diff --git a/src/autoreplace_gui.cpp b/src/autoreplace_gui.cpp index b11112692d..e58ad6114d 100644 --- a/src/autoreplace_gui.cpp +++ b/src/autoreplace_gui.cpp @@ -547,7 +547,7 @@ public: case WID_RV_ROAD_TYPE_DROPDOWN: { // Roadtype selection dropdown menu static std::string roadtype_filter; - ShowDropDownList(this, GetRoadTypeDropDownList(RTTB_ROAD | RTTB_TRAM, true, true), this->sel_roadtype, widget, 0, DropDownOption::Filterable, &roadtype_filter); + ShowDropDownList(this, GetRoadTypeDropDownList(ROADTRAMTYPES_ALL, true, true), this->sel_roadtype, widget, 0, DropDownOption::Filterable, &roadtype_filter); break; } diff --git a/src/bridge_map.h b/src/bridge_map.h index a4b6aa7e2a..39dac781ac 100644 --- a/src/bridge_map.h +++ b/src/bridge_map.h @@ -154,8 +154,8 @@ inline void MakeBridgeRamp(Tile t, Owner o, BridgeType bridgetype, DiagDirection inline void MakeRoadBridgeRamp(Tile t, Owner o, Owner owner_road, Owner owner_tram, BridgeType bridgetype, DiagDirection d, RoadType road_rt, RoadType tram_rt) { MakeBridgeRamp(t, o, bridgetype, d, TRANSPORT_ROAD); - SetRoadOwner(t, RTT_ROAD, owner_road); - if (owner_tram != OWNER_TOWN) SetRoadOwner(t, RTT_TRAM, owner_tram); + SetRoadOwner(t, RoadTramType::Road, owner_road); + if (owner_tram != OWNER_TOWN) SetRoadOwner(t, RoadTramType::Tram, owner_tram); SetRoadTypes(t, road_rt, tram_rt); } diff --git a/src/company_base.h b/src/company_base.h index 90572fb433..1ec65f6c1a 100644 --- a/src/company_base.h +++ b/src/company_base.h @@ -50,8 +50,8 @@ struct CompanyInfrastructure { uint32_t GetRoadTramTotal(RoadTramType rtt) const; - inline uint32_t GetRoadTotal() const { return GetRoadTramTotal(RTT_ROAD); } - inline uint32_t GetTramTotal() const { return GetRoadTramTotal(RTT_TRAM); } + inline uint32_t GetRoadTotal() const { return GetRoadTramTotal(RoadTramType::Road); } + inline uint32_t GetTramTotal() const { return GetRoadTramTotal(RoadTramType::Tram); } }; class FreeUnitIDGenerator { diff --git a/src/disaster_vehicle.cpp b/src/disaster_vehicle.cpp index b7b446a893..b7347d9fd5 100644 --- a/src/disaster_vehicle.cpp +++ b/src/disaster_vehicle.cpp @@ -690,7 +690,7 @@ static bool DisasterTick_Submarine(DisasterVehicle *v) TileIndex tile = v->tile + TileOffsByDiagDir(DirToDiagDir(v->direction)); if (IsValidTile(tile)) { - TrackBits trackbits = TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, 0)); + TrackBits trackbits = TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid)); if (trackbits == TRACK_BIT_ALL && !Chance16(1, 90)) { GetNewVehiclePosResult gp = GetNewVehiclePos(v); v->UpdatePosition(gp.x, gp.y, v->z_pos); diff --git a/src/elrail.cpp b/src/elrail.cpp index 6ef58f3647..5233d78c9f 100644 --- a/src/elrail.cpp +++ b/src/elrail.cpp @@ -141,7 +141,7 @@ static TrackBits MaskWireBits(TileIndex t, TrackBits tracks) TileIndex next_tile = TileAddByDiagDir(t, d); RailType rt = GetTileRailType(next_tile); if (rt == INVALID_RAILTYPE || !HasRailCatenary(rt) || - ((TrackStatusToTrackBits(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, 0)) & DiagdirReachesTracks(d)) == TRACK_BIT_NONE && + ((TrackStatusToTrackBits(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, RoadTramType::Invalid)) & DiagdirReachesTracks(d)) == TRACK_BIT_NONE && (!HasStationTileRail(next_tile) || GetRailStationAxis(next_tile) != DiagDirToAxis(d) || !CanStationTileHaveWires(next_tile)))) { neighbour_tdb |= DiagdirReachesTrackdirs(ReverseDiagDir(d)); } diff --git a/src/landscape.cpp b/src/landscape.cpp index 043857b21e..d439e867d5 100644 --- a/src/landscape.cpp +++ b/src/landscape.cpp @@ -563,7 +563,7 @@ void DoClearSquare(TileIndex tile) * @param side side we are entering from, INVALID_DIAGDIR to return all trackbits * @return trackdirbits and other info depending on 'mode' */ -TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side) +TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, RoadTramType sub_mode, DiagDirection side) { return _tile_type_procs[GetTileType(tile)]->get_tile_track_status_proc(tile, mode, sub_mode, side); } diff --git a/src/newgrf.cpp b/src/newgrf.cpp index 8dde6715b6..c50f4473da 100644 --- a/src/newgrf.cpp +++ b/src/newgrf.cpp @@ -1704,18 +1704,18 @@ static void AfterLoadGRFs() e->VehInfo().max_speed = _gted[e->index].rv_max_speed * 4; } - RoadTramType rtt = e->info.misc_flags.Test(EngineMiscFlag::RoadIsTram) ? RTT_TRAM : RTT_ROAD; + RoadTramType rtt = e->info.misc_flags.Test(EngineMiscFlag::RoadIsTram) ? RoadTramType::Tram : RoadTramType::Road; const GRFFile *file = e->GetGRF(); if (file == nullptr || _gted[e->index].roadtramtype == 0) { - e->VehInfo().roadtype = (rtt == RTT_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD; + e->VehInfo().roadtype = (rtt == RoadTramType::Tram) ? ROADTYPE_TRAM : ROADTYPE_ROAD; continue; } /* Remove +1 offset. */ _gted[e->index].roadtramtype--; - const std::vector *list = (rtt == RTT_TRAM) ? &file->tramtype_list : &file->roadtype_list; + const std::vector *list = (rtt == RoadTramType::Tram) ? &file->tramtype_list : &file->roadtype_list; if (_gted[e->index].roadtramtype < list->size()) { RoadTypeLabel rtl = (*list)[_gted[e->index].roadtramtype]; diff --git a/src/newgrf/newgrf_act0_roadtypes.cpp b/src/newgrf/newgrf_act0_roadtypes.cpp index dc55d26f79..7da4c577db 100644 --- a/src/newgrf/newgrf_act0_roadtypes.cpp +++ b/src/newgrf/newgrf_act0_roadtypes.cpp @@ -30,7 +30,7 @@ static ChangeInfoResult RoadTypeChangeInfo(uint first, uint last, int prop, Byte ChangeInfoResult ret = ChangeInfoResult::Success; extern RoadTypeInfo _roadtypes[ROADTYPE_END]; - const auto &type_map = (rtt == RTT_TRAM) ? _cur_gps.grffile->tramtype_map : _cur_gps.grffile->roadtype_map; + const auto &type_map = (rtt == RoadTramType::Tram) ? _cur_gps.grffile->tramtype_map : _cur_gps.grffile->roadtype_map; if (last > std::size(type_map)) { GrfMsg(1, "RoadTypeChangeInfo: Road type {} is invalid, max {}, ignoring", last, std::size(type_map)); @@ -151,7 +151,7 @@ static ChangeInfoResult RoadTypeReserveInfo(uint first, uint last, int prop, Byt ChangeInfoResult ret = ChangeInfoResult::Success; extern RoadTypeInfo _roadtypes[ROADTYPE_END]; - auto &type_map = (rtt == RTT_TRAM) ? _cur_gps.grffile->tramtype_map : _cur_gps.grffile->roadtype_map; + auto &type_map = (rtt == RoadTramType::Tram) ? _cur_gps.grffile->tramtype_map : _cur_gps.grffile->roadtype_map; if (last > std::size(type_map)) { GrfMsg(1, "RoadTypeReserveInfo: Road type {} is invalid, max {}, ignoring", last, std::size(type_map)); @@ -229,11 +229,11 @@ static ChangeInfoResult RoadTypeReserveInfo(uint first, uint last, int prop, Byt } /** @copydoc GrfChangeInfoHandler::Reserve */ -template <> ChangeInfoResult GrfChangeInfoHandler::Reserve(uint first, uint last, int prop, ByteReader &buf) { return RoadTypeReserveInfo(first, last, prop, buf, RTT_ROAD); } +template <> ChangeInfoResult GrfChangeInfoHandler::Reserve(uint first, uint last, int prop, ByteReader &buf) { return RoadTypeReserveInfo(first, last, prop, buf, RoadTramType::Road); } /** @copydoc GrfChangeInfoHandler::Activation */ -template <> ChangeInfoResult GrfChangeInfoHandler::Activation(uint first, uint last, int prop, ByteReader &buf) { return RoadTypeChangeInfo(first, last, prop, buf, RTT_ROAD); } +template <> ChangeInfoResult GrfChangeInfoHandler::Activation(uint first, uint last, int prop, ByteReader &buf) { return RoadTypeChangeInfo(first, last, prop, buf, RoadTramType::Road); } /** @copydoc GrfChangeInfoHandler::Reserve */ -template <> ChangeInfoResult GrfChangeInfoHandler::Reserve(uint first, uint last, int prop, ByteReader &buf) { return RoadTypeReserveInfo(first, last, prop, buf, RTT_TRAM); } +template <> ChangeInfoResult GrfChangeInfoHandler::Reserve(uint first, uint last, int prop, ByteReader &buf) { return RoadTypeReserveInfo(first, last, prop, buf, RoadTramType::Tram); } /** @copydoc GrfChangeInfoHandler::Activation */ -template <> ChangeInfoResult GrfChangeInfoHandler::Activation(uint first, uint last, int prop, ByteReader &buf) { return RoadTypeChangeInfo(first, last, prop, buf, RTT_TRAM); } +template <> ChangeInfoResult GrfChangeInfoHandler::Activation(uint first, uint last, int prop, ByteReader &buf) { return RoadTypeChangeInfo(first, last, prop, buf, RoadTramType::Tram); } diff --git a/src/newgrf/newgrf_act3.cpp b/src/newgrf/newgrf_act3.cpp index 83720c59b4..7731dd32fd 100644 --- a/src/newgrf/newgrf_act3.cpp +++ b/src/newgrf/newgrf_act3.cpp @@ -306,7 +306,7 @@ struct RoadTypeMapSpriteGroupHandler : MapSpriteGroupHandler { { if (cid >= ROTSG_END) return; - const auto &type_map = (TRoadTramType == RTT_TRAM) ? _cur_gps.grffile->tramtype_map : _cur_gps.grffile->roadtype_map; + const auto &type_map = (TRoadTramType == RoadTramType::Tram) ? _cur_gps.grffile->tramtype_map : _cur_gps.grffile->roadtype_map; RoadType roadtype = local_id < std::size(type_map) ? type_map[local_id] : INVALID_ROADTYPE; if (roadtype == INVALID_ROADTYPE) return; @@ -441,8 +441,8 @@ static void FeatureMapSpriteGroup(ByteReader &buf) case GSF_AIRPORTS: MapSpriteGroup(buf, idcount, AirportMapSpriteGroupHandler{}); return; case GSF_OBJECTS: MapSpriteGroup(buf, idcount, ObjectMapSpriteGroupHandler{}); return; case GSF_RAILTYPES: MapSpriteGroup(buf, idcount, RailTypeMapSpriteGroupHandler{}); return; - case GSF_ROADTYPES: MapSpriteGroup(buf, idcount, RoadTypeMapSpriteGroupHandler{}); return; - case GSF_TRAMTYPES: MapSpriteGroup(buf, idcount, RoadTypeMapSpriteGroupHandler{}); return; + case GSF_ROADTYPES: MapSpriteGroup(buf, idcount, RoadTypeMapSpriteGroupHandler{}); return; + case GSF_TRAMTYPES: MapSpriteGroup(buf, idcount, RoadTypeMapSpriteGroupHandler{}); return; case GSF_AIRPORTTILES: MapSpriteGroup(buf, idcount, AirportTileMapSpriteGroupHandler{}); return; case GSF_ROADSTOPS: MapSpriteGroup(buf, idcount, RoadStopMapSpriteGroupHandler{}); return; case GSF_BADGES: MapSpriteGroup(buf, idcount, BadgeMapSpriteGroupHandler{}); return; diff --git a/src/newgrf_roadstop.cpp b/src/newgrf_roadstop.cpp index 7067f53f41..3e77f09d46 100644 --- a/src/newgrf_roadstop.cpp +++ b/src/newgrf_roadstop.cpp @@ -106,10 +106,10 @@ uint32_t RoadStopScopeResolver::GetVariable(uint8_t variable, [[maybe_unused]] u case 0x42: return this->tile == INVALID_TILE ? 0 : (GetTileSlope(this->tile) << 8 | GetTerrainType(this->tile, TCX_NORMAL)); /* Road type */ - case 0x43: return get_road_type_variable(RTT_ROAD); + case 0x43: return get_road_type_variable(RoadTramType::Road); /* Tram type */ - case 0x44: return get_road_type_variable(RTT_TRAM); + case 0x44: return get_road_type_variable(RoadTramType::Tram); /* Town zone and Manhattan distance of closest town */ case 0x45: { diff --git a/src/newgrf_roadtype.cpp b/src/newgrf_roadtype.cpp index 3b10bbbd4d..31cbb3f978 100644 --- a/src/newgrf_roadtype.cpp +++ b/src/newgrf_roadtype.cpp @@ -114,8 +114,8 @@ GrfSpecFeature RoadTypeResolverObject::GetFeature() const { RoadType rt = GetRoadTypeByLabel(this->roadtype_scope.rti->label, false); switch (GetRoadTramType(rt)) { - case RTT_ROAD: return GSF_ROADTYPES; - case RTT_TRAM: return GSF_TRAMTYPES; + case RoadTramType::Road: return GSF_ROADTYPES; + case RoadTramType::Tram: return GSF_TRAMTYPES; default: return GSF_INVALID; } } @@ -183,7 +183,7 @@ RoadType GetRoadTypeTranslation(RoadTramType rtt, uint8_t tracktype, const GRFFi if (grffile == nullptr) return INVALID_ROADTYPE; - const auto &list = rtt == RTT_TRAM ? grffile->tramtype_list : grffile->roadtype_list; + const auto &list = rtt == RoadTramType::Tram ? grffile->tramtype_list : grffile->roadtype_list; if (tracktype >= list.size()) return INVALID_ROADTYPE; /* Look up roadtype including alternate labels. */ @@ -231,7 +231,7 @@ void ConvertRoadTypes() bool needs_conversion = false; for (auto it = std::begin(_roadtype_list); it != std::end(_roadtype_list); ++it) { RoadType rt = GetRoadTypeByLabel(it->label); - if (rt == INVALID_ROADTYPE || GetRoadTramType(rt) != it->subtype) { + if (rt == INVALID_ROADTYPE || GetRoadTramType(rt) != RoadTramType{it->subtype}) { rt = it->subtype ? ROADTYPE_TRAM : ROADTYPE_ROAD; } @@ -274,7 +274,7 @@ void SetCurrentRoadTypeLabelList() { _roadtype_list.clear(); for (RoadType rt = ROADTYPE_BEGIN; rt != ROADTYPE_END; rt++) { - _roadtype_list.emplace_back(GetRoadTypeInfo(rt)->label, GetRoadTramType(rt)); + _roadtype_list.emplace_back(GetRoadTypeInfo(rt)->label, to_underlying(GetRoadTramType(rt))); } } diff --git a/src/newgrf_station.cpp b/src/newgrf_station.cpp index 94f424ebde..021e8fbb52 100644 --- a/src/newgrf_station.cpp +++ b/src/newgrf_station.cpp @@ -222,7 +222,7 @@ static uint32_t GetRailContinuationInfo(TileIndex tile) for (i = 0; i < lengthof(x_dir); i++, dir++, diagdir++) { TileIndex neighbour_tile = tile + TileOffsByDir(*dir); - TrackBits trackbits = TrackStatusToTrackBits(GetTileTrackStatus(neighbour_tile, TRANSPORT_RAIL, 0)); + TrackBits trackbits = TrackStatusToTrackBits(GetTileTrackStatus(neighbour_tile, TRANSPORT_RAIL, RoadTramType::Invalid)); if (trackbits != TRACK_BIT_NONE) { /* If there is any track on the tile, set the bit in the second byte */ SetBit(res, i + 8); diff --git a/src/pathfinder/follow_track.hpp b/src/pathfinder/follow_track.hpp index b5cd34dfbf..204917cd01 100644 --- a/src/pathfinder/follow_track.hpp +++ b/src/pathfinder/follow_track.hpp @@ -105,7 +105,7 @@ struct CFollowTrackT { assert(this->IsTram()); // this function shouldn't be called in other cases if (IsNormalRoadTile(tile)) { - RoadBits rb = GetRoadBits(tile, RTT_TRAM); + RoadBits rb = GetRoadBits(tile, RoadTramType::Tram); switch (rb) { case ROAD_NW: return DIAGDIR_NW; case ROAD_SW: return DIAGDIR_SW; @@ -132,7 +132,7 @@ struct CFollowTrackT { assert([&]() { if (this->IsTram() && this->GetSingleTramBit(this->old_tile) != INVALID_DIAGDIR) return true; // Skip the check for single tram bits - const uint sub_mode = (IsRoadTT() && this->veh != nullptr) ? (this->IsTram() ? RTT_TRAM : RTT_ROAD) : 0; + const RoadTramType sub_mode = (IsRoadTT() && this->veh != nullptr) ? (this->IsTram() ? RoadTramType::Tram : RoadTramType::Road) : RoadTramType::Invalid; const TrackdirBits old_tile_valid_dirs = TrackStatusToTrackdirBits(GetTileTrackStatus(this->old_tile, TT(), sub_mode)); return (old_tile_valid_dirs & TrackdirToTrackdirBits(this->old_td)) != TRACKDIR_BIT_NONE; }()); @@ -251,9 +251,9 @@ protected: if (IsRailTT() && IsPlainRailTile(this->new_tile)) { this->new_td_bits = (TrackdirBits)(GetTrackBits(this->new_tile) * 0x101); } else if (IsRoadTT()) { - this->new_td_bits = GetTrackdirBitsForRoad(this->new_tile, this->IsTram() ? RTT_TRAM : RTT_ROAD); + this->new_td_bits = GetTrackdirBitsForRoad(this->new_tile, this->IsTram() ? RoadTramType::Tram : RoadTramType::Road); } else { - this->new_td_bits = TrackStatusToTrackdirBits(GetTileTrackStatus(this->new_tile, TT(), 0)); + this->new_td_bits = TrackStatusToTrackdirBits(GetTileTrackStatus(this->new_tile, TT(), RoadTramType::Invalid)); } return (this->new_td_bits != TRACKDIR_BIT_NONE); } diff --git a/src/pathfinder/pathfinder_func.h b/src/pathfinder/pathfinder_func.h index 9ef4dce1f6..64593fe246 100644 --- a/src/pathfinder/pathfinder_func.h +++ b/src/pathfinder/pathfinder_func.h @@ -63,9 +63,9 @@ inline TrackdirBits GetTrackdirBitsForRoad(TileIndex tile, RoadTramType rtt) { TrackdirBits bits = TrackStatusToTrackdirBits(GetTileTrackStatus(tile, TRANSPORT_ROAD, rtt)); - if (rtt == RTT_TRAM && bits == TRACKDIR_BIT_NONE) { + if (rtt == RoadTramType::Tram && bits == TRACKDIR_BIT_NONE) { if (IsNormalRoadTile(tile)) { - RoadBits rb = GetRoadBits(tile, RTT_TRAM); + RoadBits rb = GetRoadBits(tile, RoadTramType::Tram); switch (rb) { case ROAD_NE: case ROAD_SW: diff --git a/src/pathfinder/water_regions.cpp b/src/pathfinder/water_regions.cpp index 208479db6e..b21fa53335 100644 --- a/src/pathfinder/water_regions.cpp +++ b/src/pathfinder/water_regions.cpp @@ -28,7 +28,7 @@ constexpr WaterRegionPatchLabel FIRST_REGION_LABEL{1}; static_assert(sizeof(WaterRegionTraversabilityBits) * 8 == WATER_REGION_EDGE_LENGTH); static_assert(sizeof(WaterRegionPatchLabel) == sizeof(uint8_t)); // Important for the hash calculation. -static inline TrackBits GetWaterTracks(TileIndex tile) { return TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, 0)); } +static inline TrackBits GetWaterTracks(TileIndex tile) { return TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid)); } static inline bool IsAqueductTile(TileIndex tile) { return IsBridgeTile(tile) && GetTunnelBridgeTransportType(tile) == TRANSPORT_WATER; } static inline int GetWaterRegionX(TileIndex tile) { return TileX(tile) / WATER_REGION_EDGE_LENGTH; } diff --git a/src/pathfinder/yapf/yapf_destrail.hpp b/src/pathfinder/yapf/yapf_destrail.hpp index ba93a2362a..455ceb1cbf 100644 --- a/src/pathfinder/yapf/yapf_destrail.hpp +++ b/src/pathfinder/yapf/yapf_destrail.hpp @@ -154,7 +154,7 @@ public: default: this->dest_tile = v->dest_tile == INVALID_TILE ? TileIndex{} : v->dest_tile; this->dest_station_id = StationID::Invalid(); - this->dest_trackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(this->dest_tile, TRANSPORT_RAIL, 0)); + this->dest_trackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(this->dest_tile, TRANSPORT_RAIL, RoadTramType::Invalid)); break; } this->CYapfDestinationRailBase::SetDestination(v); diff --git a/src/pathfinder/yapf/yapf_road.cpp b/src/pathfinder/yapf/yapf_road.cpp index 18c9ff9ae1..e22c22170b 100644 --- a/src/pathfinder/yapf/yapf_road.cpp +++ b/src/pathfinder/yapf/yapf_road.cpp @@ -445,7 +445,7 @@ public: /* set origin (tile, trackdir) */ TileIndex src_tile = v->tile; Trackdir src_td = v->GetVehicleTrackdir(); - if (!HasTrackdir(GetTrackdirBitsForRoad(src_tile, Yapf().IsTram() ? RTT_TRAM : RTT_ROAD), src_td)) { + if (!HasTrackdir(GetTrackdirBitsForRoad(src_tile, Yapf().IsTram() ? RoadTramType::Tram : RoadTramType::Road), src_td)) { /* sometimes the roadveh is not on the road (it resides on non-existing track) * how should we handle that situation? */ return false; diff --git a/src/pathfinder/yapf/yapf_ship.cpp b/src/pathfinder/yapf/yapf_ship.cpp index 3a4bd0c825..cb50cb65ba 100644 --- a/src/pathfinder/yapf/yapf_ship.cpp +++ b/src/pathfinder/yapf/yapf_ship.cpp @@ -50,7 +50,7 @@ public: } else { this->dest_station = StationID::Invalid(); this->dest_tile = v->dest_tile == INVALID_TILE ? TileIndex{} : v->dest_tile; - this->dest_trackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(this->dest_tile, TRANSPORT_WATER, 0)); + this->dest_trackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(this->dest_tile, TRANSPORT_WATER, RoadTramType::Invalid)); } } @@ -313,7 +313,7 @@ public: } else { /* This gets called when a ship suddenly can't move forward, e.g. due to terraforming. */ const DiagDirection entry = ReverseDiagDir(VehicleExitDir(v->direction, v->state)); - const TrackdirBits reverse_dirs = DiagdirReachesTrackdirs(entry) & TrackStatusToTrackdirBits(GetTileTrackStatus(v->tile, TRANSPORT_WATER, 0, entry)); + const TrackdirBits reverse_dirs = DiagdirReachesTrackdirs(entry) & TrackStatusToTrackdirBits(GetTileTrackStatus(v->tile, TRANSPORT_WATER, RoadTramType::Invalid, entry)); (void)ChooseShipTrack(v, v->tile, TRACKDIR_BIT_NONE, reverse_dirs, path_found, dummy_cache, best_origin_dir); *trackdir = path_found && best_origin_dir != INVALID_TRACKDIR ? best_origin_dir : GetRandomTrackdir(reverse_dirs); return true; diff --git a/src/pbs.cpp b/src/pbs.cpp index bcfa106a2c..5f933b05d4 100644 --- a/src/pbs.cpp +++ b/src/pbs.cpp @@ -79,7 +79,7 @@ void SetRailStationPlatformReservation(TileIndex start, DiagDirection dir, bool */ bool TryReserveRailTrack(TileIndex tile, Track t, bool trigger_stations) { - assert(HasTrack(TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)), t)); + assert(HasTrack(TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid)), t)); if (_settings_client.gui.show_track_reservation) { /* show the reserved rail if needed */ @@ -143,7 +143,7 @@ bool TryReserveRailTrack(TileIndex tile, Track t, bool trigger_stations) */ void UnreserveRailTrack(TileIndex tile, Track t) { - assert(HasTrack(TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)), t)); + assert(HasTrack(TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid)), t)); if (_settings_client.gui.show_track_reservation) { if (IsBridgeTile(tile)) { diff --git a/src/rail_cmd.cpp b/src/rail_cmd.cpp index b3f1f33a4a..67bd56cee4 100644 --- a/src/rail_cmd.cpp +++ b/src/rail_cmd.cpp @@ -516,12 +516,12 @@ CommandCost CmdBuildSingleRail(DoCommandFlags flags, TileIndex tile, RailType ra if (roadtype_road != INVALID_ROADTYPE && RoadNoLevelCrossing(roadtype_road)) return CommandCost(STR_ERROR_CROSSING_DISALLOWED_ROAD); if (roadtype_tram != INVALID_ROADTYPE && RoadNoLevelCrossing(roadtype_tram)) return CommandCost(STR_ERROR_CROSSING_DISALLOWED_ROAD); - RoadBits road = GetRoadBits(tile, RTT_ROAD); - RoadBits tram = GetRoadBits(tile, RTT_TRAM); + RoadBits road = GetRoadBits(tile, RoadTramType::Road); + RoadBits tram = GetRoadBits(tile, RoadTramType::Tram); if ((track == TRACK_X && ((road | tram) & ROAD_X) == 0) || (track == TRACK_Y && ((road | tram) & ROAD_Y) == 0)) { - Owner road_owner = GetRoadOwner(tile, RTT_ROAD); - Owner tram_owner = GetRoadOwner(tile, RTT_TRAM); + Owner road_owner = GetRoadOwner(tile, RoadTramType::Road); + Owner tram_owner = GetRoadOwner(tile, RoadTramType::Tram); /* Disallow breaking end-of-line of someone else * so trams can still reverse on this tile. */ if (Company::IsValidID(tram_owner) && HasExactlyOneBit(tram)) { @@ -654,7 +654,7 @@ CommandCost CmdRemoveSingleRail(DoCommandFlags flags, TileIndex tile, Track trac owner = GetTileOwner(tile); Company::Get(owner)->infrastructure.rail[GetRailType(tile)] -= LEVELCROSSING_TRACKBIT_FACTOR; DirtyCompanyInfrastructureWindows(owner); - MakeRoadNormal(tile, GetCrossingRoadBits(tile), GetRoadTypeRoad(tile), GetRoadTypeTram(tile), GetTownIndex(tile), GetRoadOwner(tile, RTT_ROAD), GetRoadOwner(tile, RTT_TRAM)); + MakeRoadNormal(tile, GetCrossingRoadBits(tile), GetRoadTypeRoad(tile), GetRoadTypeTram(tile), GetTownIndex(tile), GetRoadOwner(tile, RoadTramType::Road), GetRoadOwner(tile, RoadTramType::Tram)); DeleteNewGRFInspectWindow(GSF_RAILTYPES, tile.base()); } break; @@ -1199,7 +1199,7 @@ static bool AdvanceSignalAutoFill(TileIndex &tile, Trackdir &trackdir, bool remo if (tile == INVALID_TILE) return false; /* Check for track bits on the new tile */ - TrackdirBits trackdirbits = TrackStatusToTrackdirBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)); + TrackdirBits trackdirbits = TrackStatusToTrackdirBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid)); if (TracksOverlap(TrackdirBitsToTrackBits(trackdirbits))) return false; trackdirbits &= TrackdirReachesTrackdirs(trackdir); @@ -2740,7 +2740,7 @@ set_ground: /** @copydoc GetTileTrackStatusProc */ -static TrackStatus GetTileTrackStatus_Rail(TileIndex tile, TransportType mode, [[maybe_unused]] uint sub_mode, DiagDirection side) +static TrackStatus GetTileTrackStatus_Rail(TileIndex tile, TransportType mode, [[maybe_unused]] RoadTramType sub_mode, DiagDirection side) { /* Case of half tile slope with water. */ if (mode == TRANSPORT_WATER && IsPlainRail(tile) && GetRailGroundType(tile) == RailGroundType::HalfTileWater && IsSlopeWithOneCornerRaised(GetTileSlope(tile))) { diff --git a/src/rail_gui.cpp b/src/rail_gui.cpp index 9e514518f4..644ca5aed8 100644 --- a/src/rail_gui.cpp +++ b/src/rail_gui.cpp @@ -237,7 +237,7 @@ static void PlaceRail_Station(TileIndex tile) */ static void GenericPlaceSignals(TileIndex tile) { - TrackBits trackbits = TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)); + TrackBits trackbits = TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid)); if (trackbits & TRACK_BIT_VERT) { // N-S direction trackbits = (_tile_fract_coords.x <= _tile_fract_coords.y) ? TRACK_BIT_RIGHT : TRACK_BIT_LEFT; diff --git a/src/road.cpp b/src/road.cpp index bd4b9ebf99..6bf808c60d 100644 --- a/src/road.cpp +++ b/src/road.cpp @@ -85,7 +85,7 @@ RoadBits CleanUpRoadBits(const TileIndex tile, RoadBits org_rb) /* Always connective */ connective = true; } else { - const RoadBits neighbour_rb = GetAnyRoadBits(neighbour_tile, RTT_ROAD) | GetAnyRoadBits(neighbour_tile, RTT_TRAM); + const RoadBits neighbour_rb = GetAnyRoadBits(neighbour_tile, RoadTramType::Road) | GetAnyRoadBits(neighbour_tile, RoadTramType::Tram); /* Accept only connective tiles */ connective = (neighbour_rb & mirrored_rb) != ROAD_NONE; diff --git a/src/road.h b/src/road.h index 5ce376abea..49f162acc9 100644 --- a/src/road.h +++ b/src/road.h @@ -184,27 +184,27 @@ inline RoadTypes GetMaskForRoadTramType(RoadTramType rtt) { extern RoadTypes _roadtypes_road; extern RoadTypes _roadtypes_tram; - return rtt == RTT_ROAD ? _roadtypes_road : _roadtypes_tram; + return rtt == RoadTramType::Road ? _roadtypes_road : _roadtypes_tram; } inline bool RoadTypeIsRoad(RoadType roadtype) { - return GetMaskForRoadTramType(RTT_ROAD).Test(roadtype); + return GetMaskForRoadTramType(RoadTramType::Road).Test(roadtype); } inline bool RoadTypeIsTram(RoadType roadtype) { - return GetMaskForRoadTramType(RTT_TRAM).Test(roadtype); + return GetMaskForRoadTramType(RoadTramType::Tram).Test(roadtype); } inline RoadTramType GetRoadTramType(RoadType roadtype) { - return RoadTypeIsTram(roadtype) ? RTT_TRAM : RTT_ROAD; + return RoadTypeIsTram(roadtype) ? RoadTramType::Tram : RoadTramType::Road; } inline RoadTramType OtherRoadTramType(RoadTramType rtt) { - return rtt == RTT_ROAD ? RTT_TRAM : RTT_ROAD; + return rtt == RoadTramType::Road ? RoadTramType::Tram : RoadTramType::Road; } /** diff --git a/src/road_cmd.cpp b/src/road_cmd.cpp index ad8df5b257..479b682b5f 100644 --- a/src/road_cmd.cpp +++ b/src/road_cmd.cpp @@ -138,7 +138,7 @@ RoadType AllocateRoadType(RoadTypeLabel label, RoadTramType rtt) RoadType rt = rti.Index(); /* Set up new road type based on default tram or road. */ - rti = _original_roadtypes[(rtt == RTT_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD]; + rti = _original_roadtypes[(rtt == RoadTramType::Tram) ? ROADTYPE_TRAM : ROADTYPE_ROAD]; rti.label = label; rti.alternate_labels.clear(); rti.flags = {}; @@ -159,8 +159,8 @@ RoadType AllocateRoadType(RoadTypeLabel label, RoadTramType rtt) rti.sorting_order = rt << 2 | 7; /* Set bitmap of road/tram types */ - _roadtypes_road.Set(rt, rtt == RTT_ROAD); - _roadtypes_tram.Set(rt, rtt == RTT_TRAM); + _roadtypes_road.Set(rt, rtt == RoadTramType::Road); + _roadtypes_tram.Set(rt, rtt == RoadTramType::Tram); return rt; } @@ -260,7 +260,7 @@ CommandCost CheckAllowRemoveRoad(TileIndex tile, RoadBits remove, Owner owner, R * Towns are not be allowed to remove non "normal" road pieces, like tram * tracks as that would result in trams that cannot turn. */ if (_current_company == OWNER_WATER || - (rtt == RTT_ROAD && !Company::IsValidID(_current_company))) return CommandCost(); + (rtt == RoadTramType::Road && !Company::IsValidID(_current_company))) return CommandCost(); /* Only do the special processing if the road is owned * by a town */ @@ -321,7 +321,7 @@ static CommandCost RemoveRoad(TileIndex tile, DoCommandFlags flags, RoadBits pie RoadType existing_rt = MayHaveRoad(tile) ? GetRoadType(tile, rtt) : INVALID_ROADTYPE; /* The tile doesn't have the given road type */ - if (existing_rt == INVALID_ROADTYPE) return CommandCost((rtt == RTT_TRAM) ? STR_ERROR_THERE_IS_NO_TRAMWAY : STR_ERROR_THERE_IS_NO_ROAD); + if (existing_rt == INVALID_ROADTYPE) return CommandCost((rtt == RoadTramType::Tram) ? STR_ERROR_THERE_IS_NO_TRAMWAY : STR_ERROR_THERE_IS_NO_ROAD); switch (GetTileType(tile)) { case TileType::Road: { @@ -359,7 +359,7 @@ static CommandCost RemoveRoad(TileIndex tile, DoCommandFlags flags, RoadBits pie CommandCost cost(EXPENSES_CONSTRUCTION); if (IsTileType(tile, TileType::TunnelBridge)) { /* Removing any roadbit in the bridge axis removes the roadtype (that's the behaviour remove-long-roads needs) */ - if ((AxisToRoadBits(DiagDirToAxis(GetTunnelBridgeDirection(tile))) & pieces) == ROAD_NONE) return CommandCost((rtt == RTT_TRAM) ? STR_ERROR_THERE_IS_NO_TRAMWAY : STR_ERROR_THERE_IS_NO_ROAD); + if ((AxisToRoadBits(DiagDirToAxis(GetTunnelBridgeDirection(tile))) & pieces) == ROAD_NONE) return CommandCost((rtt == RoadTramType::Tram) ? STR_ERROR_THERE_IS_NO_TRAMWAY : STR_ERROR_THERE_IS_NO_ROAD); TileIndex other_end = GetOtherTunnelBridgeEnd(tile); /* Pay for *every* tile of the bridge or tunnel */ @@ -426,7 +426,7 @@ static CommandCost RemoveRoad(TileIndex tile, DoCommandFlags flags, RoadBits pie /* limit the bits to delete to the existing bits. */ pieces &= present; - if (pieces == ROAD_NONE) return CommandCost((rtt == RTT_TRAM) ? STR_ERROR_THERE_IS_NO_TRAMWAY : STR_ERROR_THERE_IS_NO_ROAD); + if (pieces == ROAD_NONE) return CommandCost((rtt == RoadTramType::Tram) ? STR_ERROR_THERE_IS_NO_TRAMWAY : STR_ERROR_THERE_IS_NO_ROAD); /* Now set present what it will be after the remove */ present ^= pieces; @@ -456,12 +456,12 @@ static CommandCost RemoveRoad(TileIndex tile, DoCommandFlags flags, RoadBits pie /* Includes MarkTileDirtyByTile() */ DoClearSquare(tile); } else { - if (rtt == RTT_ROAD && IsRoadOwner(tile, rtt, OWNER_TOWN)) { + if (rtt == RoadTramType::Road && IsRoadOwner(tile, rtt, OWNER_TOWN)) { /* Update nearest-town index */ const Town *town = CalcClosestTownFromTile(tile); SetTownIndex(tile, town == nullptr ? TownID::Invalid() : town->index); } - if (rtt == RTT_ROAD) SetDisallowedRoadDirections(tile, DRD_NONE); + if (rtt == RoadTramType::Road) SetDisallowedRoadDirections(tile, DRD_NONE); SetRoadBits(tile, ROAD_NONE, rtt); SetRoadType(tile, rtt, INVALID_ROADTYPE); MarkTileDirtyByTile(tile); @@ -470,7 +470,7 @@ static CommandCost RemoveRoad(TileIndex tile, DoCommandFlags flags, RoadBits pie /* When bits are removed, you *always* end up with something that * is not a complete straight road tile. However, trams do not have * onewayness, so they cannot remove it either. */ - if (rtt == RTT_ROAD) SetDisallowedRoadDirections(tile, DRD_NONE); + if (rtt == RoadTramType::Road) SetDisallowedRoadDirections(tile, DRD_NONE); SetRoadBits(tile, present, rtt); MarkTileDirtyByTile(tile); } @@ -644,13 +644,13 @@ CommandCost CmdBuildRoad(DoCommandFlags flags, TileIndex tile, RoadBits pieces, existing = GetRoadBits(tile, rtt); bool crossing = !IsStraightRoad(existing | pieces); - if (rtt == RTT_ROAD && (GetDisallowedRoadDirections(tile) != DRD_NONE || toggle_drd != DRD_NONE) && crossing) { + if (rtt == RoadTramType::Road && (GetDisallowedRoadDirections(tile) != DRD_NONE || toggle_drd != DRD_NONE) && crossing) { /* Junctions cannot be one-way */ return CommandCost(STR_ERROR_ONEWAY_ROADS_CAN_T_HAVE_JUNCTION); } if ((existing & pieces) == pieces) { /* We only want to set the (dis)allowed road directions */ - if (toggle_drd != DRD_NONE && rtt == RTT_ROAD) { + if (toggle_drd != DRD_NONE && rtt == RoadTramType::Road) { Owner owner = GetRoadOwner(tile, rtt); if (owner != OWNER_NONE) { CommandCost ret = CheckOwnership(owner, tile); @@ -680,7 +680,7 @@ CommandCost CmdBuildRoad(DoCommandFlags flags, TileIndex tile, RoadBits pieces, } /* Disallow breaking end-of-line of someone else * so trams can still reverse on this tile. */ - if (rtt == RTT_TRAM && HasExactlyOneBit(existing)) { + if (rtt == RoadTramType::Tram && HasExactlyOneBit(existing)) { Owner owner = GetRoadOwner(tile, rtt); if (Company::IsValidID(owner)) { CommandCost ret = CheckOwnership(owner); @@ -769,7 +769,7 @@ CommandCost CmdBuildRoad(DoCommandFlags flags, TileIndex tile, RoadBits pieces, /* Always add road to the roadtypes (can't draw without it) */ bool reserved = HasBit(GetRailReservationTrackBits(tile), railtrack); - MakeRoadCrossing(tile, company, company, GetTileOwner(tile), roaddir, GetRailType(tile), rtt == RTT_ROAD ? rt : INVALID_ROADTYPE, (rtt == RTT_TRAM) ? rt : INVALID_ROADTYPE, town_id); + MakeRoadCrossing(tile, company, company, GetTileOwner(tile), roaddir, GetRailType(tile), rtt == RoadTramType::Road ? rt : INVALID_ROADTYPE, (rtt == RoadTramType::Tram) ? rt : INVALID_ROADTYPE, town_id); SetCrossingReservation(tile, reserved); UpdateLevelCrossing(tile, false); MarkDirtyAdjacentLevelCrossingTiles(tile, GetCrossingRoadAxis(tile)); @@ -880,7 +880,7 @@ do_clear:; if (existing == ROAD_NONE || rttype == RoadTileType::Crossing) { SetRoadType(tile, rtt, rt); SetRoadOwner(tile, rtt, company); - if (rtt == RTT_ROAD) SetTownIndex(tile, town_id); + if (rtt == RoadTramType::Road) SetTownIndex(tile, town_id); } if (rttype != RoadTileType::Crossing) SetRoadBits(tile, existing | pieces, rtt); break; @@ -912,7 +912,7 @@ do_clear:; } default: - MakeRoadNormal(tile, pieces, (rtt == RTT_ROAD) ? rt : INVALID_ROADTYPE, (rtt == RTT_TRAM) ? rt : INVALID_ROADTYPE, town_id, company, company); + MakeRoadNormal(tile, pieces, (rtt == RoadTramType::Road) ? rt : INVALID_ROADTYPE, (rtt == RoadTramType::Tram) ? rt : INVALID_ROADTYPE, town_id, company, company); break; } @@ -920,7 +920,7 @@ do_clear:; if (IsTileType(tile, TileType::TunnelBridge)) num_pieces *= TUNNELBRIDGE_TRACKBIT_FACTOR; UpdateCompanyRoadInfrastructure(rt, GetRoadOwner(tile, rtt), num_pieces); - if (rtt == RTT_ROAD && IsNormalRoadTile(tile)) { + if (rtt == RoadTramType::Road && IsNormalRoadTile(tile)) { existing |= pieces; SetDisallowedRoadDirections(tile, IsStraightRoad(existing) ? GetDisallowedRoadDirections(tile) ^ toggle_drd : DRD_NONE); @@ -1226,9 +1226,9 @@ static CommandCost ClearTile_Road(TileIndex tile, DoCommandFlags flags) RoadBits b = GetAllRoadBits(tile); /* Clear the road if only one piece is on the tile OR we are not using the DoCommandFlag::Auto flag */ - if ((HasExactlyOneBit(b) && GetRoadBits(tile, RTT_TRAM) == ROAD_NONE) || !flags.Test(DoCommandFlag::Auto)) { + if ((HasExactlyOneBit(b) && GetRoadBits(tile, RoadTramType::Tram) == ROAD_NONE) || !flags.Test(DoCommandFlag::Auto)) { CommandCost ret(EXPENSES_CONSTRUCTION); - for (RoadTramType rtt : _roadtramtypes) { + for (RoadTramType rtt : ROADTRAMTYPES_ALL) { if (!MayHaveRoad(tile) || GetRoadType(tile, rtt) == INVALID_ROADTYPE) continue; CommandCost tmp_ret = RemoveRoad(tile, flags, GetRoadBits(tile, rtt), rtt, true); @@ -1247,7 +1247,7 @@ static CommandCost ClearTile_Road(TileIndex tile, DoCommandFlags flags) /* Must iterate over the roadtypes in a reverse manner because * tram tracks must be removed before the road bits. */ - for (RoadTramType rtt : { RTT_TRAM, RTT_ROAD }) { + for (RoadTramType rtt : { RoadTramType::Tram, RoadTramType::Road }) { if (!MayHaveRoad(tile) || GetRoadType(tile, rtt) == INVALID_ROADTYPE) continue; CommandCost tmp_ret = RemoveRoad(tile, flags, GetCrossingRoadBits(tile), rtt, true); @@ -1446,8 +1446,8 @@ void DrawRoadCatenary(const TileInfo *ti) if (IsTileType(ti->tile, TileType::Road)) { if (IsNormalRoad(ti->tile)) { - road = GetRoadBits(ti->tile, RTT_ROAD); - tram = GetRoadBits(ti->tile, RTT_TRAM); + road = GetRoadBits(ti->tile, RoadTramType::Road); + tram = GetRoadBits(ti->tile, RoadTramType::Tram); } else if (IsLevelCrossing(ti->tile)) { tram = road = (GetCrossingRailAxis(ti->tile) == AXIS_Y ? ROAD_X : ROAD_Y); } @@ -1627,8 +1627,8 @@ void DrawRoadGroundSprites(const TileInfo *ti, RoadBits road, RoadBits tram, con */ static void DrawRoadBits(TileInfo *ti) { - RoadBits road = GetRoadBits(ti->tile, RTT_ROAD); - RoadBits tram = GetRoadBits(ti->tile, RTT_TRAM); + RoadBits road = GetRoadBits(ti->tile, RoadTramType::Road); + RoadBits tram = GetRoadBits(ti->tile, RoadTramType::Tram); RoadType road_rt = GetRoadTypeRoad(ti->tile); RoadType tram_rt = GetRoadTypeTram(ti->tile); @@ -2086,11 +2086,11 @@ static void TileLoop_Road(TileIndex tile) if (_settings_game.economy.mod_road_rebuild) { /* Generate a nicer town surface */ - const RoadBits old_rb = GetAnyRoadBits(tile, RTT_ROAD); + const RoadBits old_rb = GetAnyRoadBits(tile, RoadTramType::Road); const RoadBits new_rb = CleanUpRoadBits(tile, old_rb); if (old_rb != new_rb) { - RemoveRoad(tile, {DoCommandFlag::Execute, DoCommandFlag::Auto, DoCommandFlag::NoWater}, (old_rb ^ new_rb), RTT_ROAD, true); + RemoveRoad(tile, {DoCommandFlag::Execute, DoCommandFlag::Auto, DoCommandFlag::NoWater}, (old_rb ^ new_rb), RoadTramType::Road, true); /* If new_rb is 0, there are now no road pieces left and the tile is no longer a road tile */ if (new_rb == 0) { @@ -2101,10 +2101,10 @@ static void TileLoop_Road(TileIndex tile) } /* Possibly change road type */ - if (GetRoadOwner(tile, RTT_ROAD) == OWNER_TOWN) { + if (GetRoadOwner(tile, RoadTramType::Road) == OWNER_TOWN) { RoadType rt = GetTownRoadType(); if (rt != GetRoadTypeRoad(tile)) { - SetRoadType(tile, RTT_ROAD, rt); + SetRoadType(tile, RoadTramType::Road, rt); } } @@ -2142,7 +2142,7 @@ static const TrackBits _road_trackbits[16] = { }; /** @copydoc GetTileTrackStatusProc */ -static TrackStatus GetTileTrackStatus_Road(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side) +static TrackStatus GetTileTrackStatus_Road(TileIndex tile, TransportType mode, RoadTramType sub_mode, DiagDirection side) { TrackdirBits trackdirbits = TRACKDIR_BIT_NONE; TrackdirBits red_signals = TRACKDIR_BIT_NONE; // crossing barred @@ -2162,7 +2162,7 @@ static TrackStatus GetTileTrackStatus_Road(TileIndex tile, TransportType mode, u /* no roadbit at this side of tile, return 0 */ if (side != INVALID_DIAGDIR && (DiagDirToRoadBits(side) & bits) == 0) break; - uint multiplier = drd_to_multiplier[(rtt == RTT_TRAM) ? DRD_NONE : GetDisallowedRoadDirections(tile)]; + uint multiplier = drd_to_multiplier[(rtt == RoadTramType::Tram) ? DRD_NONE : GetDisallowedRoadDirections(tile)]; if (!HasRoadWorks(tile)) trackdirbits = (TrackdirBits)(_road_trackbits[bits] * multiplier); break; } @@ -2230,13 +2230,13 @@ static void GetTileDesc_Road(TileIndex tile, TileDesc &td) const RoadTypeInfo *rti = GetRoadTypeInfo(road_rt); td.roadtype = rti->strings.name; td.road_speed = rti->max_speed / 2; - road_owner = GetRoadOwner(tile, RTT_ROAD); + road_owner = GetRoadOwner(tile, RoadTramType::Road); } if (tram_rt != INVALID_ROADTYPE) { const RoadTypeInfo *rti = GetRoadTypeInfo(tram_rt); td.tramtype = rti->strings.name; td.tram_speed = rti->max_speed / 2; - tram_owner = GetRoadOwner(tile, RTT_TRAM); + tram_owner = GetRoadOwner(tile, RoadTramType::Tram); } switch (GetRoadTileType(tile)) { @@ -2335,7 +2335,7 @@ static void ChangeTileOwner_Road(TileIndex tile, Owner old_owner, Owner new_owne Company::Get(new_owner)->infrastructure.road[rt] += 2; SetTileOwner(tile, new_owner); - for (RoadTramType rtt : _roadtramtypes) { + for (RoadTramType rtt : ROADTRAMTYPES_ALL) { if (GetRoadOwner(tile, rtt) == old_owner) { SetRoadOwner(tile, rtt, new_owner); } @@ -2345,7 +2345,7 @@ static void ChangeTileOwner_Road(TileIndex tile, Owner old_owner, Owner new_owne return; } - for (RoadTramType rtt : _roadtramtypes) { + for (RoadTramType rtt : ROADTRAMTYPES_ALL) { /* Update all roadtypes, no matter if they are present */ if (GetRoadOwner(tile, rtt) == old_owner) { RoadType rt = GetRoadType(tile, rtt); @@ -2423,7 +2423,7 @@ static CommandCost TerraformTile_Road(TileIndex tile, DoCommandFlags flags, int */ static bool CanConvertUnownedRoadType(Owner owner, RoadTramType rtt) { - return (owner == OWNER_NONE || (owner == OWNER_TOWN && rtt == RTT_ROAD)); + return (owner == OWNER_NONE || (owner == OWNER_TOWN && rtt == RoadTramType::Road)); } /** @@ -2481,7 +2481,7 @@ CommandCost CmdConvertRoad(DoCommandFlags flags, TileIndex tile, TileIndex area_ RoadTramType rtt = GetRoadTramType(to_type); CommandCost cost(EXPENSES_CONSTRUCTION); - CommandCost error = CommandCost((rtt == RTT_TRAM) ? STR_ERROR_NO_SUITABLE_TRAMWAY : STR_ERROR_NO_SUITABLE_ROAD); // by default, there is no road to convert. + CommandCost error = CommandCost((rtt == RoadTramType::Tram) ? STR_ERROR_NO_SUITABLE_TRAMWAY : STR_ERROR_NO_SUITABLE_ROAD); // by default, there is no road to convert. bool found_convertible_road = false; // whether we actually did convert any road/tram (see bug #7633) std::unique_ptr iter = TileIterator::Create(area_start, area_end, diagonal); @@ -2542,7 +2542,7 @@ CommandCost CmdConvertRoad(DoCommandFlags flags, TileIndex tile, TileIndex area_ continue; } - if (rtt == RTT_ROAD && owner == OWNER_TOWN) { + if (rtt == RoadTramType::Road && owner == OWNER_TOWN) { error.MakeError(STR_ERROR_OWNED_BY); if (IsLocalCompany()) { auto params = GetParamsForOwnedBy(OWNER_TOWN, tile); @@ -2604,7 +2604,7 @@ CommandCost CmdConvertRoad(DoCommandFlags flags, TileIndex tile, TileIndex area_ continue; } - if (rtt == RTT_ROAD && owner == OWNER_TOWN) { + if (rtt == RoadTramType::Road && owner == OWNER_TOWN) { error.MakeError(STR_ERROR_OWNED_BY); if (IsLocalCompany()) { auto params = GetParamsForOwnedBy(OWNER_TOWN, tile); diff --git a/src/road_gui.cpp b/src/road_gui.cpp index 468ac5699a..8cc8a37f2e 100644 --- a/src/road_gui.cpp +++ b/src/road_gui.cpp @@ -410,10 +410,10 @@ struct BuildRoadToolbarWindow : Window { this->GetWidget(WID_ROT_BUS_STATION)->SetToolTip(STR_TOOLBAR_DISABLED_NO_VEHICLE_AVAILABLE); this->GetWidget(WID_ROT_TRUCK_STATION)->SetToolTip(STR_TOOLBAR_DISABLED_NO_VEHICLE_AVAILABLE); } else { - this->GetWidget(WID_ROT_DEPOT)->SetToolTip(rtt == RTT_ROAD ? STR_ROAD_TOOLBAR_TOOLTIP_BUILD_ROAD_VEHICLE_DEPOT : STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRAM_VEHICLE_DEPOT); - this->GetWidget(WID_ROT_BUILD_WAYPOINT)->SetToolTip(rtt == RTT_ROAD ? STR_ROAD_TOOLBAR_TOOLTIP_CONVERT_ROAD_TO_WAYPOINT : STR_ROAD_TOOLBAR_TOOLTIP_CONVERT_TRAM_TO_WAYPOINT); - this->GetWidget(WID_ROT_BUS_STATION)->SetToolTip(rtt == RTT_ROAD ? STR_ROAD_TOOLBAR_TOOLTIP_BUILD_BUS_STATION : STR_ROAD_TOOLBAR_TOOLTIP_BUILD_PASSENGER_TRAM_STATION); - this->GetWidget(WID_ROT_TRUCK_STATION)->SetToolTip(rtt == RTT_ROAD ? STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRUCK_LOADING_BAY : STR_ROAD_TOOLBAR_TOOLTIP_BUILD_CARGO_TRAM_STATION); + this->GetWidget(WID_ROT_DEPOT)->SetToolTip(rtt == RoadTramType::Road ? STR_ROAD_TOOLBAR_TOOLTIP_BUILD_ROAD_VEHICLE_DEPOT : STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRAM_VEHICLE_DEPOT); + this->GetWidget(WID_ROT_BUILD_WAYPOINT)->SetToolTip(rtt == RoadTramType::Road ? STR_ROAD_TOOLBAR_TOOLTIP_CONVERT_ROAD_TO_WAYPOINT : STR_ROAD_TOOLBAR_TOOLTIP_CONVERT_TRAM_TO_WAYPOINT); + this->GetWidget(WID_ROT_BUS_STATION)->SetToolTip(rtt == RoadTramType::Road ? STR_ROAD_TOOLBAR_TOOLTIP_BUILD_BUS_STATION : STR_ROAD_TOOLBAR_TOOLTIP_BUILD_PASSENGER_TRAM_STATION); + this->GetWidget(WID_ROT_TRUCK_STATION)->SetToolTip(rtt == RoadTramType::Road ? STR_ROAD_TOOLBAR_TOOLTIP_BUILD_TRUCK_LOADING_BAY : STR_ROAD_TOOLBAR_TOOLTIP_BUILD_CARGO_TRAM_STATION); } } } @@ -907,12 +907,12 @@ struct BuildRoadToolbarWindow : Window { static EventState RoadToolbarGlobalHotkeys(int hotkey) { - return RoadTramToolbarGlobalHotkeys(hotkey, _last_built_roadtype, RTT_ROAD); + return RoadTramToolbarGlobalHotkeys(hotkey, _last_built_roadtype, RoadTramType::Road); } static EventState TramToolbarGlobalHotkeys(int hotkey) { - return RoadTramToolbarGlobalHotkeys(hotkey, _last_built_tramtype, RTT_TRAM); + return RoadTramToolbarGlobalHotkeys(hotkey, _last_built_tramtype, RoadTramType::Tram); } static inline HotkeyList road_hotkeys{"roadtoolbar", { @@ -1839,8 +1839,8 @@ DropDownList GetRoadTypeDropDownList(RoadTramTypes rtts, bool for_replacement, b } /* Filter listed road types */ - if (!HasBit(rtts, RTT_ROAD)) used_roadtypes.Reset(GetMaskForRoadTramType(RTT_ROAD)); - if (!HasBit(rtts, RTT_TRAM)) used_roadtypes.Reset(GetMaskForRoadTramType(RTT_TRAM)); + if (!rtts.Test(RoadTramType::Road)) used_roadtypes.Reset(GetMaskForRoadTramType(RoadTramType::Road)); + if (!rtts.Test(RoadTramType::Tram)) used_roadtypes.Reset(GetMaskForRoadTramType(RoadTramType::Tram)); DropDownList list; @@ -1894,8 +1894,8 @@ DropDownList GetScenRoadTypeDropDownList(RoadTramTypes rtts) /* Filter listed road types */ used_roadtypes.Reset(_roadtypes_hidden_mask); - if (!HasBit(rtts, RTT_ROAD)) used_roadtypes.Reset(GetMaskForRoadTramType(RTT_ROAD)); - if (!HasBit(rtts, RTT_TRAM)) used_roadtypes.Reset(GetMaskForRoadTramType(RTT_TRAM)); + if (!rtts.Test(RoadTramType::Road)) used_roadtypes.Reset(GetMaskForRoadTramType(RoadTramType::Road)); + if (!rtts.Test(RoadTramType::Tram)) used_roadtypes.Reset(GetMaskForRoadTramType(RoadTramType::Tram)); DropDownList list; diff --git a/src/road_map.h b/src/road_map.h index 7ccec917dc..a2917013aa 100644 --- a/src/road_map.h +++ b/src/road_map.h @@ -112,7 +112,7 @@ inline bool IsLevelCrossingTile(Tile t) inline RoadBits GetRoadBits(Tile t, RoadTramType rtt) { assert(IsNormalRoad(t)); - if (rtt == RTT_TRAM) return (RoadBits)GB(t.m3(), 0, 4); + if (rtt == RoadTramType::Tram) return (RoadBits)GB(t.m3(), 0, 4); return (RoadBits)GB(t.m5(), 0, 4); } @@ -124,7 +124,7 @@ inline RoadBits GetRoadBits(Tile t, RoadTramType rtt) */ inline RoadBits GetAllRoadBits(Tile tile) { - return GetRoadBits(tile, RTT_ROAD) | GetRoadBits(tile, RTT_TRAM); + return GetRoadBits(tile, RoadTramType::Road) | GetRoadBits(tile, RoadTramType::Tram); } /** @@ -137,7 +137,7 @@ inline RoadBits GetAllRoadBits(Tile tile) inline void SetRoadBits(Tile t, RoadBits r, RoadTramType rtt) { assert(IsNormalRoad(t)); // XXX incomplete - if (rtt == RTT_TRAM) { + if (rtt == RoadTramType::Tram) { SB(t.m3(), 0, 4, r); } else { SB(t.m5(), 0, 4, r); @@ -145,7 +145,7 @@ inline void SetRoadBits(Tile t, RoadBits r, RoadTramType rtt) } /** - * Get the road type for RoadTramType being RTT_ROAD. + * Get the road type for RoadTramType being RoadTramType::Road. * @param t The tile to query. * @return The road type. */ @@ -156,7 +156,7 @@ inline RoadType GetRoadTypeRoad(Tile t) } /** - * Get the road type for RoadTramType being RTT_TRAM. + * Get the road type for RoadTramType being RoadTramType::Tram. * @param t The tile to query. * @return The road (tram) type. */ @@ -174,7 +174,7 @@ inline RoadType GetRoadTypeTram(Tile t) */ inline RoadType GetRoadType(Tile t, RoadTramType rtt) { - return (rtt == RTT_TRAM) ? GetRoadTypeTram(t) : GetRoadTypeRoad(t); + return (rtt == RoadTramType::Tram) ? GetRoadTypeTram(t) : GetRoadTypeRoad(t); } /** @@ -193,7 +193,7 @@ inline RoadTypes GetPresentRoadTypes(Tile t) } /** - * Check if a tile has a road type when RoadTramType is RTT_ROAD. + * Check if a tile has a road type when RoadTramType is RoadTramType::Road. * @param t The tile to check. * @return True if the tile has a road type. */ @@ -203,7 +203,7 @@ inline bool HasRoadTypeRoad(Tile t) } /** - * Check if a tile has a road type when RoadTramType is RTT_TRAM. + * Check if a tile has a road type when RoadTramType is RoadTramType::Tram. * @param t The tile to check. * @return True if the tile has a (tram) road type. */ @@ -244,7 +244,7 @@ inline bool HasTileAnyRoadType(Tile t, RoadTypes rts) inline Owner GetRoadOwner(Tile t, RoadTramType rtt) { assert(MayHaveRoad(t)); - if (rtt == RTT_ROAD) return (Owner)GB(IsNormalRoadTile(t) ? t.m1() : t.m7(), 0, 5); + if (rtt == RoadTramType::Road) return (Owner)GB(IsNormalRoadTile(t) ? t.m1() : t.m7(), 0, 5); /* Trams don't need OWNER_TOWN, and remapping OWNER_NONE * to OWNER_TOWN makes it use one bit less */ @@ -260,7 +260,7 @@ inline Owner GetRoadOwner(Tile t, RoadTramType rtt) */ inline void SetRoadOwner(Tile t, RoadTramType rtt, Owner o) { - if (rtt == RTT_ROAD) { + if (rtt == RoadTramType::Road) { SB(IsNormalRoadTile(t) ? t.m1() : t.m7(), 0, 5, o.base()); } else { SB(t.m3(), 4, 4, (o == OWNER_NONE ? OWNER_TOWN : o).base()); @@ -289,7 +289,7 @@ inline bool IsRoadOwner(Tile t, RoadTramType rtt, Owner o) */ inline bool HasTownOwnedRoad(Tile t) { - return HasTileRoadType(t, RTT_ROAD) && IsRoadOwner(t, RTT_ROAD, OWNER_TOWN); + return HasTileRoadType(t, RoadTramType::Road) && IsRoadOwner(t, RoadTramType::Road, OWNER_TOWN); } /** @@ -614,7 +614,7 @@ inline void SetRoadTypeTram(Tile t, RoadType rt) */ inline void SetRoadType(Tile t, RoadTramType rtt, RoadType rt) { - if (rtt == RTT_TRAM) { + if (rtt == RoadTramType::Tram) { SetRoadTypeTram(t, rt); } else { SetRoadTypeRoad(t, rt); @@ -654,7 +654,7 @@ inline void MakeRoadNormal(Tile t, RoadBits bits, RoadType road_rt, RoadType tra t.m7() = 0; t.m8() = 0; SetRoadTypes(t, road_rt, tram_rt); - SetRoadOwner(t, RTT_TRAM, tram); + SetRoadOwner(t, RoadTramType::Tram, tram); } /** @@ -681,7 +681,7 @@ inline void MakeRoadCrossing(Tile t, Owner road, Owner tram, Owner rail, Axis ro t.m7() = road.base(); t.m8() = INVALID_ROADTYPE << 6 | rat; SetRoadTypes(t, road_rt, tram_rt); - SetRoadOwner(t, RTT_TRAM, tram); + SetRoadOwner(t, RoadTramType::Tram, tram); } /** @@ -715,7 +715,7 @@ inline void MakeRoadDepot(Tile tile, Owner owner, DepotID depot_id, DiagDirectio tile.m7() = owner.base(); tile.m8() = INVALID_ROADTYPE << 6; SetRoadType(tile, GetRoadTramType(rt), rt); - SetRoadOwner(tile, RTT_TRAM, owner); + SetRoadOwner(tile, RoadTramType::Tram, owner); } #endif /* ROAD_MAP_H */ diff --git a/src/road_type.h b/src/road_type.h index 83bbf4ea6c..7a301ac984 100644 --- a/src/road_type.h +++ b/src/road_type.h @@ -34,18 +34,18 @@ using RoadTypes = EnumBitSet; /** * The different types of road type. */ -enum RoadTramType : bool { - RTT_ROAD, ///< Road road type. - RTT_TRAM, ///< Tram road type. +enum class RoadTramType : uint8_t { + Road, ///< Road type. + Tram, ///< Tram type. + End, ///< End marker. + Invalid = 0xFF, ///< Invalid marker. }; -enum RoadTramTypes : uint8_t { - RTTB_ROAD = 1 << RTT_ROAD, ///< Road road type bit. - RTTB_TRAM = 1 << RTT_TRAM, ///< Tram road type bit. -}; -DECLARE_ENUM_AS_BIT_SET(RoadTramTypes) +/** Bitset of \c RoadTramType elements. */ +using RoadTramTypes = EnumBitSet; -static const RoadTramType _roadtramtypes[] = { RTT_ROAD, RTT_TRAM }; +/** All possible RoadTramTypes. */ +static constexpr RoadTramTypes ROADTRAMTYPES_ALL{RoadTramType::Road, RoadTramType::Tram}; /** * Enumeration for the road parts on a tile. diff --git a/src/roadveh_cmd.cpp b/src/roadveh_cmd.cpp index 2b0e036504..0424c6b76f 100644 --- a/src/roadveh_cmd.cpp +++ b/src/roadveh_cmd.cpp @@ -948,7 +948,7 @@ static Trackdir RoadFindPathToDest(RoadVehicle *v, TileIndex tile, DiagDirection if (RoadTypeIsTram(v->roadtype)) { /* Trams may only reverse on a tile if it contains at least the straight * trackbits or when it is a valid turning tile (i.e. one roadbit) */ - RoadBits rb = GetAnyRoadBits(tile, RTT_TRAM); + RoadBits rb = GetAnyRoadBits(tile, RoadTramType::Tram); RoadBits straight = AxisToRoadBits(DiagDirToAxis(enterdir)); reverse = ((rb & straight) == straight) || (rb == DiagDirToRoadBits(enterdir)); @@ -1243,7 +1243,7 @@ again: if ((v->Previous() != nullptr && v->Previous()->tile == tile) || (v->IsFrontEngine() && IsNormalRoadTile(tile) && !HasRoadWorks(tile) && HasTileAnyRoadType(tile, v->compatible_roadtypes) && - (needed & GetRoadBits(tile, RTT_TRAM)) != ROAD_NONE)) { + (needed & GetRoadBits(tile, RoadTramType::Tram)) != ROAD_NONE)) { /* * Taking the 'big' corner for trams only happens when: * - The previous vehicle in this (articulated) tram chain is @@ -1254,7 +1254,7 @@ again: * going to cause the tram to split up. * - Or the front of the tram can drive over the next tile. */ - } else if (!v->IsFrontEngine() || !CanBuildTramTrackOnTile(v->owner, tile, v->roadtype, needed) || ((~needed & GetAnyRoadBits(v->tile, RTT_TRAM, false)) == ROAD_NONE)) { + } else if (!v->IsFrontEngine() || !CanBuildTramTrackOnTile(v->owner, tile, v->roadtype, needed) || ((~needed & GetAnyRoadBits(v->tile, RoadTramType::Tram, false)) == ROAD_NONE)) { /* * Taking the 'small' corner for trams only happens when: * - We are not the from vehicle of an articulated tram. @@ -1365,7 +1365,7 @@ again: Trackdir dir; uint turn_around_start_frame = RVC_TURN_AROUND_START_FRAME; - if (RoadTypeIsTram(v->roadtype) && !IsRoadDepotTile(v->tile) && HasExactlyOneBit(GetAnyRoadBits(v->tile, RTT_TRAM, true))) { + if (RoadTypeIsTram(v->roadtype) && !IsRoadDepotTile(v->tile) && HasExactlyOneBit(GetAnyRoadBits(v->tile, RoadTramType::Tram, true))) { /* * The tram is turning around with one tram 'roadbit'. This means that * it is using the 'big' corner 'drive data'. However, to support the diff --git a/src/saveload/afterload.cpp b/src/saveload/afterload.cpp index 2d517f6a91..f9d2c82a50 100644 --- a/src/saveload/afterload.cpp +++ b/src/saveload/afterload.cpp @@ -438,8 +438,8 @@ static void FixOwnerOfRailTrack(Tile t) /* try to find any connected rail */ for (DiagDirection dd = DIAGDIR_BEGIN; dd < DIAGDIR_END; dd++) { TileIndex tt{t + TileOffsByDiagDir(dd)}; - if (GetTileTrackStatus(t, TRANSPORT_RAIL, 0, dd) != 0 && - GetTileTrackStatus(tt, TRANSPORT_RAIL, 0, ReverseDiagDir(dd)) != 0 && + if (GetTileTrackStatus(t, TRANSPORT_RAIL, RoadTramType::Invalid, dd) != 0 && + GetTileTrackStatus(tt, TRANSPORT_RAIL, RoadTramType::Invalid, ReverseDiagDir(dd)) != 0 && Company::IsValidID(GetTileOwner(tt))) { SetTileOwner(t, GetTileOwner(tt)); return; @@ -448,8 +448,8 @@ static void FixOwnerOfRailTrack(Tile t) if (IsLevelCrossingTile(t)) { /* else change the crossing to normal road (road vehicles won't care) */ - Owner road = GetRoadOwner(t, RTT_ROAD); - Owner tram = GetRoadOwner(t, RTT_TRAM); + Owner road = GetRoadOwner(t, RoadTramType::Road); + Owner tram = GetRoadOwner(t, RoadTramType::Tram); RoadBits bits = GetCrossingRoadBits(t); bool hasroad = HasBit(t.m7(), 6); bool hastram = HasBit(t.m7(), 7); @@ -460,7 +460,7 @@ static void FixOwnerOfRailTrack(Tile t) t.m3() = (hasroad ? bits : 0); t.m5() = (hastram ? bits : 0) | to_underlying(RoadTileType::Normal) << 6; SB(t.m6(), 2, 4, 0); - SetRoadOwner(t, RTT_TRAM, tram); + SetRoadOwner(t, RoadTramType::Tram, tram); return; } @@ -1248,7 +1248,7 @@ bool AfterLoadGame() t.m5() = (axis == AXIS_X ? ROAD_Y : ROAD_X) | to_underlying(RoadTileType::Normal) << 6; SB(t.m6(), 2, 4, 0); t.m7() = 1 << 6; - SetRoadOwner(t, RTT_TRAM, OWNER_NONE); + SetRoadOwner(t, RoadTramType::Tram, OWNER_NONE); } } else { if (GB(t.m5(), 3, 2) == 0) { @@ -1952,7 +1952,7 @@ bool AfterLoadGame() } } else if (IsTileType(t, TileType::Road)) { /* works for all RoadTileType */ - for (RoadTramType rtt : _roadtramtypes) { + for (RoadTramType rtt : ROADTRAMTYPES_ALL) { /* update even non-existing road types to update tile owner too */ Owner o = GetRoadOwner(t, rtt); if (o < MAX_COMPANIES && !Company::IsValidID(o)) SetRoadOwner(t, rtt, OWNER_NONE); @@ -2964,8 +2964,8 @@ bool AfterLoadGame() for (const auto t : Map::Iterate()) { if (!IsBayRoadStopTile(t)) continue; Owner o = GetTileOwner(t); - SetRoadOwner(t, RTT_ROAD, o); - SetRoadOwner(t, RTT_TRAM, o); + SetRoadOwner(t, RoadTramType::Road, o); + SetRoadOwner(t, RoadTramType::Tram, o); } } diff --git a/src/saveload/company_sl.cpp b/src/saveload/company_sl.cpp index 751e1c9c0c..d5f025ff4b 100644 --- a/src/saveload/company_sl.cpp +++ b/src/saveload/company_sl.cpp @@ -160,7 +160,7 @@ void AfterLoadCompanyStats() } /* Iterate all present road types as each can have a different owner. */ - for (RoadTramType rtt : _roadtramtypes) { + for (RoadTramType rtt : ROADTRAMTYPES_ALL) { RoadType rt = GetRoadType(tile, rtt); if (rt == INVALID_ROADTYPE) continue; c = Company::GetIfValid(IsRoadDepot(tile) ? GetTileOwner(tile) : GetRoadOwner(tile, rtt)); @@ -184,7 +184,7 @@ void AfterLoadCompanyStats() case StationType::Truck: case StationType::RoadWaypoint: { /* Iterate all present road types as each can have a different owner. */ - for (RoadTramType rtt : _roadtramtypes) { + for (RoadTramType rtt : ROADTRAMTYPES_ALL) { RoadType rt = GetRoadType(tile, rtt); if (rt == INVALID_ROADTYPE) continue; c = Company::GetIfValid(GetRoadOwner(tile, rtt)); @@ -242,7 +242,7 @@ void AfterLoadCompanyStats() case TRANSPORT_ROAD: { /* Iterate all present road types as each can have a different owner. */ - for (RoadTramType rtt : _roadtramtypes) { + for (RoadTramType rtt : ROADTRAMTYPES_ALL) { RoadType rt = GetRoadType(tile, rtt); if (rt == INVALID_ROADTYPE) continue; c = Company::GetIfValid(GetRoadOwner(tile, rtt)); diff --git a/src/saveload/labelmaps_sl.cpp b/src/saveload/labelmaps_sl.cpp index 863ce02949..01248a50de 100644 --- a/src/saveload/labelmaps_sl.cpp +++ b/src/saveload/labelmaps_sl.cpp @@ -84,7 +84,7 @@ struct ROTTChunkHandler : ChunkHandler { for (RoadType r = ROADTYPE_BEGIN; r != ROADTYPE_END; r++) { const RoadTypeInfo *rti = GetRoadTypeInfo(r); lo.label = rti->label; - lo.subtype = GetRoadTramType(r); + lo.subtype = to_underlying(GetRoadTramType(r)); SlSetArrayIndex(r); SlObject(&lo, description); diff --git a/src/script/api/script_marine.cpp b/src/script/api/script_marine.cpp index 716abfc82d..1fde9d9530 100644 --- a/src/script/api/script_marine.cpp +++ b/src/script/api/script_marine.cpp @@ -67,11 +67,11 @@ DiagDirection to_other_tile = ::DiagdirBetweenTiles(t2, t1); /* Determine the reachable tracks from the shared edge */ - TrackBits gtts1 = ::TrackStatusToTrackBits(::GetTileTrackStatus(t1, TRANSPORT_WATER, 0, ReverseDiagDir(to_other_tile))) & ::DiagdirReachesTracks(to_other_tile); + TrackBits gtts1 = ::TrackStatusToTrackBits(::GetTileTrackStatus(t1, TRANSPORT_WATER, RoadTramType::Invalid, ReverseDiagDir(to_other_tile))) & ::DiagdirReachesTracks(to_other_tile); if (gtts1 == TRACK_BIT_NONE) return false; to_other_tile = ReverseDiagDir(to_other_tile); - TrackBits gtts2 = ::TrackStatusToTrackBits(::GetTileTrackStatus(t2, TRANSPORT_WATER, 0, ReverseDiagDir(to_other_tile))) & ::DiagdirReachesTracks(to_other_tile); + TrackBits gtts2 = ::TrackStatusToTrackBits(::GetTileTrackStatus(t2, TRANSPORT_WATER, RoadTramType::Invalid, ReverseDiagDir(to_other_tile))) & ::DiagdirReachesTracks(to_other_tile); return gtts2 != TRACK_BIT_NONE; } diff --git a/src/script/api/script_road.cpp b/src/script/api/script_road.cpp index d67297bf98..862f1e08b6 100644 --- a/src/script/api/script_road.cpp +++ b/src/script/api/script_road.cpp @@ -442,7 +442,7 @@ static std::optional ToRoadPartOrientation(const TileIndex if (::IsNormalRoadTile(tile)) { rb = ::GetAllRoadBits(tile); } else { - rb = ::GetAnyRoadBits(tile, RTT_ROAD) | ::GetAnyRoadBits(tile, RTT_TRAM); + rb = ::GetAnyRoadBits(tile, RoadTramType::Road) | ::GetAnyRoadBits(tile, RoadTramType::Tram); } Array existing; @@ -656,7 +656,7 @@ static bool NeighbourHasReachableRoad(::RoadType rt, TileIndex start_tile, DiagD /* static */ ScriptRoad::RoadTramTypes ScriptRoad::GetRoadTramType(RoadType roadtype) { - return (RoadTramTypes)(1 << ::GetRoadTramType((::RoadType)roadtype)); + return static_cast(::RoadTramTypes{::GetRoadTramType(static_cast<::RoadType>(roadtype))}.base()); } /* static */ SQInteger ScriptRoad::GetMaxSpeed(RoadType road_type) diff --git a/src/script/api/script_road.hpp b/src/script/api/script_road.hpp index 26db7fa52d..9b0282f876 100644 --- a/src/script/api/script_road.hpp +++ b/src/script/api/script_road.hpp @@ -65,8 +65,8 @@ public: * Road/tram types */ enum RoadTramTypes : uint8_t { - ROADTRAMTYPES_ROAD = ::RTTB_ROAD, ///< Road road types. - ROADTRAMTYPES_TRAM = ::RTTB_TRAM, ///< Tram road types. + ROADTRAMTYPES_ROAD = ::RoadTramTypes{RoadTramType::Road}.base(), ///< Road road types. + ROADTRAMTYPES_TRAM = ::RoadTramTypes{RoadTramType::Tram}.base(), ///< Tram road types. }; /** diff --git a/src/script/api/script_roadtypelist.cpp b/src/script/api/script_roadtypelist.cpp index a9b1f5bbff..1d213ce104 100644 --- a/src/script/api/script_roadtypelist.cpp +++ b/src/script/api/script_roadtypelist.cpp @@ -18,7 +18,7 @@ ScriptRoadTypeList::ScriptRoadTypeList(ScriptRoad::RoadTramTypes rtts) EnforceDeityOrCompanyModeValid_Void(); ::CompanyID owner = ScriptObject::GetCompany(); for (RoadType rt = ROADTYPE_BEGIN; rt != ROADTYPE_END; rt++) { - if (!HasBit(rtts, GetRoadTramType(rt))) continue; + if (!::RoadTramTypes{rtts}.Test(GetRoadTramType(rt))) continue; if (::HasRoadTypeAvail(owner, rt)) this->AddItem(rt); } } diff --git a/src/script/api/script_tile.cpp b/src/script/api/script_tile.cpp index e31487e2b9..19d8c26109 100644 --- a/src/script/api/script_tile.cpp +++ b/src/script/api/script_tile.cpp @@ -38,9 +38,9 @@ if (::GetRoadTypeTram(tile) != INVALID_ROADTYPE) return false; /* Depots and crossings aren't considered buildable */ if (::GetRoadTileType(tile) != RoadTileType::Normal) return false; - if (!HasExactlyOneBit(::GetRoadBits(tile, RTT_ROAD))) return false; - if (::IsRoadOwner(tile, RTT_ROAD, OWNER_TOWN)) return true; - if (::IsRoadOwner(tile, RTT_ROAD, ScriptObject::GetCompany())) return true; + if (!HasExactlyOneBit(::GetRoadBits(tile, RoadTramType::Road))) return false; + if (::IsRoadOwner(tile, RoadTramType::Road, OWNER_TOWN)) return true; + if (::IsRoadOwner(tile, RoadTramType::Road, ScriptObject::GetCompany())) return true; return false; } } @@ -219,10 +219,10 @@ if (!::IsValidTile(tile)) return false; if (transport_type == TRANSPORT_ROAD) { - return ::TrackStatusToTrackdirBits(::GetTileTrackStatus(tile, (::TransportType)transport_type, 0)) != TRACKDIR_BIT_NONE || - ::TrackStatusToTrackdirBits(::GetTileTrackStatus(tile, (::TransportType)transport_type, 1)) != TRACKDIR_BIT_NONE; + return ::TrackStatusToTrackdirBits(::GetTileTrackStatus(tile, (::TransportType)transport_type, ::RoadTramType::Road)) != TRACKDIR_BIT_NONE || + ::TrackStatusToTrackdirBits(::GetTileTrackStatus(tile, (::TransportType)transport_type, ::RoadTramType::Tram)) != TRACKDIR_BIT_NONE; } else { - return ::TrackStatusToTrackdirBits(::GetTileTrackStatus(tile, (::TransportType)transport_type, 0)) != TRACKDIR_BIT_NONE; + return ::TrackStatusToTrackdirBits(::GetTileTrackStatus(tile, (::TransportType)transport_type, ::RoadTramType::Invalid)) != TRACKDIR_BIT_NONE; } } diff --git a/src/ship_cmd.cpp b/src/ship_cmd.cpp index 10c39fc1a6..04d98cd67a 100644 --- a/src/ship_cmd.cpp +++ b/src/ship_cmd.cpp @@ -75,7 +75,7 @@ bool IsValidImageIndex(uint8_t image_index) static inline TrackBits GetTileShipTrackStatus(TileIndex tile) { - return TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, 0)); + return TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid)); } static void GetShipIcon(EngineID engine, EngineImageType image_type, VehicleSpriteSeq *result) @@ -725,7 +725,7 @@ static void ShipController(Ship *v) /* Test if continuing forward would lead to a dead-end, moving into the dock. */ const DiagDirection exitdir = VehicleExitDir(v->direction, v->state); const TileIndex tile = TileAddByDiagDir(v->tile, exitdir); - if (TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, 0, exitdir)) == TRACK_BIT_NONE) return ReverseShip(v); + if (TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid, exitdir)) == TRACK_BIT_NONE) return ReverseShip(v); } else if (v->dest_tile != INVALID_TILE) { /* We have a target, let's see if we reached it... */ if (v->current_order.IsType(OT_GOTO_WAYPOINT) && diff --git a/src/signal.cpp b/src/signal.cpp index de63a04698..bbf10505bd 100644 --- a/src/signal.cpp +++ b/src/signal.cpp @@ -522,7 +522,7 @@ static SigSegState UpdateSignalsInBuffer(Owner owner) case TileType::Station: case TileType::Road: - if ((TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)) & _enterdir_to_trackbits[dir]) != TRACK_BIT_NONE) { + if ((TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid)) & _enterdir_to_trackbits[dir]) != TRACK_BIT_NONE) { /* only add to set when there is some 'interesting' track */ _tbdset.Add(tile, dir); _tbdset.Add(tile + TileOffsByDiagDir(dir), ReverseDiagDir(dir)); @@ -534,7 +534,7 @@ static SigSegState UpdateSignalsInBuffer(Owner owner) /* jump to next tile */ tile = tile + TileOffsByDiagDir(dir); dir = ReverseDiagDir(dir); - if ((TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)) & _enterdir_to_trackbits[dir]) != TRACK_BIT_NONE) { + if ((TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid)) & _enterdir_to_trackbits[dir]) != TRACK_BIT_NONE) { _tbdset.Add(tile, dir); break; } diff --git a/src/smallmap_gui.cpp b/src/smallmap_gui.cpp index 49194dbb7d..e893618530 100644 --- a/src/smallmap_gui.cpp +++ b/src/smallmap_gui.cpp @@ -588,7 +588,7 @@ uint32_t GetSmallMapOwnerPixels(TileIndex tile, TileType t, IncludeHeightmap inc case TileType::Industry: return MKCOLOUR_XXXX(PC_DARK_GREY); case TileType::House: return MKCOLOUR_XXXX(PC_DARK_RED); case TileType::Road: - o = GetRoadOwner(tile, HasRoadTypeRoad(tile) ? RTT_ROAD : RTT_TRAM); + o = GetRoadOwner(tile, HasRoadTypeRoad(tile) ? RoadTramType::Road : RoadTramType::Tram); break; default: diff --git a/src/station_cmd.cpp b/src/station_cmd.cpp index 49fabcf8d1..597c536398 100644 --- a/src/station_cmd.cpp +++ b/src/station_cmd.cpp @@ -1145,16 +1145,16 @@ static CommandCost CheckFlatLandRoadStop(TileIndex cur_tile, int &allowed_z, con if (build_over_road) { /* There is a road, check if we can build road+tram stop over it. */ - RoadType road_rt = GetRoadType(cur_tile, RTT_ROAD); + RoadType road_rt = GetRoadType(cur_tile, RoadTramType::Road); if (road_rt != INVALID_ROADTYPE) { - Owner road_owner = GetRoadOwner(cur_tile, RTT_ROAD); + Owner road_owner = GetRoadOwner(cur_tile, RoadTramType::Road); if (road_owner == OWNER_TOWN) { if (!_settings_game.construction.road_stop_on_town_road) return CommandCost(STR_ERROR_DRIVE_THROUGH_ON_TOWN_ROAD); } else if (!_settings_game.construction.road_stop_on_competitor_road && road_owner != OWNER_NONE) { ret = CheckOwnership(road_owner); if (ret.Failed()) return ret; } - uint num_pieces = CountBits(GetRoadBits(cur_tile, RTT_ROAD)); + uint num_pieces = CountBits(GetRoadBits(cur_tile, RoadTramType::Road)); if (rt != INVALID_ROADTYPE && RoadTypeIsRoad(rt) && !HasPowerOnRoad(rt, road_rt)) return CommandCost(STR_ERROR_NO_SUITABLE_ROAD); @@ -1169,18 +1169,18 @@ static CommandCost CheckFlatLandRoadStop(TileIndex cur_tile, int &allowed_z, con } /* There is a tram, check if we can build road+tram stop over it. */ - RoadType tram_rt = GetRoadType(cur_tile, RTT_TRAM); + RoadType tram_rt = GetRoadType(cur_tile, RoadTramType::Tram); if (tram_rt != INVALID_ROADTYPE) { - Owner tram_owner = GetRoadOwner(cur_tile, RTT_TRAM); + Owner tram_owner = GetRoadOwner(cur_tile, RoadTramType::Tram); if (Company::IsValidID(tram_owner) && (!_settings_game.construction.road_stop_on_competitor_road || /* Disallow breaking end-of-line of someone else * so trams can still reverse on this tile. */ - HasExactlyOneBit(GetRoadBits(cur_tile, RTT_TRAM)))) { + HasExactlyOneBit(GetRoadBits(cur_tile, RoadTramType::Tram)))) { ret = CheckOwnership(tram_owner); if (ret.Failed()) return ret; } - uint num_pieces = CountBits(GetRoadBits(cur_tile, RTT_TRAM)); + uint num_pieces = CountBits(GetRoadBits(cur_tile, RoadTramType::Tram)); if (rt != INVALID_ROADTYPE && RoadTypeIsTram(rt) && !HasPowerOnRoad(rt, tram_rt)) return CommandCost(STR_ERROR_NO_SUITABLE_ROAD); @@ -2170,10 +2170,10 @@ CommandCost CmdBuildRoadStop(DoCommandFlags flags, TileIndex tile, uint8_t width /* Check every tile in the area. */ for (TileIndex cur_tile : roadstop_area) { /* Get existing road types and owners before any tile clearing */ - RoadType road_rt = MayHaveRoad(cur_tile) ? GetRoadType(cur_tile, RTT_ROAD) : INVALID_ROADTYPE; - RoadType tram_rt = MayHaveRoad(cur_tile) ? GetRoadType(cur_tile, RTT_TRAM) : INVALID_ROADTYPE; - Owner road_owner = road_rt != INVALID_ROADTYPE ? GetRoadOwner(cur_tile, RTT_ROAD) : _current_company; - Owner tram_owner = tram_rt != INVALID_ROADTYPE ? GetRoadOwner(cur_tile, RTT_TRAM) : _current_company; + RoadType road_rt = MayHaveRoad(cur_tile) ? GetRoadType(cur_tile, RoadTramType::Road) : INVALID_ROADTYPE; + RoadType tram_rt = MayHaveRoad(cur_tile) ? GetRoadType(cur_tile, RoadTramType::Tram) : INVALID_ROADTYPE; + Owner road_owner = road_rt != INVALID_ROADTYPE ? GetRoadOwner(cur_tile, RoadTramType::Road) : _current_company; + Owner tram_owner = tram_rt != INVALID_ROADTYPE ? GetRoadOwner(cur_tile, RoadTramType::Tram) : _current_company; if (IsTileType(cur_tile, TileType::Station) && IsStationRoadStop(cur_tile)) { RemoveRoadStop(cur_tile, flags, *specindex); @@ -2206,8 +2206,8 @@ CommandCost CmdBuildRoadStop(DoCommandFlags flags, TileIndex tile, uint8_t width /* Update company infrastructure counts. If the current tile is a normal road tile, remove the old * bits first. */ if (IsNormalRoadTile(cur_tile)) { - UpdateCompanyRoadInfrastructure(road_rt, road_owner, -(int)CountBits(GetRoadBits(cur_tile, RTT_ROAD))); - UpdateCompanyRoadInfrastructure(tram_rt, tram_owner, -(int)CountBits(GetRoadBits(cur_tile, RTT_TRAM))); + UpdateCompanyRoadInfrastructure(road_rt, road_owner, -(int)CountBits(GetRoadBits(cur_tile, RoadTramType::Road))); + UpdateCompanyRoadInfrastructure(tram_rt, tram_owner, -(int)CountBits(GetRoadBits(cur_tile, RoadTramType::Tram))); } if (road_rt == INVALID_ROADTYPE && RoadTypeIsRoad(rt)) road_rt = rt; @@ -2310,7 +2310,7 @@ static CommandCost RemoveRoadStop(TileIndex tile, DoCommandFlags flags, int repl } /* Update company infrastructure counts. */ - for (RoadTramType rtt : _roadtramtypes) { + for (RoadTramType rtt : ROADTRAMTYPES_ALL) { RoadType rt = GetRoadType(tile, rtt); UpdateCompanyRoadInfrastructure(rt, GetRoadOwner(tile, rtt), -static_cast(ROAD_STOP_TRACKBIT_FACTOR)); } @@ -2393,7 +2393,7 @@ CommandCost RemoveRoadWaypointStop(TileIndex tile, DoCommandFlags flags, int rep if (flags.Test(DoCommandFlag::Execute)) { /* Update company infrastructure counts. */ - for (RoadTramType rtt : _roadtramtypes) { + for (RoadTramType rtt : ROADTRAMTYPES_ALL) { RoadType rt = GetRoadType(tile, rtt); UpdateCompanyRoadInfrastructure(rt, GetRoadOwner(tile, rtt), -static_cast(ROAD_STOP_TRACKBIT_FACTOR)); } @@ -2451,10 +2451,10 @@ static CommandCost RemoveGenericRoadStop(DoCommandFlags flags, const TileArea &r /* Save information on to-be-restored roads before the stop is removed. */ RoadBits road_bits = ROAD_NONE; - RoadType road_type[] = { INVALID_ROADTYPE, INVALID_ROADTYPE }; - Owner road_owner[] = { OWNER_NONE, OWNER_NONE }; + EnumClassIndexContainer, RoadTramType> road_type{INVALID_ROADTYPE, INVALID_ROADTYPE}; + EnumClassIndexContainer, RoadTramType> road_owner{OWNER_NONE, OWNER_NONE}; if (IsDriveThroughStopTile(cur_tile)) { - for (RoadTramType rtt : _roadtramtypes) { + for (RoadTramType rtt : ROADTRAMTYPES_ALL) { road_type[rtt] = GetRoadType(cur_tile, rtt); if (road_type[rtt] == INVALID_ROADTYPE) continue; road_owner[rtt] = GetRoadOwner(cur_tile, rtt); @@ -2478,14 +2478,14 @@ static CommandCost RemoveGenericRoadStop(DoCommandFlags flags, const TileArea &r had_success = true; /* Restore roads. */ - if (flags.Test(DoCommandFlag::Execute) && (road_type[RTT_ROAD] != INVALID_ROADTYPE || road_type[RTT_TRAM] != INVALID_ROADTYPE)) { - MakeRoadNormal(cur_tile, road_bits, road_type[RTT_ROAD], road_type[RTT_TRAM], ClosestTownFromTile(cur_tile, UINT_MAX)->index, - road_owner[RTT_ROAD], road_owner[RTT_TRAM]); + if (flags.Test(DoCommandFlag::Execute) && (road_type[RoadTramType::Road] != INVALID_ROADTYPE || road_type[RoadTramType::Tram] != INVALID_ROADTYPE)) { + MakeRoadNormal(cur_tile, road_bits, road_type[RoadTramType::Road], road_type[RoadTramType::Tram], ClosestTownFromTile(cur_tile, UINT_MAX)->index, + road_owner[RoadTramType::Road], road_owner[RoadTramType::Tram]); /* Update company infrastructure counts. */ int count = CountBits(road_bits); - UpdateCompanyRoadInfrastructure(road_type[RTT_ROAD], road_owner[RTT_ROAD], count); - UpdateCompanyRoadInfrastructure(road_type[RTT_TRAM], road_owner[RTT_TRAM], count); + UpdateCompanyRoadInfrastructure(road_type[RoadTramType::Road], road_owner[RoadTramType::Road], count); + UpdateCompanyRoadInfrastructure(road_type[RoadTramType::Tram], road_owner[RoadTramType::Tram], count); } } @@ -3600,14 +3600,14 @@ static void FillTileDescRoadStop(TileIndex tile, TileDesc &td) const RoadTypeInfo *rti = GetRoadTypeInfo(road_rt); td.roadtype = rti->strings.name; td.road_speed = rti->max_speed / 2; - road_owner = GetRoadOwner(tile, RTT_ROAD); + road_owner = GetRoadOwner(tile, RoadTramType::Road); } if (tram_rt != INVALID_ROADTYPE) { const RoadTypeInfo *rti = GetRoadTypeInfo(tram_rt); td.tramtype = rti->strings.name; td.tram_speed = rti->max_speed / 2; - tram_owner = GetRoadOwner(tile, RTT_TRAM); + tram_owner = GetRoadOwner(tile, RoadTramType::Tram); } if (IsDriveThroughStopTile(tile)) { @@ -3702,7 +3702,7 @@ static void GetTileDesc_Station(TileIndex tile, TileDesc &td) /** @copydoc GetTileTrackStatusProc */ -static TrackStatus GetTileTrackStatus_Station(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side) +static TrackStatus GetTileTrackStatus_Station(TileIndex tile, TransportType mode, RoadTramType sub_mode, DiagDirection side) { TrackBits trackbits = TRACK_BIT_NONE; @@ -4799,7 +4799,7 @@ void DeleteOilRig(TileIndex tile) static void ChangeTileOwner_Station(TileIndex tile, Owner old_owner, Owner new_owner) { if (IsAnyRoadStopTile(tile)) { - for (RoadTramType rtt : _roadtramtypes) { + for (RoadTramType rtt : ROADTRAMTYPES_ALL) { /* Update all roadtypes, no matter if they are present */ if (GetRoadOwner(tile, rtt) == old_owner) { RoadType rt = GetRoadType(tile, rtt); @@ -4897,7 +4897,7 @@ static CommandCost CanRemoveRoadWithStop(TileIndex tile, DoCommandFlags flags) CommandCost ret; if (GetRoadTypeTram(tile) != INVALID_ROADTYPE) { - Owner tram_owner = GetRoadOwner(tile, RTT_TRAM); + Owner tram_owner = GetRoadOwner(tile, RoadTramType::Tram); if (tram_owner != OWNER_NONE) { ret = CheckOwnership(tram_owner); if (ret.Failed()) return ret; @@ -4905,9 +4905,9 @@ static CommandCost CanRemoveRoadWithStop(TileIndex tile, DoCommandFlags flags) } if (GetRoadTypeRoad(tile) != INVALID_ROADTYPE) { - Owner road_owner = GetRoadOwner(tile, RTT_ROAD); + Owner road_owner = GetRoadOwner(tile, RoadTramType::Road); if (road_owner == OWNER_TOWN) { - ret = CheckAllowRemoveRoad(tile, GetAnyRoadBits(tile, RTT_ROAD), OWNER_TOWN, RTT_ROAD, flags); + ret = CheckAllowRemoveRoad(tile, GetAnyRoadBits(tile, RoadTramType::Road), OWNER_TOWN, RoadTramType::Road, flags); if (ret.Failed()) return ret; } else if (road_owner != OWNER_NONE) { ret = CheckOwnership(road_owner); @@ -4927,8 +4927,8 @@ CommandCost ClearTile_Station(TileIndex tile, DoCommandFlags flags) case StationType::Rail: return CommandCost(STR_ERROR_MUST_DEMOLISH_RAILROAD); case StationType::RailWaypoint: return CommandCost(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED); case StationType::Airport: return CommandCost(STR_ERROR_MUST_DEMOLISH_AIRPORT_FIRST); - case StationType::Truck: return CommandCost(HasTileRoadType(tile, RTT_TRAM) ? STR_ERROR_MUST_DEMOLISH_CARGO_TRAM_STATION_FIRST : STR_ERROR_MUST_DEMOLISH_TRUCK_STATION_FIRST); - case StationType::Bus: return CommandCost(HasTileRoadType(tile, RTT_TRAM) ? STR_ERROR_MUST_DEMOLISH_PASSENGER_TRAM_STATION_FIRST : STR_ERROR_MUST_DEMOLISH_BUS_STATION_FIRST); + case StationType::Truck: return CommandCost(HasTileRoadType(tile, RoadTramType::Tram) ? STR_ERROR_MUST_DEMOLISH_CARGO_TRAM_STATION_FIRST : STR_ERROR_MUST_DEMOLISH_TRUCK_STATION_FIRST); + case StationType::Bus: return CommandCost(HasTileRoadType(tile, RoadTramType::Tram) ? STR_ERROR_MUST_DEMOLISH_PASSENGER_TRAM_STATION_FIRST : STR_ERROR_MUST_DEMOLISH_BUS_STATION_FIRST); case StationType::RoadWaypoint: return CommandCost(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED); case StationType::Buoy: return CommandCost(STR_ERROR_BUOY_IN_THE_WAY); case StationType::Dock: return CommandCost(STR_ERROR_MUST_DEMOLISH_DOCK_FIRST); diff --git a/src/station_map.h b/src/station_map.h index 702b9f8a4c..e18a50a633 100644 --- a/src/station_map.h +++ b/src/station_map.h @@ -780,8 +780,8 @@ inline void MakeRoadStop(Tile t, Owner o, StationID sid, RoadStopType rst, RoadT { MakeStation(t, o, sid, (rst == RoadStopType::Bus ? StationType::Bus : StationType::Truck), d); SetRoadTypes(t, road_rt, tram_rt); - SetRoadOwner(t, RTT_ROAD, o); - SetRoadOwner(t, RTT_TRAM, o); + SetRoadOwner(t, RoadTramType::Road, o); + SetRoadOwner(t, RoadTramType::Tram, o); } /** @@ -800,8 +800,8 @@ inline void MakeDriveThroughRoadStop(Tile t, Owner station, Owner road, Owner tr { MakeStation(t, station, sid, rst, GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET + a); SetRoadTypes(t, road_rt, tram_rt); - SetRoadOwner(t, RTT_ROAD, road); - SetRoadOwner(t, RTT_TRAM, tram); + SetRoadOwner(t, RoadTramType::Road, road); + SetRoadOwner(t, RoadTramType::Tram, tram); } /** diff --git a/src/table/newgrf_debug_data.h b/src/table/newgrf_debug_data.h index 429156bee5..422f9e84ef 100644 --- a/src/table/newgrf_debug_data.h +++ b/src/table/newgrf_debug_data.h @@ -652,14 +652,14 @@ static const NIFeature _nif_roadtype = { {}, {}, _niv_roadtypes, - std::make_unique>(), + std::make_unique>(), }; static const NIFeature _nif_tramtype = { {}, {}, _niv_roadtypes, - std::make_unique>(), + std::make_unique>(), }; #define NICRS(cb_id, bit) NIC(cb_id, RoadStopSpec, callback_mask, bit) diff --git a/src/table/roadveh_movement.h b/src/table/roadveh_movement.h index fc7bad70f5..749bd0d055 100644 --- a/src/table/roadveh_movement.h +++ b/src/table/roadveh_movement.h @@ -1478,7 +1478,8 @@ static const RoadDriveEntry * const _road_tram_drive_data[] = { nullptr, }; -static const RoadDriveEntry * const * const _road_drive_data[2] = { +/** Road drive data for all \c RoadTramTypes */ +static const EnumClassIndexContainer, RoadTramType> _road_drive_data{ _road_road_drive_data, _road_tram_drive_data, }; diff --git a/src/tile_cmd.h b/src/tile_cmd.h index 5f2f2ac5bf..bcd00d79e1 100644 --- a/src/tile_cmd.h +++ b/src/tile_cmd.h @@ -13,6 +13,7 @@ #include "core/enum_type.hpp" #include "core/geometry_type.hpp" #include "command_type.h" +#include "road_type.h" #include "vehicle_type.h" #include "cargo_type.h" #include "track_type.h" @@ -116,7 +117,7 @@ using GetTileDescProc = void(TileIndex tile, TileDesc &td); * @return the track status information * @see GetTileTrackStatus */ -using GetTileTrackStatusProc = TrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side); +using GetTileTrackStatusProc = TrackStatus(TileIndex tile, TransportType mode, RoadTramType sub_mode, DiagDirection side); /** * Tile callback function signature for obtaining the produced cargo of a tile. @@ -215,7 +216,7 @@ struct TileTypeProcs { ClearTileProc *clear_tile_proc; ////< Called to clear a tile. AddAcceptedCargoProc *add_accepted_cargo_proc = nullptr; ///< Adds accepted cargo of the tile to cargo array supplied as parameter. GetTileDescProc *get_tile_desc_proc; ///< Get a description of a tile (for the 'land area information' tool). - GetTileTrackStatusProc *get_tile_track_status_proc = [](TileIndex, TransportType, uint, DiagDirection) -> TrackStatus { return {}; }; ///< Get available tracks and status of a tile. + GetTileTrackStatusProc *get_tile_track_status_proc = [](TileIndex, TransportType, RoadTramType, DiagDirection) -> TrackStatus { return {}; }; ///< Get available tracks and status of a tile. ClickTileProc *click_tile_proc = nullptr; ///< Called when tile is clicked AnimateTileProc *animate_tile_proc = nullptr; ///< Called to animate a tile. TileLoopProc *tile_loop_proc; ///< Called to periodically update the tile. @@ -229,7 +230,7 @@ struct TileTypeProcs { extern const EnumClassIndexContainer, TileType> _tile_type_procs; -TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side = INVALID_DIAGDIR); +TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, RoadTramType sub_mode, DiagDirection side = INVALID_DIAGDIR); VehicleEnterTileStates VehicleEnterTile(Vehicle *v, TileIndex tile, int x, int y); void ChangeTileOwner(TileIndex tile, Owner old_owner, Owner new_owner); void GetTileDesc(TileIndex tile, TileDesc &td); diff --git a/src/toolbar_gui.cpp b/src/toolbar_gui.cpp index f8fed2033a..7f545eb974 100644 --- a/src/toolbar_gui.cpp +++ b/src/toolbar_gui.cpp @@ -910,7 +910,7 @@ static CallBackFunction MenuClickBuildRail(int index) static CallBackFunction ToolbarBuildRoadClick(Window *w) { - ShowDropDownList(w, GetRoadTypeDropDownList(RTTB_ROAD), _last_built_roadtype, WID_TN_ROADS, 140, GetToolbarDropDownOptions(DropDownOption::Filterable), &_roadtype_filter); + ShowDropDownList(w, GetRoadTypeDropDownList(RoadTramType::Road), _last_built_roadtype, WID_TN_ROADS, 140, GetToolbarDropDownOptions(DropDownOption::Filterable), &_roadtype_filter); return CallBackFunction::None; } @@ -931,7 +931,7 @@ static CallBackFunction MenuClickBuildRoad(int index) static CallBackFunction ToolbarBuildTramClick(Window *w) { - ShowDropDownList(w, GetRoadTypeDropDownList(RTTB_TRAM), _last_built_tramtype, WID_TN_TRAMS, 140, GetToolbarDropDownOptions(DropDownOption::Filterable), &_tramtype_filter); + ShowDropDownList(w, GetRoadTypeDropDownList(RoadTramType::Tram), _last_built_tramtype, WID_TN_TRAMS, 140, GetToolbarDropDownOptions(DropDownOption::Filterable), &_tramtype_filter); return CallBackFunction::None; } @@ -1268,7 +1268,7 @@ static CallBackFunction ToolbarScenGenIndustry(Window *w) static CallBackFunction ToolbarScenBuildRoadClick(Window *w) { - ShowDropDownList(w, GetScenRoadTypeDropDownList(RTTB_ROAD), _last_built_roadtype, WID_TE_ROADS, 140, GetToolbarDropDownOptions(DropDownOption::Filterable), &_roadtype_filter); + ShowDropDownList(w, GetScenRoadTypeDropDownList(RoadTramType::Road), _last_built_roadtype, WID_TE_ROADS, 140, GetToolbarDropDownOptions(DropDownOption::Filterable), &_roadtype_filter); return CallBackFunction::None; } @@ -1287,7 +1287,7 @@ static CallBackFunction ToolbarScenBuildRoad(int index) static CallBackFunction ToolbarScenBuildTramClick(Window *w) { - ShowDropDownList(w, GetScenRoadTypeDropDownList(RTTB_TRAM), _last_built_tramtype, WID_TE_TRAMS, 140, GetToolbarDropDownOptions(DropDownOption::Filterable), &_tramtype_filter); + ShowDropDownList(w, GetScenRoadTypeDropDownList(RoadTramType::Tram), _last_built_tramtype, WID_TE_TRAMS, 140, GetToolbarDropDownOptions(DropDownOption::Filterable), &_tramtype_filter); return CallBackFunction::None; } @@ -2370,8 +2370,8 @@ struct ScenarioEditorToolbarWindow : Window { { this->SetWidgetDisabledState(WID_TE_DATE_BACKWARD, _settings_game.game_creation.starting_year <= CalendarTime::MIN_YEAR); this->SetWidgetDisabledState(WID_TE_DATE_FORWARD, _settings_game.game_creation.starting_year >= CalendarTime::MAX_YEAR); - this->SetWidgetDisabledState(WID_TE_ROADS, !GetRoadTypes(true).Any(GetMaskForRoadTramType(RTT_ROAD))); - this->SetWidgetDisabledState(WID_TE_TRAMS, !GetRoadTypes(true).Any(GetMaskForRoadTramType(RTT_TRAM))); + this->SetWidgetDisabledState(WID_TE_ROADS, !GetRoadTypes(true).Any(GetMaskForRoadTramType(RoadTramType::Road))); + this->SetWidgetDisabledState(WID_TE_TRAMS, !GetRoadTypes(true).Any(GetMaskForRoadTramType(RoadTramType::Tram))); this->DrawWidgets(); } diff --git a/src/town_cmd.cpp b/src/town_cmd.cpp index a28c4dbd3a..fdeb77f114 100644 --- a/src/town_cmd.cpp +++ b/src/town_cmd.cpp @@ -926,7 +926,7 @@ static RoadBits GetTownRoadBits(TileIndex tile) { if (IsRoadDepotTile(tile) || IsBayRoadStopTile(tile)) return ROAD_NONE; - return GetAnyRoadBits(tile, RTT_ROAD, true); + return GetAnyRoadBits(tile, RoadTramType::Road, true); } /** @@ -940,7 +940,7 @@ RoadType GetTownRoadType() const RoadTypeInfo *best = nullptr; const uint16_t assume_max_speed = 50; - for (RoadType rt : GetMaskForRoadTramType(RTT_ROAD)) { + for (RoadType rt : GetMaskForRoadTramType(RoadTramType::Road)) { const RoadTypeInfo *rti = GetRoadTypeInfo(rt); /* Can town build this road. */ @@ -967,7 +967,7 @@ RoadType GetTownRoadType() static TimerGameCalendar::Date GetTownRoadTypeFirstIntroductionDate() { const RoadTypeInfo *best = nullptr; - for (RoadType rt : GetMaskForRoadTramType(RTT_ROAD)) { + for (RoadType rt : GetMaskForRoadTramType(RoadTramType::Road)) { const RoadTypeInfo *rti = GetRoadTypeInfo(rt); if (!rti->flags.Test(RoadTypeFlag::TownBuild)) continue; // Town can't build this road type. @@ -1832,14 +1832,14 @@ static bool GrowTownAtRoad(Town *t, TileIndex tile, TownExpandModes modes) } tile = TileAddByDiagDir(tile, target_dir); - if (IsTileType(tile, TileType::Road) && !IsRoadDepot(tile) && HasTileRoadType(tile, RTT_ROAD)) { + if (IsTileType(tile, TileType::Road) && !IsRoadDepot(tile) && HasTileRoadType(tile, RoadTramType::Road)) { /* Don't allow building over roads of other cities */ - if (IsRoadOwner(tile, RTT_ROAD, OWNER_TOWN) && Town::GetByTile(tile) != t) { + if (IsRoadOwner(tile, RoadTramType::Road, OWNER_TOWN) && Town::GetByTile(tile) != t) { return false; - } else if (IsRoadOwner(tile, RTT_ROAD, OWNER_NONE) && _game_mode == GM_EDITOR) { + } else if (IsRoadOwner(tile, RoadTramType::Road, OWNER_NONE) && _game_mode == GM_EDITOR) { /* If we are in the SE, and this road-piece has no town owner yet, it just found an * owner :) (happy happy happy road now) */ - SetRoadOwner(tile, RTT_ROAD, OWNER_TOWN); + SetRoadOwner(tile, RoadTramType::Road, OWNER_TOWN); SetTownIndex(tile, t->index); } } diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp index 5bb750f17a..ccfcc4ff8e 100644 --- a/src/train_cmd.cpp +++ b/src/train_cmd.cpp @@ -2860,7 +2860,7 @@ static Track ChooseTrainTrack(Train *v, TileIndex tile, DiagDirection enterdir, /* Extend reservation until we have found a safe position. */ DiagDirection exitdir = TrackdirToExitdir(res_dest.trackdir); TileIndex next_tile = TileAddByDiagDir(res_dest.tile, exitdir); - TrackBits reachable = TrackdirBitsToTrackBits((TrackdirBits)(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, 0))) & DiagdirReachesTracks(exitdir); + TrackBits reachable = TrackdirBitsToTrackBits((TrackdirBits)(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, RoadTramType::Invalid))) & DiagdirReachesTracks(exitdir); if (Rail90DegTurnDisallowed(GetTileRailType(res_dest.tile), GetTileRailType(next_tile))) { reachable &= ~TrackCrossesTracks(TrackdirToTrack(res_dest.trackdir)); } @@ -2960,7 +2960,7 @@ bool TryPathReserve(Train *v, bool mark_as_stuck, bool first_tile_okay) DiagDirection exitdir = TrackdirToExitdir(origin.trackdir); TileIndex new_tile = TileAddByDiagDir(origin.tile, exitdir); - TrackBits reachable = TrackdirBitsToTrackBits(TrackStatusToTrackdirBits(GetTileTrackStatus(new_tile, TRANSPORT_RAIL, 0)) & DiagdirReachesTrackdirs(exitdir)); + TrackBits reachable = TrackdirBitsToTrackBits(TrackStatusToTrackdirBits(GetTileTrackStatus(new_tile, TRANSPORT_RAIL, RoadTramType::Invalid)) & DiagdirReachesTrackdirs(exitdir)); if (Rail90DegTurnDisallowed(GetTileRailType(origin.tile), GetTileRailType(new_tile))) reachable &= ~TrackCrossesTracks(TrackdirToTrack(origin.trackdir)); @@ -3350,7 +3350,7 @@ bool TrainController(Train *v, Vehicle *nomove, bool reverse) /* Get the status of the tracks in the new tile and mask * away the bits that aren't reachable. */ - TrackStatus ts = GetTileTrackStatus(gp.new_tile, TRANSPORT_RAIL, 0, ReverseDiagDir(enterdir)); + TrackStatus ts = GetTileTrackStatus(gp.new_tile, TRANSPORT_RAIL, RoadTramType::Invalid, ReverseDiagDir(enterdir)); TrackdirBits reachable_trackdirs = DiagdirReachesTrackdirs(enterdir); TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts) & reachable_trackdirs; @@ -3935,7 +3935,7 @@ static bool TrainCheckIfLineEnds(Train *v, bool reverse) TileIndex tile = v->tile + TileOffsByDiagDir(dir); /* Determine the track status on the next tile */ - TrackStatus ts = GetTileTrackStatus(tile, TRANSPORT_RAIL, 0, ReverseDiagDir(dir)); + TrackStatus ts = GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid, ReverseDiagDir(dir)); TrackdirBits reachable_trackdirs = DiagdirReachesTrackdirs(dir); TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts) & reachable_trackdirs; diff --git a/src/tunnel_map.h b/src/tunnel_map.h index 0575e84575..0840d7da12 100644 --- a/src/tunnel_map.h +++ b/src/tunnel_map.h @@ -59,8 +59,8 @@ inline void MakeRoadTunnel(Tile t, Owner o, DiagDirection d, RoadType road_rt, R SB(t.m6(), 2, 6, 0); t.m7() = 0; t.m8() = 0; - SetRoadOwner(t, RTT_ROAD, o); - if (o != OWNER_TOWN) SetRoadOwner(t, RTT_TRAM, o); + SetRoadOwner(t, RoadTramType::Road, o); + if (o != OWNER_TOWN) SetRoadOwner(t, RoadTramType::Tram, o); SetRoadTypes(t, road_rt, tram_rt); } diff --git a/src/tunnelbridge_cmd.cpp b/src/tunnelbridge_cmd.cpp index 4edc05b203..8356b2f763 100644 --- a/src/tunnelbridge_cmd.cpp +++ b/src/tunnelbridge_cmd.cpp @@ -553,8 +553,8 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t case TRANSPORT_ROAD: { if (is_new_owner) { /* Also give unowned present roadtypes to new owner */ - if (hasroad && GetRoadOwner(tile_start, RTT_ROAD) == OWNER_NONE) hasroad = false; - if (hastram && GetRoadOwner(tile_start, RTT_TRAM) == OWNER_NONE) hastram = false; + if (hasroad && GetRoadOwner(tile_start, RoadTramType::Road) == OWNER_NONE) hasroad = false; + if (hastram && GetRoadOwner(tile_start, RoadTramType::Tram) == OWNER_NONE) hastram = false; } if (c != nullptr) { /* Add all new road types to the company infrastructure counter. */ @@ -567,8 +567,8 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t c->infrastructure.road[tram_rt] += bridge_len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR; } } - Owner owner_road = hasroad ? GetRoadOwner(tile_start, RTT_ROAD) : company; - Owner owner_tram = hastram ? GetRoadOwner(tile_start, RTT_TRAM) : company; + Owner owner_road = hasroad ? GetRoadOwner(tile_start, RoadTramType::Road) : company; + Owner owner_tram = hastram ? GetRoadOwner(tile_start, RoadTramType::Tram) : company; MakeRoadBridgeRamp(tile_start, owner, owner_road, owner_tram, bridge_type, dir, road_rt, tram_rt); MakeRoadBridgeRamp(tile_end, owner, owner_road, owner_tram, bridge_type, ReverseDiagDir(dir), road_rt, tram_rt); break; @@ -823,8 +823,8 @@ static inline CommandCost CheckAllowRemoveTunnelBridge(TileIndex tile) Owner road_owner = _current_company; Owner tram_owner = _current_company; - if (road_rt != INVALID_ROADTYPE) road_owner = GetRoadOwner(tile, RTT_ROAD); - if (tram_rt != INVALID_ROADTYPE) tram_owner = GetRoadOwner(tile, RTT_TRAM); + if (road_rt != INVALID_ROADTYPE) road_owner = GetRoadOwner(tile, RoadTramType::Road); + if (tram_rt != INVALID_ROADTYPE) tram_owner = GetRoadOwner(tile, RoadTramType::Tram); /* We can remove unowned road and if the town allows it */ if (road_owner == OWNER_TOWN && _current_company != OWNER_TOWN && !(_settings_game.construction.extra_dynamite || _cheats.magic_bulldozer.value)) { @@ -921,8 +921,8 @@ static CommandCost DoClearTunnel(TileIndex tile, DoCommandFlags flags) if (v != nullptr) TryPathReserve(v); } else { /* A full diagonal road tile has two road bits. */ - UpdateCompanyRoadInfrastructure(GetRoadTypeRoad(tile), GetRoadOwner(tile, RTT_ROAD), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR)); - UpdateCompanyRoadInfrastructure(GetRoadTypeTram(tile), GetRoadOwner(tile, RTT_TRAM), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR)); + UpdateCompanyRoadInfrastructure(GetRoadTypeRoad(tile), GetRoadOwner(tile, RoadTramType::Road), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR)); + UpdateCompanyRoadInfrastructure(GetRoadTypeTram(tile), GetRoadOwner(tile, RoadTramType::Tram), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR)); DoClearSquare(tile); DoClearSquare(endtile); @@ -988,8 +988,8 @@ static CommandCost DoClearBridge(TileIndex tile, DoCommandFlags flags) if (Company::IsValidID(owner)) Company::Get(owner)->infrastructure.rail[GetRailType(tile)] -= len * TUNNELBRIDGE_TRACKBIT_FACTOR; } else if (GetTunnelBridgeTransportType(tile) == TRANSPORT_ROAD) { /* A full diagonal road tile has two road bits. */ - UpdateCompanyRoadInfrastructure(GetRoadTypeRoad(tile), GetRoadOwner(tile, RTT_ROAD), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR)); - UpdateCompanyRoadInfrastructure(GetRoadTypeTram(tile), GetRoadOwner(tile, RTT_TRAM), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR)); + UpdateCompanyRoadInfrastructure(GetRoadTypeRoad(tile), GetRoadOwner(tile, RoadTramType::Road), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR)); + UpdateCompanyRoadInfrastructure(GetRoadTypeTram(tile), GetRoadOwner(tile, RoadTramType::Tram), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR)); } else { // Aqueduct if (Company::IsValidID(owner)) Company::Get(owner)->infrastructure.water -= len * TUNNELBRIDGE_TRACKBIT_FACTOR; } @@ -1773,13 +1773,13 @@ static void GetTileDesc_TunnelBridge(TileIndex tile, TileDesc &td) const RoadTypeInfo *rti = GetRoadTypeInfo(road_rt); td.roadtype = rti->strings.name; td.road_speed = rti->max_speed / 2; - road_owner = GetRoadOwner(tile, RTT_ROAD); + road_owner = GetRoadOwner(tile, RoadTramType::Road); } if (tram_rt != INVALID_ROADTYPE) { const RoadTypeInfo *rti = GetRoadTypeInfo(tram_rt); td.tramtype = rti->strings.name; td.tram_speed = rti->max_speed / 2; - tram_owner = GetRoadOwner(tile, RTT_TRAM); + tram_owner = GetRoadOwner(tile, RoadTramType::Tram); } /* Is there a mix of owners? */ @@ -1850,7 +1850,7 @@ static void TileLoop_TunnelBridge(TileIndex tile) } /** @copydoc GetTileTrackStatusProc */ -static TrackStatus GetTileTrackStatus_TunnelBridge(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side) +static TrackStatus GetTileTrackStatus_TunnelBridge(TileIndex tile, TransportType mode, RoadTramType sub_mode, DiagDirection side) { TransportType transport_type = GetTunnelBridgeTransportType(tile); if (transport_type != mode || (transport_type == TRANSPORT_ROAD && !HasTileRoadType(tile, (RoadTramType)sub_mode))) return 0; @@ -1871,7 +1871,7 @@ static void ChangeTileOwner_TunnelBridge(TileIndex tile, Owner old_owner, Owner TransportType tt = GetTunnelBridgeTransportType(tile); if (tt == TRANSPORT_ROAD) { - for (RoadTramType rtt : _roadtramtypes) { + for (RoadTramType rtt : ROADTRAMTYPES_ALL) { /* Update all roadtypes, no matter if they are present */ if (GetRoadOwner(tile, rtt) == old_owner) { RoadType rt = GetRoadType(tile, rtt); diff --git a/src/vehicle.cpp b/src/vehicle.cpp index 32a5645c75..c79da6ba8a 100644 --- a/src/vehicle.cpp +++ b/src/vehicle.cpp @@ -1942,7 +1942,7 @@ UnitID GetFreeUnitNumber(VehicleType type) * @return true if there is any reason why you may build * the infrastructure for the given vehicle type */ -bool CanBuildVehicleInfrastructure(VehicleType type, uint8_t subtype) +bool CanBuildVehicleInfrastructure(VehicleType type, RoadTramType subtype) { assert(IsCompanyBuildableVehicleType(type)); @@ -1955,7 +1955,7 @@ bool CanBuildVehicleInfrastructure(VehicleType type, uint8_t subtype) max = _settings_game.vehicle.max_trains; break; case VEH_ROAD: - if (!HasAnyRoadTypesAvail(_local_company, (RoadTramType)subtype)) return false; + if (!HasAnyRoadTypesAvail(_local_company, subtype)) return false; max = _settings_game.vehicle.max_roadveh; break; case VEH_SHIP: max = _settings_game.vehicle.max_ships; break; @@ -1967,7 +1967,7 @@ bool CanBuildVehicleInfrastructure(VehicleType type, uint8_t subtype) if (max > 0) { /* Can we actually build the vehicle type? */ for (const Engine *e : Engine::IterateType(type)) { - if (type == VEH_ROAD && GetRoadTramType(e->VehInfo().roadtype) != (RoadTramType)subtype) continue; + if (type == VEH_ROAD && GetRoadTramType(e->VehInfo().roadtype) != subtype) continue; if (e->company_avail.Test(_local_company)) return true; } return false; @@ -1975,7 +1975,7 @@ bool CanBuildVehicleInfrastructure(VehicleType type, uint8_t subtype) /* We should be able to build infrastructure when we have the actual vehicle type */ for (const Vehicle *v : Vehicle::Iterate()) { - if (v->type == VEH_ROAD && GetRoadTramType(RoadVehicle::From(v)->roadtype) != (RoadTramType)subtype) continue; + if (v->type == VEH_ROAD && GetRoadTramType(RoadVehicle::From(v)->roadtype) != subtype) continue; if (v->owner == _local_company && v->type == type) return true; } diff --git a/src/vehicle_func.h b/src/vehicle_func.h index cfb2e09f55..a5ab06fa2d 100644 --- a/src/vehicle_func.h +++ b/src/vehicle_func.h @@ -216,7 +216,7 @@ UnitID GetFreeUnitNumber(VehicleType type); void VehicleEnterDepot(Vehicle *v); -bool CanBuildVehicleInfrastructure(VehicleType type, uint8_t subtype = 0); +bool CanBuildVehicleInfrastructure(VehicleType type, RoadTramType subtype = RoadTramType::Invalid); /** Position information of a vehicle after it moved */ struct GetNewVehiclePosResult { diff --git a/src/water_cmd.cpp b/src/water_cmd.cpp index 98b89bf171..e225e4aeae 100644 --- a/src/water_cmd.cpp +++ b/src/water_cmd.cpp @@ -186,7 +186,7 @@ bool IsPossibleDockingTile(Tile t) case TileType::Railway: case TileType::Station: case TileType::TunnelBridge: - return TrackStatusToTrackBits(GetTileTrackStatus(t, TRANSPORT_WATER, 0)) != TRACK_BIT_NONE; + return TrackStatusToTrackBits(GetTileTrackStatus(t, TRANSPORT_WATER, RoadTramType::Invalid)) != TRACK_BIT_NONE; default: return false; @@ -1384,7 +1384,7 @@ void ConvertGroundTilesIntoWaterTiles() } /** @copydoc GetTileTrackStatusProc */ -static TrackStatus GetTileTrackStatus_Water(TileIndex tile, TransportType mode, [[maybe_unused]] uint sub_mode, [[maybe_unused]] DiagDirection side) +static TrackStatus GetTileTrackStatus_Water(TileIndex tile, TransportType mode, [[maybe_unused]] RoadTramType sub_mode, [[maybe_unused]] DiagDirection side) { static const TrackBits coast_tracks[] = {TRACK_BIT_NONE, TRACK_BIT_RIGHT, TRACK_BIT_UPPER, TRACK_BIT_NONE, TRACK_BIT_LEFT, TRACK_BIT_NONE, TRACK_BIT_NONE, TRACK_BIT_NONE, TRACK_BIT_LOWER, TRACK_BIT_NONE, TRACK_BIT_NONE, TRACK_BIT_NONE, TRACK_BIT_NONE, TRACK_BIT_NONE, TRACK_BIT_NONE, TRACK_BIT_NONE}; diff --git a/src/waypoint_cmd.cpp b/src/waypoint_cmd.cpp index b76d8a239c..3c970383eb 100644 --- a/src/waypoint_cmd.cpp +++ b/src/waypoint_cmd.cpp @@ -431,10 +431,10 @@ CommandCost CmdBuildRoadWaypoint(DoCommandFlags flags, TileIndex start_tile, Axi /* Check every tile in the area. */ for (TileIndex cur_tile : roadstop_area) { /* Get existing road types and owners before any tile clearing */ - RoadType road_rt = MayHaveRoad(cur_tile) ? GetRoadType(cur_tile, RTT_ROAD) : INVALID_ROADTYPE; - RoadType tram_rt = MayHaveRoad(cur_tile) ? GetRoadType(cur_tile, RTT_TRAM) : INVALID_ROADTYPE; - Owner road_owner = road_rt != INVALID_ROADTYPE ? GetRoadOwner(cur_tile, RTT_ROAD) : _current_company; - Owner tram_owner = tram_rt != INVALID_ROADTYPE ? GetRoadOwner(cur_tile, RTT_TRAM) : _current_company; + RoadType road_rt = MayHaveRoad(cur_tile) ? GetRoadType(cur_tile, RoadTramType::Road) : INVALID_ROADTYPE; + RoadType tram_rt = MayHaveRoad(cur_tile) ? GetRoadType(cur_tile, RoadTramType::Tram) : INVALID_ROADTYPE; + Owner road_owner = road_rt != INVALID_ROADTYPE ? GetRoadOwner(cur_tile, RoadTramType::Road) : _current_company; + Owner tram_owner = tram_rt != INVALID_ROADTYPE ? GetRoadOwner(cur_tile, RoadTramType::Tram) : _current_company; if (IsRoadWaypointTile(cur_tile)) { RemoveRoadWaypointStop(cur_tile, flags, *specindex); @@ -447,8 +447,8 @@ CommandCost CmdBuildRoadWaypoint(DoCommandFlags flags, TileIndex start_tile, Axi /* Update company infrastructure counts. If the current tile is a normal road tile, remove the old * bits first. */ if (IsNormalRoadTile(cur_tile)) { - UpdateCompanyRoadInfrastructure(road_rt, road_owner, -(int)CountBits(GetRoadBits(cur_tile, RTT_ROAD))); - UpdateCompanyRoadInfrastructure(tram_rt, tram_owner, -(int)CountBits(GetRoadBits(cur_tile, RTT_TRAM))); + UpdateCompanyRoadInfrastructure(road_rt, road_owner, -(int)CountBits(GetRoadBits(cur_tile, RoadTramType::Road))); + UpdateCompanyRoadInfrastructure(tram_rt, tram_owner, -(int)CountBits(GetRoadBits(cur_tile, RoadTramType::Tram))); } UpdateCompanyRoadInfrastructure(road_rt, road_owner, ROAD_STOP_TRACKBIT_FACTOR);