Loading

Paste #pno9y11jg

  1. /**
  2.  * Make a connected lake; fill all tiles in the circular tile search that are connected.
  3.  * @param tile The tile to consider for lake making.
  4.  * @param user_data The height of the lake.
  5.  * @return Always false, so it continues searching.
  6.  */
  7. static bool MakeLake(TileIndex tile, void *user_data)
  8. {
  9.     uint height = *(uint*)user_data;
  10.     if (!IsValidTile(tile) || TileHeight(tile) != height || !IsTileFlat(tile)) return false;
  11.     if (_settings_game.game_creation.landscape == LT_TROPIC && GetTropicZone(tile) == TROPICZONE_DESERT) return false;
  12.  
  13.     for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
  14.         TileIndex t2 = tile + TileOffsByDiagDir(d);
  15.         if (IsWaterTile(t2)) {
  16.             MakeRiver(tile, Random());
  17.             return false;
  18.         }
  19.     }
  20.  
  21.     return false;
  22. }
  23.  
  24. /**
  25.  * Check whether a river could (logically) flow into a lock.
  26.  * @param tile the middle tile of a lock.
  27.  * @recursive whether the function is being called recursively.
  28.  * @return true iff the water can be flowing into a lock.
  29.  */
  30. bool FlowsLock(TileIndex tile, bool recursive = false)
  31. {
  32.     DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile));
  33.     if (dir == INVALID_DIAGDIR) return false;
  34.  
  35.     int delta_mid = TileOffsByDiagDir(dir);
  36.     if (!IsTileFlat(tile + delta_mid)) return false;
  37.     if (!IsTileFlat(tile - delta_mid)) return false;
  38.  
  39.     if (!recursive) return true;
  40.  
  41.     DiagDirection dir_rot = ChangeDiagDir(dir, DIAGDIRDIFF_90RIGHT);
  42.     int delta = TileOffsByDiagDir(dir_rot);
  43.  
  44.     for (int m = -1; m <= 1; m += 2) {
  45.         TileIndex t_dm = tile + m * delta_mid;
  46.         if (IsValidTile(t_dm)) {
  47.             if (DistanceFromEdgeDir(t_dm, dir) == 0 || DistanceFromEdgeDir(t_dm, ReverseDiagDir(dir)) == 0) {
  48.                 return false;
  49.             }
  50.  
  51.             for (int d = -1; d <= 1; d += 2) {
  52.                 if (IsValidTile(t_dm + d * delta)) {
  53.                     if (!IsTileFlat(t_dm + d * delta) &&
  54.                             (GetInclinedSlopeDirection(GetTileSlope(t_dm + d * delta)) == dir_rot ||
  55.                             GetInclinedSlopeDirection(GetTileSlope(t_dm + d * delta)) == ReverseDiagDir(dir_rot)) &&
  56.                             FlowsLock(t_dm + d * delta)) {
  57.                         return false;
  58.                     }
  59.  
  60.                     if (IsValidTile(t_dm + d * 2 * delta)) {
  61.                         if (!IsTileFlat(t_dm + d * 2 * delta) &&
  62.                                 (GetInclinedSlopeDirection(GetTileSlope(t_dm + d * 2 * delta)) == dir_rot ||
  63.                                 GetInclinedSlopeDirection(GetTileSlope(t_dm + d * 2 * delta)) == ReverseDiagDir(dir_rot)) &&
  64.                                 FlowsLock(t_dm + d * 2 * delta)) {
  65.                             return false;
  66.                         }
  67.                     }
  68.                 }
  69.             }
  70.  
  71.             TileIndex t_2dm = t_dm + m * delta_mid;
  72.             if (IsValidTile(t_2dm)) {
  73.                 if (!IsTileFlat(t_2dm)) {
  74.                     return false;
  75.                 }
  76.  
  77.                 for (int d = -1; d <= 1; d += 2) {
  78.                     if (IsValidTile(t_2dm + d * delta)) {
  79.                         if (IsTileFlat(t_dm + d * delta) && !IsTileFlat(t_2dm + d * delta)) {
  80.                             return false;
  81.                         }
  82.  
  83.                         if (!IsTileFlat(t_2dm + d * delta) &&
  84.                                 (GetInclinedSlopeDirection(GetTileSlope(t_2dm + d * delta)) == dir_rot ||
  85.                                 GetInclinedSlopeDirection(GetTileSlope(t_2dm + d * delta)) == ReverseDiagDir(dir_rot)) &&
  86.                                 FlowsLock(t_2dm + d * delta)) {
  87.                             return false;
  88.                         }
  89.                     }
  90.                 }
  91.  
  92.                 TileIndex t_3dm = t_2dm + m * delta_mid;
  93.                 if (IsValidTile(t_3dm)) {
  94.                     if ((GetInclinedSlopeDirection(GetTileSlope(t_3dm)) == dir ||
  95.                             GetInclinedSlopeDirection(GetTileSlope(t_3dm)) == ReverseDiagDir(dir)) &&
  96.                             FlowsLock(t_3dm)) {
  97.                         return false;
  98.                     }
  99.                 }
  100.  
  101.                 for (int d = -1; d <= 1; d += 2) {
  102.                     if (IsValidTile(t_3dm + d * delta)) {
  103.                         if ((GetInclinedSlopeDirection(GetTileSlope(t_3dm + d * delta)) == dir ||
  104.                                 GetInclinedSlopeDirection(GetTileSlope(t_3dm + d * delta)) == ReverseDiagDir(dir)) &&
  105.                                 FlowsLock(t_3dm + d * delta)) {
  106.                             return false;
  107.                         }
  108.                     }
  109.                 }
  110.             }
  111.         }
  112.     }
  113.  
  114.     return true;
  115. }
  116.  
  117. /**
  118.  * Check whether a river at begin could (logically) flow down to end.
  119.  * @param begin The origin of the flow.
  120.  * @param end The destination of the flow.
  121.  * @return True iff the water can be flowing down.
  122.  */
  123. static bool FlowsDown(TileIndex begin, TileIndex end)
  124. {
  125.     assert(DistanceManhattan(begin, end) == 1);
  126.  
  127.     int heightBegin;
  128.     int heightEnd;
  129.     Slope slopeBegin = GetTileSlope(begin, &heightBegin);
  130.     Slope slopeEnd   = GetTileSlope(end, &heightEnd);
  131.  
  132.     return heightEnd <= heightBegin &&
  133.             /* Slope either is inclined or flat; rivers don't support other slopes. */
  134.             (slopeEnd == SLOPE_FLAT || (IsInclinedSlope(slopeEnd) && FlowsLock(end, true))) &&
  135.             /* Slope continues, then it must be lower... or either end must be flat. */
  136.             ((slopeEnd == slopeBegin && heightEnd < heightBegin) || slopeEnd == SLOPE_FLAT || (slopeBegin == SLOPE_FLAT && GetTileMaxZ(end) == heightBegin));
  137. }

Version history

Revision # Author Created at
pdbjhwad9 Anonymous 26 Nov 2017, 15:17:24 UTC Diff

Comments