Loading

Paste #pmudplmuu

Wrap Raw Revise
  1. static bool AdjacentLock(TileIndex t, DiagDirection d, bool check_tile_flat) {
  2.     if (check_tile_flat && IsTileFlat(t)) return true;
  3.     DiagDirection ts = GetInclinedSlopeDirection(GetTileSlope(t));
  4.     if (ts != d) return true;
  5.     if (ts != ReverseDiagDir(d)) return true;
  6.     return !FlowsLock(t);
  7. }
  8.  
  9. /**
  10.  * Check whether a river could (logically) flow into a lock.
  11.  * @param tile the middle tile of a lock.
  12.  * @recursive whether the function is being called recursively.
  13.  * @return true iff the water can be flowing into a lock.
  14.  */
  15. bool FlowsLock(TileIndex tile, bool recursive = false)
  16. {
  17.     DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile));
  18.     if (dir == INVALID_DIAGDIR) return false;
  19.  
  20.     int delta_mid = TileOffsByDiagDir(dir);
  21.     if (!IsTileFlat(tile + delta_mid)) return false;
  22.     if (!IsTileFlat(tile - delta_mid)) return false;
  23.  
  24.     if (!recursive) return true;
  25.  
  26.     DiagDirection dir_rot = ChangeDiagDir(dir, DIAGDIRDIFF_90RIGHT);
  27.     int delta = TileOffsByDiagDir(dir_rot);
  28.  
  29.     for (int m = -1; m <= 1; m += 2) {
  30.         TileIndex t_dm = tile + m * delta_mid;
  31.         if (IsValidTile(t_dm)) {
  32.             if (DistanceFromEdgeDir(t_dm, dir) == 0 || DistanceFromEdgeDir(t_dm, ReverseDiagDir(dir)) == 0) return false;
  33.  
  34.             for (int d = -1; d <= 1; d += 2) {
  35.                 if (IsValidTile(t_dm + d * delta)) {
  36.                     if (!AdjacentLock(t_dm + d * delta, dir_rot, true)) return false;
  37.  
  38.                     if (IsValidTile(t_dm + d * 2 * delta)) {
  39.                         if (!AdjacentLock(t_dm + d * 2 * delta, dir_rot, true)) return false;
  40.                     }
  41.                 }
  42.  
  43. //              if (IsValidTile(t_dm + d * delta)) {
  44. //                  if (!IsTileFlat(t_dm + d * delta) &&
  45. //                          (GetInclinedSlopeDirection(GetTileSlope(t_dm + d * delta)) == dir_rot ||
  46. //                          GetInclinedSlopeDirection(GetTileSlope(t_dm + d * delta)) == ReverseDiagDir(dir_rot)) &&
  47. //                          FlowsLock(t_dm + d * delta)) {
  48. //                      return false;
  49. //                  }
  50.  
  51. //                  if (IsValidTile(t_dm + d * 2 * delta)) {
  52. //                      if (!IsTileFlat(t_dm + d * 2 * delta) &&
  53. //                              (GetInclinedSlopeDirection(GetTileSlope(t_dm + d * 2 * delta)) == dir_rot ||
  54. //                              GetInclinedSlopeDirection(GetTileSlope(t_dm + d * 2 * delta)) == ReverseDiagDir(dir_rot)) &&
  55. //                              FlowsLock(t_dm + d * 2 * delta)) {
  56. //                          return false;
  57. //                      }
  58. //                  }
  59. //              }
  60.             }
  61.  
  62.             TileIndex t_2dm = t_dm + m * delta_mid;
  63.             if (IsValidTile(t_2dm)) {
  64.                 if (!IsTileFlat(t_2dm)) return false;
  65.  
  66.                 for (int d = -1; d <= 1; d += 2) {
  67.                     if (IsValidTile(t_2dm + d * delta)) {
  68.                         if (IsTileFlat(t_dm + d * delta) && !IsTileFlat(t_2dm + d * delta)) return false;
  69.  
  70.                         if (!AdjacentLock(t_2dm + d * delta, dir_rot, true)) return false;
  71. //                      if (!IsTileFlat(t_2dm + d * delta) &&
  72. //                              (GetInclinedSlopeDirection(GetTileSlope(t_2dm + d * delta)) == dir_rot ||
  73. //                              GetInclinedSlopeDirection(GetTileSlope(t_2dm + d * delta)) == ReverseDiagDir(dir_rot)) &&
  74. //                              FlowsLock(t_2dm + d * delta)) {
  75. //                          return false;
  76. //                      }
  77.                     }
  78.                 }
  79.  
  80.                 TileIndex t_3dm = t_2dm + m * delta_mid;
  81.                 if (IsValidTile(t_3dm)) {
  82.                     if (!AdjacentLock(t_3dm, dir, true)) return false;
  83. //                  if ((GetInclinedSlopeDirection(GetTileSlope(t_3dm)) == dir ||
  84. //                          GetInclinedSlopeDirection(GetTileSlope(t_3dm)) == ReverseDiagDir(dir)) &&
  85. //                          FlowsLock(t_3dm)) {
  86. //                      return false;
  87. //                  }
  88.                 }
  89.  
  90.                 for (int d = -1; d <= 1; d += 2) {
  91.                     if (IsValidTile(t_3dm + d * delta)) {
  92.                         if (!AdjacentLock(t_3dm + d * delta, dir, true)) return false;
  93. //                      if ((GetInclinedSlopeDirection(GetTileSlope(t_3dm + d * delta)) == dir ||
  94. //                              GetInclinedSlopeDirection(GetTileSlope(t_3dm + d * delta)) == ReverseDiagDir(dir)) &&
  95. //                              FlowsLock(t_3dm + d * delta)) {
  96. //                          return false;
  97. //                      }
  98.                     }
  99.                 }
  100.             }
  101.         }
  102.     }
  103.  
  104.     return true;
  105. }
Posted by Anonymous at 26 Nov 2017, 18:57:55 UTC
Language: cpp • Views: 665

Version history

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

Comments