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