Loading

Revision differences

Return to paste
Old revision #ps9wzxlinNew revision #pmudplmuu
  1static 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  
1/**  9/**  
2 * Check whether a river could (logically) flow into a lock.  10 * Check whether a river could (logically) flow into a lock.  
3 * @param tile the middle tile of a lock.  11 * @param tile the middle tile of a lock.  
… … 
21    for (int m = -1; m <= 1; m += 2) {  29    for (int m = -1; m <= 1; m += 2) {  
22        TileIndex t_dm = tile + m * delta_mid;  30        TileIndex t_dm = tile + m * delta_mid;  
23        if (IsValidTile(t_dm)) {  31        if (IsValidTile(t_dm)) {  
24            if (DistanceFromEdgeDir(t_dm, dir) == 0 || DistanceFromEdgeDir(t_dm, ReverseDiagDir(dir)) == 0) {  24            if (DistanceFromEdgeDir(t_dm, dir) == 0 || DistanceFromEdgeDir(t_dm, ReverseDiagDir(dir)) == 0) return false;
25                return false;    
26            }    
27  33  
28            for (int d = -1; d <= 1; d += 2) {  34            for (int d = -1; d <= 1; d += 2) {  
29                if (IsValidTile(t_dm + d * delta)) {  35                if (IsValidTile(t_dm + d * delta)) {  
30                    if (!IsTileFlat(t_dm + d * delta) &&  30                    if (!AdjacentLock(t_dm + d * delta, dir_rot, true)) return false;
31                            (GetInclinedSlopeDirection(GetTileSlope(t_dm + d * delta)) == dir_rot ||    
32                            GetInclinedSlopeDirection(GetTileSlope(t_dm + d * delta)) == ReverseDiagDir(dir_rot)) &&    
33                            FlowsLock(t_dm + d * delta)) {    
34                        return false;    
35                    }    
36  37  
37                    if (IsValidTile(t_dm + d * 2 * delta)) {  38                    if (IsValidTile(t_dm + d * 2 * delta)) {  
38                        if (!IsTileFlat(t_dm + d * 2 * delta) &&  38                        if (!AdjacentLock(t_dm + d * 2 * delta, dir_rot, true)) return false;
39                            (GetInclinedSlopeDirection(GetTileSlope(t_dm + d * 2 * delta)) == dir_rot ||    
40                                GetInclinedSlopeDirection(GetTileSlope(t_dm + d * 2 * delta)) == ReverseDiagDir(dir_rot)) &&    
41                            FlowsLock(t_dm + d * 2 * delta)) {    
42                            return false;    
43                        }    
44                    }  40                    }  
45                }  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//                }  
46            }  60            }  
47  61  
48            TileIndex t_2dm = t_dm + m * delta_mid;  62            TileIndex t_2dm = t_dm + m * delta_mid;  
49            if (IsValidTile(t_2dm)) {  63            if (IsValidTile(t_2dm)) {  
50                if (!IsTileFlat(t_2dm)) {  50                if (!IsTileFlat(t_2dm)) return false;
51                    return false;    
52                }    
53  65  
54                for (int d = -1; d <= 1; d += 2) {  66                for (int d = -1; d <= 1; d += 2) {  
55                    if (IsValidTile(t_2dm + d * delta)) {  67                    if (IsValidTile(t_2dm + d * delta)) {  
56                        if (IsTileFlat(t_dm + d * delta) && !IsTileFlat(t_2dm + d * delta)) {  56                        if (IsTileFlat(t_dm + d * delta) && !IsTileFlat(t_2dm + d * delta)) return false;
57                            return false;    
58                        }    
59  69  
60                        if (!IsTileFlat(t_2dm + d * delta) &&  70                        if (!AdjacentLock(t_2dm + d * delta, dir_rot, true)) return false;
61                                (GetInclinedSlopeDirection(GetTileSlope(t_2dm + d * delta)) == dir_rot ||  71//                        if (!IsTileFlat(t_2dm + d * delta) &&
62                                GetInclinedSlopeDirection(GetTileSlope(t_2dm + d * delta)) == ReverseDiagDir(dir_rot)) &&  72//                                (GetInclinedSlopeDirection(GetTileSlope(t_2dm + d * delta)) == dir_rot ||
63                                FlowsLock(t_2dm + d * delta)) {  73//                                GetInclinedSlopeDirection(GetTileSlope(t_2dm + d * delta)) == ReverseDiagDir(dir_rot)) &&
64                            return false;  74//                                FlowsLock(t_2dm + d * delta)) {
65                        }  75//                            return false;
   76//                        }
66                    }  77                    }  
67                }  78                }  
68  79  
69                TileIndex t_3dm = t_2dm + m * delta_mid;  80                TileIndex t_3dm = t_2dm + m * delta_mid;  
70                if (IsValidTile(t_3dm)) {  81                if (IsValidTile(t_3dm)) {  
71                    if ((GetInclinedSlopeDirection(GetTileSlope(t_3dm)) == dir ||  82                    if (!AdjacentLock(t_3dm, dir, true)) return false;
72                            GetInclinedSlopeDirection(GetTileSlope(t_3dm)) == ReverseDiagDir(dir)) &&  83//                    if ((GetInclinedSlopeDirection(GetTileSlope(t_3dm)) == dir ||
73                            FlowsLock(t_3dm)) {  84//                            GetInclinedSlopeDirection(GetTileSlope(t_3dm)) == ReverseDiagDir(dir)) &&
74                        return false;  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//                        }
75                    }  98                    }  
76                }  99                }  
77            }  100            }  
… … 
79    }  102    }  
80  103  
81    return true;  104    return true;  
82}    
83    
84/**    
85 * Check whether a river at begin could (logically) flow down to end.    
86 * @param begin The origin of the flow.    
87 * @param end The destination of the flow.    
88 * @return True iff the water can be flowing down.    
89 */    
90static bool FlowsDown(TileIndex begin, TileIndex end)    
91{    
92    assert(DistanceManhattan(begin, end) == 1);    
93    
94    int heightBegin;    
95    int heightEnd;    
96    Slope slopeBegin = GetTileSlope(begin, &heightBegin);    
97    Slope slopeEnd   = GetTileSlope(end, &heightEnd);    
98    
99    return heightEnd <= heightBegin &&    
100            /* Slope either is inclined or flat; rivers don't support other slopes. */    
101            (slopeEnd == SLOPE_FLAT || (IsInclinedSlope(slopeEnd) && FlowsLock(end, true))) &&    
102            /* Slope continues, then it must be lower... or either end must be flat. */    
103            ((slopeEnd == slopeBegin && heightEnd < heightBegin) || slopeEnd == SLOPE_FLAT || (slopeBegin == SLOPE_FLAT && GetTileMaxZ(end) == heightBegin));    
104} 105}