From d86b5e5e9328e85faa1bf97615b8c796fc874863 Mon Sep 17 00:00:00 2001 From: rubidium Date: Sun, 20 May 2007 19:14:08 +0000 Subject: (svn r9892) -Codechange: lots of ground work for allowing multiple types of "road" with multiple owners on a single tile. --- src/road_map.h | 147 +++++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 111 insertions(+), 36 deletions(-) (limited to 'src/road_map.h') diff --git a/src/road_map.h b/src/road_map.h index 88e0a0295..15edb8e43 100644 --- a/src/road_map.h +++ b/src/road_map.h @@ -18,9 +18,9 @@ enum RoadTileType { }; static inline RoadTileType GetRoadTileType(TileIndex t) -{ + { assert(IsTileType(t, MP_STREET)); - return (RoadTileType)GB(_m[t].m5, 4, 4); + return (RoadTileType)GB(_m[t].m5, 6, 2); } static inline bool IsLevelCrossing(TileIndex t) @@ -33,65 +33,133 @@ static inline bool IsLevelCrossingTile(TileIndex t) return IsTileType(t, MP_STREET) && IsLevelCrossing(t); } -static inline RoadBits GetRoadBits(TileIndex t) +static inline RoadBits GetRoadBits(TileIndex t, RoadType rt) { assert(GetRoadTileType(t) == ROAD_TILE_NORMAL); - return (RoadBits)GB(_m[t].m5, 0, 4); + switch (rt) { + default: NOT_REACHED(); + case ROADTYPE_ROAD: return (RoadBits)GB(_m[t].m4, 0, 4); + case ROADTYPE_TRAM: return (RoadBits)GB(_m[t].m4, 4, 4); + case ROADTYPE_HWAY: return (RoadBits)GB(_m[t].m6, 2, 4); + } } -static inline void SetRoadBits(TileIndex t, RoadBits r) +static inline RoadBits GetAllRoadBits(TileIndex tile) { - assert(GetRoadTileType(t) == ROAD_TILE_NORMAL); // XXX incomplete - SB(_m[t].m5, 0, 4, r); + return GetRoadBits(tile, ROADTYPE_ROAD) | GetRoadBits(tile, ROADTYPE_TRAM) | GetRoadBits(tile, ROADTYPE_HWAY); } +static inline void SetRoadBits(TileIndex t, RoadBits r, RoadType rt) +{ + assert(GetRoadTileType(t) == ROAD_TILE_NORMAL); // XXX incomplete + switch (rt) { + default: NOT_REACHED(); + case ROADTYPE_ROAD: SB(_m[t].m4, 0, 4, r); break; + case ROADTYPE_TRAM: SB(_m[t].m4, 4, 4, r); break; + case ROADTYPE_HWAY: SB(_m[t].m6, 2, 4, r); break; + } +} -static inline Axis GetCrossingRoadAxis(TileIndex t) +static inline RoadTypes GetRoadTypes(TileIndex t) { - assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); - return (Axis)GB(_m[t].m5, 3, 1); + if (IsTileType(t, MP_STREET)) { + return (RoadTypes)GB(_me[t].m7, 5, 3); + } else { + return (RoadTypes)GB(_m[t].m3, 0, 3); + } } -static inline RoadBits GetCrossingRoadBits(TileIndex tile) +static inline void SetRoadTypes(TileIndex t, RoadTypes rt) { - return GetCrossingRoadAxis(tile) == AXIS_X ? ROAD_X : ROAD_Y; + if (IsTileType(t, MP_STREET)) { + SB(_me[t].m7, 5, 3, rt); + } else { + assert(IsTileType(t, MP_STATION) || IsTileType(t, MP_TUNNELBRIDGE)); + SB(_m[t].m3, 0, 2, rt); + } } -static inline TrackBits GetCrossingRailBits(TileIndex tile) +static inline Owner GetRoadOwner(TileIndex t, RoadType rt) { - return AxisToTrackBits(OtherAxis(GetCrossingRoadAxis(tile))); + if (!IsTileType(t, MP_STREET)) return GetTileOwner(t); + + switch (GetRoadTileType(t)) { + default: NOT_REACHED(); + case ROAD_TILE_NORMAL: + switch (rt) { + default: NOT_REACHED(); + case ROADTYPE_ROAD: return (Owner)GB( _m[t].m1, 0, 5); + case ROADTYPE_TRAM: return (Owner)GB( _m[t].m5, 0, 5); + case ROADTYPE_HWAY: return (Owner)GB(_me[t].m7, 0, 5); + } + case ROAD_TILE_CROSSING: + switch (rt) { + default: NOT_REACHED(); + case ROADTYPE_ROAD: return (Owner)GB( _m[t].m4, 0, 5); + case ROADTYPE_TRAM: return (Owner)GB( _m[t].m5, 0, 5); + case ROADTYPE_HWAY: return (Owner)GB(_me[t].m7, 0, 5); + } + case ROAD_TILE_DEPOT: return GetTileOwner(t); + } } +static inline void SetRoadOwner(TileIndex t, RoadType rt, Owner o) +{ + if (!IsTileType(t, MP_STREET)) return SetTileOwner(t, o); + + switch (GetRoadTileType(t)) { + default: NOT_REACHED(); + case ROAD_TILE_NORMAL: + switch (rt) { + default: NOT_REACHED(); + case ROADTYPE_ROAD: SB( _m[t].m1, 0, 5, o); break; + case ROADTYPE_TRAM: SB( _m[t].m5, 0, 5, o); break; + case ROADTYPE_HWAY: SB(_me[t].m7, 0, 5, o); break; + } + case ROAD_TILE_CROSSING: + switch (rt) { + default: NOT_REACHED(); + case ROADTYPE_ROAD: SB( _m[t].m4, 0, 5, o); break; + case ROADTYPE_TRAM: SB( _m[t].m5, 0, 5, o); break; + case ROADTYPE_HWAY: SB(_me[t].m7, 0, 5, o); break; + } + case ROAD_TILE_DEPOT: return SetTileOwner(t, o); + } +} -// TODO swap owner of road and rail -static inline Owner GetCrossingRoadOwner(TileIndex t) +static inline Axis GetCrossingRoadAxis(TileIndex t) { assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); - return (Owner)_m[t].m4; + return (Axis)GB(_m[t].m4, 6, 1); } -static inline void SetCrossingRoadOwner(TileIndex t, Owner o) +static inline RoadBits GetCrossingRoadBits(TileIndex tile) { - assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); - _m[t].m4 = o; + return GetCrossingRoadAxis(tile) == AXIS_X ? ROAD_X : ROAD_Y; +} + +static inline TrackBits GetCrossingRailBits(TileIndex tile) +{ + return AxisToTrackBits(OtherAxis(GetCrossingRoadAxis(tile))); } + static inline void UnbarCrossing(TileIndex t) { assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); - CLRBIT(_m[t].m5, 2); + CLRBIT(_m[t].m4, 5); } static inline void BarCrossing(TileIndex t) { assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); - SETBIT(_m[t].m5, 2); + SETBIT(_m[t].m4, 5); } static inline bool IsCrossingBarred(TileIndex t) { assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); - return HASBIT(_m[t].m5, 2); + return HASBIT(_m[t].m4, 5); } #define IsOnDesert IsOnSnow @@ -174,9 +242,10 @@ static inline DiagDirection GetRoadDepotDirection(TileIndex t) * - bridge ramps: start of the ramp is treated as road piece * - bridge middle parts: bridge itself is ignored * @param tile the tile to get the road bits for + * @param rt the road type to get the road bits form * @return the road bits of the given tile */ -RoadBits GetAnyRoadBits(TileIndex tile); +RoadBits GetAnyRoadBits(TileIndex tile, RoadType rt); /** * Get the accessible track bits for the given tile. @@ -186,39 +255,45 @@ RoadBits GetAnyRoadBits(TileIndex tile); * @param tile the tile to get the track bits for * @return the track bits for the given tile */ -TrackBits GetAnyRoadTrackBits(TileIndex tile); +TrackBits GetAnyRoadTrackBits(TileIndex tile, RoadType rt); -static inline void MakeRoadNormal(TileIndex t, Owner owner, RoadBits bits, TownID town) +static inline void MakeRoadNormal(TileIndex t, RoadBits bits, RoadTypes rot, TownID town, Owner road, Owner tram, Owner hway) { SetTileType(t, MP_STREET); - SetTileOwner(t, owner); + SetTileOwner(t, road); _m[t].m2 = town; - _m[t].m3 = 0 << 7 | 0 << 4 | 0; - _m[t].m4 = 0; - _m[t].m5 = ROAD_TILE_NORMAL << 4 | bits; + _m[t].m3 = 0; + _m[t].m4 = (HASBIT(rot, ROADTYPE_ROAD) ? bits : 0) << 4 | HASBIT(rot, ROADTYPE_TRAM) ? bits : 0; + _m[t].m5 = ROAD_TILE_NORMAL << 6 | tram; + SB(_m[t].m6, 2, 4, HASBIT(rot, ROADTYPE_HWAY) ? bits : 0); + _me[t].m7 = rot << 5 | hway; } -static inline void MakeRoadCrossing(TileIndex t, Owner road, Owner rail, Axis roaddir, RailType rt, uint town) +static inline void MakeRoadCrossing(TileIndex t, Owner road, Owner tram, Owner hway, Owner rail, Axis roaddir, RailType rat, RoadTypes rot, uint town) { SetTileType(t, MP_STREET); SetTileOwner(t, rail); _m[t].m2 = town; - _m[t].m3 = 0 << 7 | 0 << 4 | rt; - _m[t].m4 = road; - _m[t].m5 = ROAD_TILE_CROSSING << 4 | roaddir << 3 | 0 << 2; + _m[t].m3 = rat; + _m[t].m4 = roaddir << 6 | road; + _m[t].m5 = ROAD_TILE_CROSSING << 6 | tram; + SB(_m[t].m6, 2, 4, 0); + _me[t].m7 = rot << 5 | hway; } -static inline void MakeRoadDepot(TileIndex t, Owner owner, DiagDirection dir) +static inline void MakeRoadDepot(TileIndex t, Owner owner, DiagDirection dir, RoadType rt) { SetTileType(t, MP_STREET); SetTileOwner(t, owner); _m[t].m2 = 0; _m[t].m3 = 0; _m[t].m4 = 0; - _m[t].m5 = ROAD_TILE_DEPOT << 4 | dir; + _m[t].m5 = ROAD_TILE_DEPOT << 6 | dir; + SB(_m[t].m6, 2, 4, 0); + _me[t].m7 = RoadTypeToRoadTypes(rt) << 5; } #endif /* ROAD_MAP_H */ -- cgit v1.2.3-54-g00ecf