31 static inline bool IsLevelCrossingTile(TileIndex t) |
31 static inline bool IsLevelCrossingTile(TileIndex t) |
32 { |
32 { |
33 return IsTileType(t, MP_STREET) && IsLevelCrossing(t); |
33 return IsTileType(t, MP_STREET) && IsLevelCrossing(t); |
34 } |
34 } |
35 |
35 |
36 static inline RoadBits GetRoadBits(TileIndex t) |
36 static inline RoadBits GetRoadBits(TileIndex t, RoadType rt) |
37 { |
37 { |
38 assert(GetRoadTileType(t) == ROAD_TILE_NORMAL); |
38 assert(GetRoadTileType(t) == ROAD_TILE_NORMAL); |
39 return (RoadBits)GB(_m[t].m5, 0, 4); |
39 switch (rt) { |
40 } |
40 default: NOT_REACHED(); |
41 |
41 case ROADTYPE_ROAD: return (RoadBits)GB(_m[t].m4, 0, 4); |
42 static inline void SetRoadBits(TileIndex t, RoadBits r) |
42 case ROADTYPE_TRAM: return (RoadBits)GB(_m[t].m4, 4, 4); |
|
43 case ROADTYPE_HWAY: return (RoadBits)GB(_m[t].m6, 2, 4); |
|
44 } |
|
45 } |
|
46 |
|
47 static inline RoadBits GetAllRoadBits(TileIndex tile) |
|
48 { |
|
49 return GetRoadBits(tile, ROADTYPE_ROAD) | GetRoadBits(tile, ROADTYPE_TRAM) | GetRoadBits(tile, ROADTYPE_HWAY); |
|
50 } |
|
51 |
|
52 static inline void SetRoadBits(TileIndex t, RoadBits r, RoadType rt) |
43 { |
53 { |
44 assert(GetRoadTileType(t) == ROAD_TILE_NORMAL); // XXX incomplete |
54 assert(GetRoadTileType(t) == ROAD_TILE_NORMAL); // XXX incomplete |
45 SB(_m[t].m5, 0, 4, r); |
55 switch (rt) { |
46 } |
56 default: NOT_REACHED(); |
47 |
57 case ROADTYPE_ROAD: SB(_m[t].m4, 0, 4, r); break; |
|
58 case ROADTYPE_TRAM: SB(_m[t].m4, 4, 4, r); break; |
|
59 case ROADTYPE_HWAY: SB(_m[t].m6, 2, 4, r); break; |
|
60 } |
|
61 } |
|
62 |
|
63 static inline RoadTypes GetRoadTypes(TileIndex t) |
|
64 { |
|
65 if (IsTileType(t, MP_STREET)) { |
|
66 return (RoadTypes)GB(_me[t].m7, 5, 3); |
|
67 } else { |
|
68 return (RoadTypes)GB(_m[t].m3, 0, 3); |
|
69 } |
|
70 } |
|
71 |
|
72 static inline void SetRoadTypes(TileIndex t, RoadTypes rt) |
|
73 { |
|
74 if (IsTileType(t, MP_STREET)) { |
|
75 SB(_me[t].m7, 5, 3, rt); |
|
76 } else { |
|
77 assert(IsTileType(t, MP_STATION) || IsTileType(t, MP_TUNNELBRIDGE)); |
|
78 SB(_m[t].m3, 0, 2, rt); |
|
79 } |
|
80 } |
|
81 |
|
82 static inline Owner GetRoadOwner(TileIndex t, RoadType rt) |
|
83 { |
|
84 if (!IsTileType(t, MP_STREET)) return GetTileOwner(t); |
|
85 |
|
86 switch (GetRoadTileType(t)) { |
|
87 default: NOT_REACHED(); |
|
88 case ROAD_TILE_NORMAL: |
|
89 switch (rt) { |
|
90 default: NOT_REACHED(); |
|
91 case ROADTYPE_ROAD: return (Owner)GB( _m[t].m1, 0, 5); |
|
92 case ROADTYPE_TRAM: return (Owner)GB( _m[t].m5, 0, 5); |
|
93 case ROADTYPE_HWAY: return (Owner)GB(_me[t].m7, 0, 5); |
|
94 } |
|
95 case ROAD_TILE_CROSSING: |
|
96 switch (rt) { |
|
97 default: NOT_REACHED(); |
|
98 case ROADTYPE_ROAD: return (Owner)GB( _m[t].m4, 0, 5); |
|
99 case ROADTYPE_TRAM: return (Owner)GB( _m[t].m5, 0, 5); |
|
100 case ROADTYPE_HWAY: return (Owner)GB(_me[t].m7, 0, 5); |
|
101 } |
|
102 case ROAD_TILE_DEPOT: return GetTileOwner(t); |
|
103 } |
|
104 } |
|
105 |
|
106 static inline void SetRoadOwner(TileIndex t, RoadType rt, Owner o) |
|
107 { |
|
108 if (!IsTileType(t, MP_STREET)) return SetTileOwner(t, o); |
|
109 |
|
110 switch (GetRoadTileType(t)) { |
|
111 default: NOT_REACHED(); |
|
112 case ROAD_TILE_NORMAL: |
|
113 switch (rt) { |
|
114 default: NOT_REACHED(); |
|
115 case ROADTYPE_ROAD: SB( _m[t].m1, 0, 5, o); break; |
|
116 case ROADTYPE_TRAM: SB( _m[t].m5, 0, 5, o); break; |
|
117 case ROADTYPE_HWAY: SB(_me[t].m7, 0, 5, o); break; |
|
118 } |
|
119 break; |
|
120 case ROAD_TILE_CROSSING: |
|
121 switch (rt) { |
|
122 default: NOT_REACHED(); |
|
123 case ROADTYPE_ROAD: SB( _m[t].m4, 0, 5, o); break; |
|
124 case ROADTYPE_TRAM: SB( _m[t].m5, 0, 5, o); break; |
|
125 case ROADTYPE_HWAY: SB(_me[t].m7, 0, 5, o); break; |
|
126 } |
|
127 break; |
|
128 case ROAD_TILE_DEPOT: return SetTileOwner(t, o); |
|
129 } |
|
130 } |
48 |
131 |
49 static inline Axis GetCrossingRoadAxis(TileIndex t) |
132 static inline Axis GetCrossingRoadAxis(TileIndex t) |
50 { |
133 { |
51 assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); |
134 assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); |
52 return (Axis)GB(_m[t].m5, 3, 1); |
135 return (Axis)GB(_m[t].m4, 6, 1); |
53 } |
136 } |
54 |
137 |
55 static inline RoadBits GetCrossingRoadBits(TileIndex tile) |
138 static inline RoadBits GetCrossingRoadBits(TileIndex tile) |
56 { |
139 { |
57 return GetCrossingRoadAxis(tile) == AXIS_X ? ROAD_X : ROAD_Y; |
140 return GetCrossingRoadAxis(tile) == AXIS_X ? ROAD_X : ROAD_Y; |
61 { |
144 { |
62 return AxisToTrackBits(OtherAxis(GetCrossingRoadAxis(tile))); |
145 return AxisToTrackBits(OtherAxis(GetCrossingRoadAxis(tile))); |
63 } |
146 } |
64 |
147 |
65 |
148 |
66 // TODO swap owner of road and rail |
149 static inline void UnbarCrossing(TileIndex t) |
67 static inline Owner GetCrossingRoadOwner(TileIndex t) |
|
68 { |
150 { |
69 assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); |
151 assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); |
70 return (Owner)_m[t].m4; |
152 CLRBIT(_m[t].m4, 5); |
71 } |
153 } |
72 |
154 |
73 static inline void SetCrossingRoadOwner(TileIndex t, Owner o) |
155 static inline void BarCrossing(TileIndex t) |
74 { |
156 { |
75 assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); |
157 assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); |
76 _m[t].m4 = o; |
158 SETBIT(_m[t].m4, 5); |
77 } |
159 } |
78 |
160 |
79 static inline void UnbarCrossing(TileIndex t) |
161 static inline bool IsCrossingBarred(TileIndex t) |
80 { |
162 { |
81 assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); |
163 assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); |
82 CLRBIT(_m[t].m5, 2); |
164 return HASBIT(_m[t].m4, 5); |
83 } |
|
84 |
|
85 static inline void BarCrossing(TileIndex t) |
|
86 { |
|
87 assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); |
|
88 SETBIT(_m[t].m5, 2); |
|
89 } |
|
90 |
|
91 static inline bool IsCrossingBarred(TileIndex t) |
|
92 { |
|
93 assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); |
|
94 return HASBIT(_m[t].m5, 2); |
|
95 } |
165 } |
96 |
166 |
97 #define IsOnDesert IsOnSnow |
167 #define IsOnDesert IsOnSnow |
98 static inline bool IsOnSnow(TileIndex t) |
168 static inline bool IsOnSnow(TileIndex t) |
99 { |
169 { |
172 * - road depots: entrance is treated as road piece |
242 * - road depots: entrance is treated as road piece |
173 * - road tunnels: entrance is treated as road piece |
243 * - road tunnels: entrance is treated as road piece |
174 * - bridge ramps: start of the ramp is treated as road piece |
244 * - bridge ramps: start of the ramp is treated as road piece |
175 * - bridge middle parts: bridge itself is ignored |
245 * - bridge middle parts: bridge itself is ignored |
176 * @param tile the tile to get the road bits for |
246 * @param tile the tile to get the road bits for |
|
247 * @param rt the road type to get the road bits form |
177 * @return the road bits of the given tile |
248 * @return the road bits of the given tile |
178 */ |
249 */ |
179 RoadBits GetAnyRoadBits(TileIndex tile); |
250 RoadBits GetAnyRoadBits(TileIndex tile, RoadType rt); |
180 |
251 |
181 /** |
252 /** |
182 * Get the accessible track bits for the given tile. |
253 * Get the accessible track bits for the given tile. |
183 * Special behaviour: |
254 * Special behaviour: |
184 * - road depots: no track bits |
255 * - road depots: no track bits |
185 * - non-drive-through stations: no track bits |
256 * - non-drive-through stations: no track bits |
186 * @param tile the tile to get the track bits for |
257 * @param tile the tile to get the track bits for |
187 * @return the track bits for the given tile |
258 * @return the track bits for the given tile |
188 */ |
259 */ |
189 TrackBits GetAnyRoadTrackBits(TileIndex tile); |
260 TrackBits GetAnyRoadTrackBits(TileIndex tile, RoadType rt); |
190 |
261 |
191 |
262 |
192 static inline void MakeRoadNormal(TileIndex t, Owner owner, RoadBits bits, TownID town) |
263 static inline void MakeRoadNormal(TileIndex t, RoadBits bits, RoadTypes rot, TownID town, Owner road, Owner tram, Owner hway) |
193 { |
264 { |
194 SetTileType(t, MP_STREET); |
265 SetTileType(t, MP_STREET); |
195 SetTileOwner(t, owner); |
266 SetTileOwner(t, road); |
196 _m[t].m2 = town; |
267 _m[t].m2 = town; |
197 _m[t].m3 = 0 << 7 | 0 << 4 | 0; |
268 _m[t].m3 = 0; |
198 _m[t].m4 = 0; |
269 _m[t].m4 = (HASBIT(rot, ROADTYPE_TRAM) ? bits : 0) << 4 | (HASBIT(rot, ROADTYPE_ROAD) ? bits : 0); |
199 _m[t].m5 = ROAD_TILE_NORMAL << 4 | bits; |
270 _m[t].m5 = ROAD_TILE_NORMAL << 6 | tram; |
200 } |
271 SB(_m[t].m6, 2, 4, HASBIT(rot, ROADTYPE_HWAY) ? bits : 0); |
201 |
272 _me[t].m7 = rot << 5 | hway; |
202 |
273 } |
203 static inline void MakeRoadCrossing(TileIndex t, Owner road, Owner rail, Axis roaddir, RailType rt, uint town) |
274 |
|
275 |
|
276 static inline void MakeRoadCrossing(TileIndex t, Owner road, Owner tram, Owner hway, Owner rail, Axis roaddir, RailType rat, RoadTypes rot, uint town) |
204 { |
277 { |
205 SetTileType(t, MP_STREET); |
278 SetTileType(t, MP_STREET); |
206 SetTileOwner(t, rail); |
279 SetTileOwner(t, rail); |
207 _m[t].m2 = town; |
280 _m[t].m2 = town; |
208 _m[t].m3 = 0 << 7 | 0 << 4 | rt; |
281 _m[t].m3 = rat; |
209 _m[t].m4 = road; |
282 _m[t].m4 = roaddir << 6 | road; |
210 _m[t].m5 = ROAD_TILE_CROSSING << 4 | roaddir << 3 | 0 << 2; |
283 _m[t].m5 = ROAD_TILE_CROSSING << 6 | tram; |
211 } |
284 SB(_m[t].m6, 2, 4, 0); |
212 |
285 _me[t].m7 = rot << 5 | hway; |
213 |
286 } |
214 static inline void MakeRoadDepot(TileIndex t, Owner owner, DiagDirection dir) |
287 |
|
288 |
|
289 static inline void MakeRoadDepot(TileIndex t, Owner owner, DiagDirection dir, RoadType rt) |
215 { |
290 { |
216 SetTileType(t, MP_STREET); |
291 SetTileType(t, MP_STREET); |
217 SetTileOwner(t, owner); |
292 SetTileOwner(t, owner); |
218 _m[t].m2 = 0; |
293 _m[t].m2 = 0; |
219 _m[t].m3 = 0; |
294 _m[t].m3 = 0; |
220 _m[t].m4 = 0; |
295 _m[t].m4 = 0; |
221 _m[t].m5 = ROAD_TILE_DEPOT << 4 | dir; |
296 _m[t].m5 = ROAD_TILE_DEPOT << 6 | dir; |
|
297 SB(_m[t].m6, 2, 4, 0); |
|
298 _me[t].m7 = RoadTypeToRoadTypes(rt) << 5; |
222 } |
299 } |
223 |
300 |
224 #endif /* ROAD_MAP_H */ |
301 #endif /* ROAD_MAP_H */ |