59
59
assert(IsNormalRoad(t));
61
61
default: NOT_REACHED();
62
case ROADTYPE_ROAD: return (RoadBits)GB(_m[t].m4, 0, 4);
63
case ROADTYPE_TRAM: return (RoadBits)GB(_m[t].m4, 4, 4);
64
case ROADTYPE_HWAY: return (RoadBits)GB(_m[t].m6, 2, 4);
62
case ROADTYPE_ROAD: return (RoadBits)GB(_m[t].m5, 0, 4);
63
case ROADTYPE_TRAM: return (RoadBits)GB(_m[t].m3, 0, 4);
68
* Get all RoadBits set on a tile except from the given RoadType
70
* @param t The tile from which we want to get the RoadBits
71
* @param rt The RoadType which we exclude from the querry
72
* @return all set RoadBits of the tile which are not from the given RoadType
74
static inline RoadBits GetOtherRoadBits(TileIndex t, RoadType rt)
76
return GetRoadBits(t, rt == ROADTYPE_ROAD ? ROADTYPE_TRAM : ROADTYPE_ROAD);
80
* Get all set RoadBits on the given tile
82
* @param tile The tile from which we want to get the RoadBits
83
* @return all set RoadBits of the tile
68
85
static inline RoadBits GetAllRoadBits(TileIndex tile)
70
return GetRoadBits(tile, ROADTYPE_ROAD) | GetRoadBits(tile, ROADTYPE_TRAM) | GetRoadBits(tile, ROADTYPE_HWAY);
87
return GetRoadBits(tile, ROADTYPE_ROAD) | GetRoadBits(tile, ROADTYPE_TRAM);
73
90
static inline void SetRoadBits(TileIndex t, RoadBits r, RoadType rt)
75
92
assert(IsNormalRoad(t)); // XXX incomplete
77
94
default: NOT_REACHED();
78
case ROADTYPE_ROAD: SB(_m[t].m4, 0, 4, r); break;
79
case ROADTYPE_TRAM: SB(_m[t].m4, 4, 4, r); break;
80
case ROADTYPE_HWAY: SB(_m[t].m6, 2, 4, r); break;
95
case ROADTYPE_ROAD: SB(_m[t].m5, 0, 4, r); break;
96
case ROADTYPE_TRAM: SB(_m[t].m3, 0, 4, r); break;
84
100
static inline RoadTypes GetRoadTypes(TileIndex t)
86
if (IsTileType(t, MP_ROAD)) {
87
return (RoadTypes)GB(_me[t].m7, 5, 3);
89
return (RoadTypes)GB(_m[t].m3, 0, 3);
102
return (RoadTypes)GB(_me[t].m7, 6, 2);
93
105
static inline void SetRoadTypes(TileIndex t, RoadTypes rt)
95
if (IsTileType(t, MP_ROAD)) {
96
SB(_me[t].m7, 5, 3, rt);
98
assert(IsTileType(t, MP_STATION) || IsTileType(t, MP_TUNNELBRIDGE));
99
SB(_m[t].m3, 0, 2, rt);
107
assert(IsTileType(t, MP_ROAD) || IsTileType(t, MP_STATION) || IsTileType(t, MP_TUNNELBRIDGE));
108
SB(_me[t].m7, 6, 2, rt);
103
111
static inline bool HasTileRoadType(TileIndex t, RoadType rt)
108
116
static inline Owner GetRoadOwner(TileIndex t, RoadType rt)
110
if (!IsTileType(t, MP_ROAD)) return GetTileOwner(t);
112
switch (GetRoadTileType(t)) {
113
119
default: NOT_REACHED();
114
case ROAD_TILE_NORMAL:
116
default: NOT_REACHED();
117
case ROADTYPE_ROAD: return (Owner)GB( _m[t].m1, 0, 5);
118
case ROADTYPE_TRAM: {
119
/* Trams don't need OWNER_TOWN, and remapping OWNER_NONE
120
* to OWNER_TOWN makes it use one bit less */
121
Owner o = (Owner)GB( _m[t].m5, 0, 4);
122
return o == OWNER_TOWN ? OWNER_NONE : o;
124
case ROADTYPE_HWAY: return (Owner)GB(_me[t].m7, 0, 5);
126
case ROAD_TILE_CROSSING:
128
default: NOT_REACHED();
129
case ROADTYPE_ROAD: return (Owner)GB( _m[t].m4, 0, 5);
130
case ROADTYPE_TRAM: {
131
/* Trams don't need OWNER_TOWN, and remapping OWNER_NONE
132
* to OWNER_TOWN makes it use one bit less */
133
Owner o = (Owner)GB( _m[t].m5, 0, 4);
134
return o == OWNER_TOWN ? OWNER_NONE : o;
136
case ROADTYPE_HWAY: return (Owner)GB(_me[t].m7, 0, 5);
138
case ROAD_TILE_DEPOT: return GetTileOwner(t);
120
case ROADTYPE_ROAD: return (Owner)GB(IsNormalRoadTile(t) ? _m[t].m1 : _me[t].m7, 0, 5);
121
case ROADTYPE_TRAM: {
122
/* Trams don't need OWNER_TOWN, and remapping OWNER_NONE
123
* to OWNER_TOWN makes it use one bit less */
124
Owner o = (Owner)GB(_m[t].m3, 4, 4);
125
return o == OWNER_TOWN ? OWNER_NONE : o;
142
130
static inline void SetRoadOwner(TileIndex t, RoadType rt, Owner o)
144
if (!IsTileType(t, MP_ROAD)) return SetTileOwner(t, o);
146
switch (GetRoadTileType(t)) {
147
133
default: NOT_REACHED();
148
case ROAD_TILE_NORMAL:
150
default: NOT_REACHED();
151
case ROADTYPE_ROAD: SB( _m[t].m1, 0, 5, o); break;
152
case ROADTYPE_TRAM: SB( _m[t].m5, 0, 4, o == OWNER_NONE ? OWNER_TOWN : o); break;
153
case ROADTYPE_HWAY: SB(_me[t].m7, 0, 5, o); break;
156
case ROAD_TILE_CROSSING:
158
default: NOT_REACHED();
159
case ROADTYPE_ROAD: SB( _m[t].m4, 0, 5, o); break;
160
/* Trams don't need OWNER_TOWN, and remapping OWNER_NONE
161
* to OWNER_TOWN makes it use one bit less */
162
case ROADTYPE_TRAM: SB( _m[t].m5, 0, 4, o == OWNER_NONE ? OWNER_TOWN : o); break;
163
case ROADTYPE_HWAY: SB(_me[t].m7, 0, 5, o); break;
166
case ROAD_TILE_DEPOT: return SetTileOwner(t, o);
134
case ROADTYPE_ROAD: SB(IsNormalRoadTile(t) ? _m[t].m1 : _me[t].m7, 0, 5, o); break;
135
case ROADTYPE_TRAM: SB(_m[t].m3, 4, 4, o == OWNER_NONE ? OWNER_TOWN : o); break;
139
static inline bool IsRoadOwner(TileIndex t, RoadType rt, Owner o)
141
assert(HasTileRoadType(t, rt));
142
return (GetRoadOwner(t, rt) == o);
145
/** Checks if given tile has town owned road
146
* @param t tile to check
147
* @return true iff tile has road and the road is owned by a town
148
* @pre IsTileType(t, MP_ROAD)
150
static inline bool HasTownOwnedRoad(TileIndex t)
152
return HasTileRoadType(t, ROADTYPE_ROAD) && IsRoadOwner(t, ROADTYPE_ROAD, OWNER_TOWN);
170
155
/** Which directions are disallowed ? */
171
156
enum DisallowedRoadDirections {
172
157
DRD_NONE, ///< None of the directions are disallowed
227
212
return AxisToTrackBits(GetCrossingRailAxis(tile));
217
* Get the reservation state of the rail crossing
218
* @pre IsLevelCrossingTile(t)
219
* @param t the crossing tile
220
* @return reservation state
222
static inline bool GetCrossingReservation(TileIndex t)
224
assert(IsLevelCrossingTile(t));
225
return HasBit(_m[t].m5, 4);
229
* Set the reservation state of the rail crossing
230
* @note Works for both waypoints and rail depots
231
* @pre IsLevelCrossingTile(t)
232
* @param t the crossing tile
233
* @param b the reservation state
235
static inline void SetCrossingReservation(TileIndex t, bool b)
237
assert(IsLevelCrossingTile(t));
238
SB(_m[t].m5, 4, 1, b ? 1 : 0);
242
* Get the reserved track bits for a rail crossing
243
* @pre IsLevelCrossingTile(t)
245
* @return reserved track bits
247
static inline TrackBits GetRailCrossingReservation(TileIndex t)
249
return GetCrossingReservation(t) ? GetCrossingRailBits(t) : TRACK_BIT_NONE;
230
252
static inline bool IsCrossingBarred(TileIndex t)
232
254
assert(IsLevelCrossing(t));
233
return HasBit(_m[t].m4, 5);
255
return HasBit(_m[t].m5, 5);
236
258
static inline void SetCrossingBarred(TileIndex t, bool barred)
238
260
assert(IsLevelCrossing(t));
239
SB(_m[t].m4, 5, 1, barred);
261
SB(_m[t].m5, 5, 1, barred ? 1 : 0);
242
264
static inline void UnbarCrossing(TileIndex t)
275
297
static inline Roadside GetRoadside(TileIndex tile)
277
return (Roadside)GB(_m[tile].m3, 4, 3);
299
return (Roadside)GB(_m[tile].m6, 3, 3);
280
302
static inline void SetRoadside(TileIndex tile, Roadside s)
282
SB(_m[tile].m3, 4, 3, s);
304
SB(_m[tile].m6, 3, 3, s);
285
307
static inline bool HasRoadWorks(TileIndex t)
360
382
bool IsPossibleCrossing(const TileIndex tile, Axis ax);
363
static inline void MakeRoadNormal(TileIndex t, RoadBits bits, RoadTypes rot, TownID town, Owner road, Owner tram, Owner hway)
385
static inline void MakeRoadNormal(TileIndex t, RoadBits bits, RoadTypes rot, TownID town, Owner road, Owner tram)
365
387
SetTileType(t, MP_ROAD);
366
388
SetTileOwner(t, road);
369
_m[t].m4 = (HasBit(rot, ROADTYPE_TRAM) ? bits : 0) << 4 | (HasBit(rot, ROADTYPE_ROAD) ? bits : 0);
370
_m[t].m5 = ROAD_TILE_NORMAL << 6;
390
_m[t].m3 = (HasBit(rot, ROADTYPE_TRAM) ? bits : 0);
392
_m[t].m5 = (HasBit(rot, ROADTYPE_ROAD) ? bits : 0) | ROAD_TILE_NORMAL << 6;
393
SB(_m[t].m6, 2, 4, 0);
394
_me[t].m7 = rot << 6;
371
395
SetRoadOwner(t, ROADTYPE_TRAM, tram);
372
SB(_m[t].m6, 2, 4, HasBit(rot, ROADTYPE_HWAY) ? bits : 0);
373
_me[t].m7 = rot << 5 | hway;
377
static inline void MakeRoadCrossing(TileIndex t, Owner road, Owner tram, Owner hway, Owner rail, Axis roaddir, RailType rat, RoadTypes rot, uint town)
399
static inline void MakeRoadCrossing(TileIndex t, Owner road, Owner tram, Owner rail, Axis roaddir, RailType rat, RoadTypes rot, uint town)
379
401
SetTileType(t, MP_ROAD);
380
402
SetTileOwner(t, rail);
383
_m[t].m4 = roaddir << 6 | road;
384
_m[t].m5 = ROAD_TILE_CROSSING << 6;
406
_m[t].m5 = ROAD_TILE_CROSSING << 6 | roaddir;
407
SB(_m[t].m6, 2, 4, 0);
408
_me[t].m7 = rot << 6 | road;
385
409
SetRoadOwner(t, ROADTYPE_TRAM, tram);
386
SB(_m[t].m6, 2, 4, 0);
387
_me[t].m7 = rot << 5 | hway;
391
static inline void MakeRoadDepot(TileIndex t, Owner owner, DiagDirection dir, RoadType rt)
413
static inline void MakeRoadDepot(TileIndex t, Owner owner, DiagDirection dir, RoadType rt, TownID town)
393
415
SetTileType(t, MP_ROAD);
394
416
SetTileOwner(t, owner);
398
420
_m[t].m5 = ROAD_TILE_DEPOT << 6 | dir;
399
421
SB(_m[t].m6, 2, 4, 0);
400
_me[t].m7 = RoadTypeToRoadTypes(rt) << 5;
422
_me[t].m7 = RoadTypeToRoadTypes(rt) << 6 | owner;
423
SetRoadOwner(t, ROADTYPE_TRAM, owner);
403
426
#endif /* ROAD_MAP_H */
added
removed
src/road_map.h
