#### Paste #pmudplmuu

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. }

#### Version history

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