diff --git a/src/airport_gui.cpp b/src/airport_gui.cpp index 03d66f000a..449d928890 100644 --- a/src/airport_gui.cpp +++ b/src/airport_gui.cpp @@ -112,7 +112,7 @@ struct BuildAirToolbarWindow : Window { bool can_build = CanBuildVehicleInfrastructure(VehicleType::Aircraft); this->SetWidgetDisabledState(WID_AT_AIRPORT, !can_build); if (!can_build) { - CloseWindowById(WindowClass::BuildStation, TRANSPORT_AIR); + CloseWindowById(WindowClass::BuildStation, TransportType::Air); /* Show in the tooltip why this button is disabled. */ this->GetWidget(WID_AT_AIRPORT)->SetToolTip(STR_TOOLBAR_DISABLED_NO_VEHICLE_AVAILABLE); @@ -179,7 +179,7 @@ struct BuildAirToolbarWindow : Window { this->RaiseButtons(); - CloseWindowById(WindowClass::BuildStation, TRANSPORT_AIR); + CloseWindowById(WindowClass::BuildStation, TransportType::Air); CloseWindowById(WindowClass::JoinStation, 0); } @@ -236,7 +236,7 @@ Window *ShowBuildAirToolbar() if (!Company::IsValidID(_local_company)) return nullptr; CloseWindowByClass(WindowClass::BuildToolbar); - return AllocateWindowDescFront(_air_toolbar_desc, TRANSPORT_AIR); + return AllocateWindowDescFront(_air_toolbar_desc, TransportType::Air); } class BuildAirportWindow : public PickerWindowBase { @@ -268,7 +268,7 @@ public: this->vscroll->SetCapacity(5); this->vscroll->SetPosition(0); - this->FinishInitNested(TRANSPORT_AIR); + this->FinishInitNested(TransportType::Air); this->SetWidgetLoweredState(WID_AP_BTN_DONTHILIGHT, !_settings_client.gui.station_show_coverage); this->SetWidgetLoweredState(WID_AP_BTN_DOHILIGHT, _settings_client.gui.station_show_coverage); diff --git a/src/bridge_gui.cpp b/src/bridge_gui.cpp index 0883a99b96..f461a184c6 100644 --- a/src/bridge_gui.cpp +++ b/src/bridge_gui.cpp @@ -59,7 +59,7 @@ void CcBuildBridge(Commands, const CommandCost &result, TileIndex end_tile, Tile if (result.Failed()) return; if (_settings_client.sound.confirm) SndPlayTileFx(SND_27_CONSTRUCTION_BRIDGE, end_tile); - if (transport_type == TRANSPORT_ROAD) { + if (transport_type == TransportType::Road) { DiagDirection end_direction = ReverseDiagDir(GetTunnelBridgeDirection(end_tile)); ConnectRoadToStructure(end_tile, end_direction); @@ -84,7 +84,7 @@ private: TileIndex start_tile = INVALID_TILE; TileIndex end_tile = INVALID_TILE; - TransportType transport_type = INVALID_TRANSPORT; + TransportType transport_type = TransportType::Invalid; RailType railtype = INVALID_RAILTYPE; ///< Rail type to build if building a rail bridge. RoadType roadtype = INVALID_ROADTYPE; ///< Road type to build if building a road bridge. GUIBridgeList bridges{}; @@ -112,8 +112,8 @@ private: void BuildBridge(BridgeType type) { switch (this->transport_type) { - case TRANSPORT_RAIL: _last_railbridge_type = type; break; - case TRANSPORT_ROAD: _last_roadbridge_type = type; break; + case TransportType::Rail: _last_railbridge_type = type; break; + case TransportType::Road: _last_roadbridge_type = type; break; default: break; } Command::Post(STR_ERROR_CAN_T_BUILD_BRIDGE_HERE, CcBuildBridge, @@ -175,7 +175,7 @@ public: this->CreateNestedTree(); this->vscroll = this->GetScrollbar(WID_BBS_SCROLLBAR); /* Change the data, or the caption of the gui. Set it to road or rail, accordingly. */ - this->GetWidget(WID_BBS_CAPTION)->SetString((transport_type == TRANSPORT_ROAD) ? STR_SELECT_ROAD_BRIDGE_CAPTION : STR_SELECT_RAIL_BRIDGE_CAPTION); + this->GetWidget(WID_BBS_CAPTION)->SetString((transport_type == TransportType::Road) ? STR_SELECT_ROAD_BRIDGE_CAPTION : STR_SELECT_RAIL_BRIDGE_CAPTION); this->FinishInitNested(transport_type); // Initializes 'this->icon_width'. this->parent = FindWindowById(WindowClass::BuildToolbar, transport_type); @@ -381,8 +381,8 @@ void ShowBuildBridgeWindow(TileIndex start, TileIndex end, TransportType transpo */ BridgeType last_bridge_type = 0; switch (transport_type) { - case TRANSPORT_ROAD: last_bridge_type = _last_roadbridge_type; break; - case TRANSPORT_RAIL: last_bridge_type = _last_railbridge_type; break; + case TransportType::Road: last_bridge_type = _last_roadbridge_type; break; + case TransportType::Rail: last_bridge_type = _last_railbridge_type; break; default: break; // water ways and air routes don't have bridge types } if (_ctrl_pressed && CheckBridgeAvailability(last_bridge_type, bridge_len).Succeeded()) { @@ -401,7 +401,7 @@ void ShowBuildBridgeWindow(TileIndex start, TileIndex end, TransportType transpo Money infra_cost = 0; switch (transport_type) { - case TRANSPORT_ROAD: { + case TransportType::Road: { /* In case we add a new road type as well, we must be aware of those costs. */ RoadType road_rt = INVALID_ROADTYPE; RoadType tram_rt = INVALID_ROADTYPE; @@ -420,7 +420,7 @@ void ShowBuildBridgeWindow(TileIndex start, TileIndex end, TransportType transpo break; } - case TRANSPORT_RAIL: infra_cost = (bridge_len + 2) * RailBuildCost(railtype); break; + case TransportType::Rail: infra_cost = (bridge_len + 2) * RailBuildCost(railtype); break; default: break; } diff --git a/src/bridge_map.h b/src/bridge_map.h index 4f63fcbe6f..678ca252a1 100644 --- a/src/bridge_map.h +++ b/src/bridge_map.h @@ -133,7 +133,7 @@ inline void MakeBridgeRamp(Tile t, Owner o, BridgeType bridgetype, DiagDirection t.m2() = 0; t.m3() = 0; t.m4() = 0; - t.m5() = 1 << 7 | tt << 2 | to_underlying(d); + t.m5() = 1 << 7 | to_underlying(tt) << 2 | to_underlying(d); SB(t.m6(), 2, 4, bridgetype); SB(t.m6(), 6, 2, 0); t.m7() = 0; @@ -153,7 +153,7 @@ 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); + MakeBridgeRamp(t, o, bridgetype, d, TransportType::Road); SetRoadOwner(t, RoadTramType::Road, owner_road); if (owner_tram != OWNER_TOWN) SetRoadOwner(t, RoadTramType::Tram, owner_tram); SetRoadTypes(t, road_rt, tram_rt); @@ -169,7 +169,7 @@ inline void MakeRoadBridgeRamp(Tile t, Owner o, Owner owner_road, Owner owner_tr */ inline void MakeRailBridgeRamp(Tile t, Owner o, BridgeType bridgetype, DiagDirection d, RailType rt) { - MakeBridgeRamp(t, o, bridgetype, d, TRANSPORT_RAIL); + MakeBridgeRamp(t, o, bridgetype, d, TransportType::Rail); SetRailType(t, rt); } @@ -181,7 +181,7 @@ inline void MakeRailBridgeRamp(Tile t, Owner o, BridgeType bridgetype, DiagDirec */ inline void MakeAqueductBridgeRamp(Tile t, Owner o, DiagDirection d) { - MakeBridgeRamp(t, o, 0, d, TRANSPORT_WATER); + MakeBridgeRamp(t, o, 0, d, TransportType::Water); } #endif /* BRIDGE_MAP_H */ diff --git a/src/depot_map.h b/src/depot_map.h index d6ac291dec..919828d899 100644 --- a/src/depot_map.h +++ b/src/depot_map.h @@ -23,16 +23,16 @@ inline bool IsDepotTypeTile(Tile tile, TransportType type) { switch (type) { default: NOT_REACHED(); - case TRANSPORT_RAIL: + case TransportType::Rail: return IsRailDepotTile(tile); - case TRANSPORT_ROAD: + case TransportType::Road: return IsRoadDepotTile(tile); - case TRANSPORT_WATER: + case TransportType::Water: return IsShipDepotTile(tile); - case TRANSPORT_AIR: + case TransportType::Air: return IsHangarTile(tile); } } diff --git a/src/disaster_vehicle.cpp b/src/disaster_vehicle.cpp index f6169cb8e6..e499dcc96b 100644 --- a/src/disaster_vehicle.cpp +++ b/src/disaster_vehicle.cpp @@ -698,7 +698,7 @@ static bool DisasterTick_Submarine(DisasterVehicle *v) TileIndex tile = v->tile + TileOffsByDiagDir(DirToDiagDir(v->direction)); if (IsValidTile(tile)) { - TrackBits trackbits = TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid).trackdirs); + TrackBits trackbits = TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TransportType::Water, RoadTramType::Invalid).trackdirs); 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/dock_gui.cpp b/src/dock_gui.cpp index 2715c2f1ce..799f01dea9 100644 --- a/src/dock_gui.cpp +++ b/src/dock_gui.cpp @@ -129,8 +129,8 @@ struct BuildDocksToolbarWindow : Window { WID_DT_STATION, WID_DT_BUOY); if (!can_build) { - CloseWindowById(WindowClass::BuildStation, TRANSPORT_WATER); - CloseWindowById(WindowClass::BuildDepot, TRANSPORT_WATER); + CloseWindowById(WindowClass::BuildStation, TransportType::Water); + CloseWindowById(WindowClass::BuildDepot, TransportType::Water); } if (_game_mode != GameMode::Editor) { @@ -238,7 +238,7 @@ struct BuildDocksToolbarWindow : Window { break; case WID_DT_BUILD_AQUEDUCT: // Build aqueduct button - Command::Post(STR_ERROR_CAN_T_BUILD_AQUEDUCT_HERE, CcBuildBridge, tile, GetOtherAqueductEnd(tile), TRANSPORT_WATER, 0, INVALID_RAILTYPE, INVALID_ROADTYPE); + Command::Post(STR_ERROR_CAN_T_BUILD_AQUEDUCT_HERE, CcBuildBridge, tile, GetOtherAqueductEnd(tile), TransportType::Water, 0, INVALID_RAILTYPE, INVALID_ROADTYPE); break; default: NOT_REACHED(); @@ -284,8 +284,8 @@ struct BuildDocksToolbarWindow : Window { this->RaiseButtons(); - CloseWindowById(WindowClass::BuildStation, TRANSPORT_WATER); - CloseWindowById(WindowClass::BuildDepot, TRANSPORT_WATER); + CloseWindowById(WindowClass::BuildStation, TransportType::Water); + CloseWindowById(WindowClass::BuildDepot, TransportType::Water); CloseWindowById(WindowClass::JoinStation, 0); CloseWindowByClass(WindowClass::BuildBridge); } @@ -377,7 +377,7 @@ Window *ShowBuildDocksToolbar() if (!Company::IsValidID(_local_company)) return nullptr; CloseWindowByClass(WindowClass::BuildToolbar); - return AllocateWindowDescFront(_build_docks_toolbar_desc, TRANSPORT_WATER); + return AllocateWindowDescFront(_build_docks_toolbar_desc, TransportType::Water); } /** @@ -415,14 +415,14 @@ static WindowDesc _build_docks_scen_toolbar_desc( */ Window *ShowBuildDocksScenToolbar() { - return AllocateWindowDescFront(_build_docks_scen_toolbar_desc, TRANSPORT_WATER); + return AllocateWindowDescFront(_build_docks_scen_toolbar_desc, TransportType::Water); } struct BuildDocksStationWindow : public PickerWindowBase { public: BuildDocksStationWindow(WindowDesc &desc, Window *parent) : PickerWindowBase(desc, parent) { - this->InitNested(TRANSPORT_WATER); + this->InitNested(TransportType::Water); this->LowerWidget(_settings_client.gui.station_show_coverage + WID_BDSW_LT_OFF); } @@ -530,7 +530,7 @@ private: public: BuildDocksDepotWindow(WindowDesc &desc, Window *parent) : PickerWindowBase(desc, parent) { - this->InitNested(TRANSPORT_WATER); + this->InitNested(TransportType::Water); this->LowerWidget(WID_BDD_X + _ship_depot_direction); UpdateDocksDirection(); } diff --git a/src/elrail.cpp b/src/elrail.cpp index 573ceff4b6..43ff84e7eb 100644 --- a/src/elrail.cpp +++ b/src/elrail.cpp @@ -98,7 +98,7 @@ static TrackBits GetRailTrackBitsUniversal(TileIndex t, DiagDirections *override break; case TileType::TunnelBridge: - if (GetTunnelBridgeTransportType(t) != TRANSPORT_RAIL) return {}; + if (GetTunnelBridgeTransportType(t) != TransportType::Rail) return {}; if (!HasRailCatenary(GetRailType(t))) return {}; if (override != nullptr && (IsTunnel(t) || GetTunnelBridgeLength(t, GetOtherBridgeEnd(t)) > 0)) { *override = GetTunnelBridgeDirection(t); @@ -142,7 +142,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) || - (!TrackdirBitsToTrackBits(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs).Any(DiagdirReachesTracks(d)) && + (!TrackdirBitsToTrackBits(GetTileTrackStatus(next_tile, TransportType::Rail, RoadTramType::Invalid).trackdirs).Any(DiagdirReachesTracks(d)) && (!HasStationTileRail(next_tile) || GetRailStationAxis(next_tile) != DiagDirToAxis(d) || !CanStationTileHaveWires(next_tile)))) { neighbour_tdb |= DiagdirReachesTrackdirs(ReverseDiagDir(d)); } diff --git a/src/engine.cpp b/src/engine.cpp index a9304fdf14..d5b5e177da 100644 --- a/src/engine.cpp +++ b/src/engine.cpp @@ -872,9 +872,9 @@ static void EnableEngineForCompany(EngineID eid, CompanyID company) /* Update the toolbar. */ InvalidateWindowData(WindowClass::MainToolbar, 0); - if (e->type == VehicleType::Road) InvalidateWindowData(WindowClass::BuildToolbar, TRANSPORT_ROAD); - if (e->type == VehicleType::Ship) InvalidateWindowData(WindowClass::BuildToolbar, TRANSPORT_WATER); - if (e->type == VehicleType::Aircraft) InvalidateWindowData(WindowClass::BuildToolbar, TRANSPORT_AIR); + if (e->type == VehicleType::Road) InvalidateWindowData(WindowClass::BuildToolbar, TransportType::Road); + if (e->type == VehicleType::Ship) InvalidateWindowData(WindowClass::BuildToolbar, TransportType::Water); + if (e->type == VehicleType::Aircraft) InvalidateWindowData(WindowClass::BuildToolbar, TransportType::Air); } } @@ -1155,9 +1155,9 @@ static void NewVehicleAvailable(Engine *e) } /* Update the toolbar. */ - if (e->type == VehicleType::Road) InvalidateWindowData(WindowClass::BuildToolbar, TRANSPORT_ROAD); - if (e->type == VehicleType::Ship) InvalidateWindowData(WindowClass::BuildToolbar, TRANSPORT_WATER); - if (e->type == VehicleType::Aircraft) InvalidateWindowData(WindowClass::BuildToolbar, TRANSPORT_AIR); + if (e->type == VehicleType::Road) InvalidateWindowData(WindowClass::BuildToolbar, TransportType::Road); + if (e->type == VehicleType::Ship) InvalidateWindowData(WindowClass::BuildToolbar, TransportType::Water); + if (e->type == VehicleType::Aircraft) InvalidateWindowData(WindowClass::BuildToolbar, TransportType::Air); /* Remove from preview windows */ InvalidateWindowClassesData(WindowClass::EnginePreview); diff --git a/src/ground_vehicle.cpp b/src/ground_vehicle.cpp index 760aeb85a1..ef9f48a14a 100644 --- a/src/ground_vehicle.cpp +++ b/src/ground_vehicle.cpp @@ -191,8 +191,8 @@ bool GroundVehicle::IsChainInDepot() const { const T *v = this->First(); /* Is the front engine stationary in the depot? */ - static_assert(to_underlying(TRANSPORT_RAIL) == to_underlying(VehicleType::Train)); - static_assert(to_underlying(TRANSPORT_ROAD) == to_underlying(VehicleType::Road)); + static_assert(to_underlying(TransportType::Rail) == to_underlying(VehicleType::Train)); + static_assert(to_underlying(TransportType::Road) == to_underlying(VehicleType::Road)); if (!IsDepotTypeTile(v->tile, (TransportType)Type) || v->cur_speed != 0) return false; /* Check whether the rest is also already trying to enter the depot. */ diff --git a/src/landscape.cpp b/src/landscape.cpp index 60bce0c0ff..478bf6964d 100644 --- a/src/landscape.cpp +++ b/src/landscape.cpp @@ -556,10 +556,10 @@ void DoClearSquare(TileIndex tile) /** * Returns information about trackdirs and signal states. * If there is any trackbit at 'side', return all trackdirbits. - * For TRANSPORT_ROAD, return no trackbits if there is no roadbit (of given subtype) at given side. + * For TransportType::Road, return no trackbits if there is no roadbit (of given subtype) at given side. * @param tile tile to get info about * @param mode transport type - * @param sub_mode for TRANSPORT_ROAD, roadtypes to check + * @param sub_mode for TransportType::Road, roadtypes to check * @param side side we are entering from, DiagDirection::Invalid to return all trackbits * @return trackdirbits and other info depending on 'mode' */ diff --git a/src/newgrf_railtype.cpp b/src/newgrf_railtype.cpp index 0ca3dfddad..58747c4edc 100644 --- a/src/newgrf_railtype.cpp +++ b/src/newgrf_railtype.cpp @@ -229,7 +229,7 @@ void ConvertRailTypes() break; case TileType::TunnelBridge: - if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) { + if (GetTunnelBridgeTransportType(t) == TransportType::Rail) { SetRailType(t, railtype_conversion_map[GetRailType(t)]); } break; diff --git a/src/newgrf_roadtype.cpp b/src/newgrf_roadtype.cpp index aefe053969..d6612a1aab 100644 --- a/src/newgrf_roadtype.cpp +++ b/src/newgrf_roadtype.cpp @@ -257,7 +257,7 @@ void ConvertRoadTypes() break; case TileType::TunnelBridge: - if (GetTunnelBridgeTransportType(t) == TRANSPORT_ROAD) { + if (GetTunnelBridgeTransportType(t) == TransportType::Road) { if (RoadType rt = GetRoadTypeRoad(t); rt != INVALID_ROADTYPE) SetRoadTypeRoad(t, roadtype_conversion_map[rt]); if (RoadType rt = GetRoadTypeTram(t); rt != INVALID_ROADTYPE) SetRoadTypeTram(t, roadtype_conversion_map[rt]); } diff --git a/src/newgrf_station.cpp b/src/newgrf_station.cpp index ccebb19e53..f782335af6 100644 --- a/src/newgrf_station.cpp +++ b/src/newgrf_station.cpp @@ -221,7 +221,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 = TrackdirBitsToTrackBits(GetTileTrackStatus(neighbour_tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs); + TrackBits trackbits = TrackdirBitsToTrackBits(GetTileTrackStatus(neighbour_tile, TransportType::Rail, RoadTramType::Invalid).trackdirs); if (trackbits.Any()) { /* 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 1852a6ff15..71bf484c64 100644 --- a/src/pathfinder/follow_track.hpp +++ b/src/pathfinder/follow_track.hpp @@ -89,10 +89,10 @@ struct CFollowTrackT { } [[debug_inline]] inline static TransportType TT() { return Ttr_type_; } - [[debug_inline]] inline static bool IsWaterTT() { return TT() == TRANSPORT_WATER; } - [[debug_inline]] inline static bool IsRailTT() { return TT() == TRANSPORT_RAIL; } + [[debug_inline]] inline static bool IsWaterTT() { return TT() == TransportType::Water; } + [[debug_inline]] inline static bool IsRailTT() { return TT() == TransportType::Rail; } inline bool IsTram() { return IsRoadTT() && RoadTypeIsTram(RoadVehicle::From(this->veh)->roadtype); } - [[debug_inline]] inline static bool IsRoadTT() { return TT() == TRANSPORT_ROAD; } + [[debug_inline]] inline static bool IsRoadTT() { return TT() == TransportType::Road; } static inline bool Allow90degTurns() { return T90deg_turns_allowed_; } static inline bool DoTrackMasking() { return Tmask_reserved_tracks; } @@ -501,13 +501,13 @@ public: } }; -typedef CFollowTrackT CFollowTrackWater; -typedef CFollowTrackT CFollowTrackRoad; -typedef CFollowTrackT CFollowTrackRail; +typedef CFollowTrackT CFollowTrackWater; +typedef CFollowTrackT CFollowTrackRoad; +typedef CFollowTrackT CFollowTrackRail; -typedef CFollowTrackT CFollowTrackRailNo90; +typedef CFollowTrackT CFollowTrackRailNo90; -typedef CFollowTrackT CFollowTrackFreeRail; -typedef CFollowTrackT CFollowTrackFreeRailNo90; +typedef CFollowTrackT CFollowTrackFreeRail; +typedef CFollowTrackT CFollowTrackFreeRailNo90; #endif /* FOLLOW_TRACK_HPP */ diff --git a/src/pathfinder/pathfinder_func.h b/src/pathfinder/pathfinder_func.h index 55f1e59d58..22f4bd1dc2 100644 --- a/src/pathfinder/pathfinder_func.h +++ b/src/pathfinder/pathfinder_func.h @@ -61,7 +61,7 @@ inline TileIndex CalcClosestStationTile(StationID station, TileIndex tile, Stati */ inline TrackdirBits GetTrackdirBitsForRoad(TileIndex tile, RoadTramType rtt) { - TrackdirBits bits = GetTileTrackStatus(tile, TRANSPORT_ROAD, rtt).trackdirs; + TrackdirBits bits = GetTileTrackStatus(tile, TransportType::Road, rtt).trackdirs; if (rtt == RoadTramType::Tram && bits.None()) { if (IsNormalRoadTile(tile)) { diff --git a/src/pathfinder/water_regions.cpp b/src/pathfinder/water_regions.cpp index d7667a2006..5f0417c6f5 100644 --- a/src/pathfinder/water_regions.cpp +++ b/src/pathfinder/water_regions.cpp @@ -28,8 +28,8 @@ 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 TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid).trackdirs); } -static inline bool IsAqueductTile(TileIndex tile) { return IsBridgeTile(tile) && GetTunnelBridgeTransportType(tile) == TRANSPORT_WATER; } +static inline TrackBits GetWaterTracks(TileIndex tile) { return TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TransportType::Water, RoadTramType::Invalid).trackdirs); } +static inline bool IsAqueductTile(TileIndex tile) { return IsBridgeTile(tile) && GetTunnelBridgeTransportType(tile) == TransportType::Water; } static inline int GetWaterRegionX(TileIndex tile) { return TileX(tile) / WATER_REGION_EDGE_LENGTH; } static inline int GetWaterRegionY(TileIndex tile) { return TileY(tile) / WATER_REGION_EDGE_LENGTH; } diff --git a/src/pathfinder/yapf/yapf_destrail.hpp b/src/pathfinder/yapf/yapf_destrail.hpp index 89be57c401..6efe09609f 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 = GetTileTrackStatus(this->dest_tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs; + this->dest_trackdirs = GetTileTrackStatus(this->dest_tile, TransportType::Rail, RoadTramType::Invalid).trackdirs; break; } this->CYapfDestinationRailBase::SetDestination(v); diff --git a/src/pathfinder/yapf/yapf_road.cpp b/src/pathfinder/yapf/yapf_road.cpp index efba10af20..c8e1432f3a 100644 --- a/src/pathfinder/yapf/yapf_road.cpp +++ b/src/pathfinder/yapf/yapf_road.cpp @@ -251,7 +251,7 @@ public: } else { this->dest_station = StationID::Invalid(); this->dest_tile = v->dest_tile == INVALID_TILE ? TileIndex{} : v->dest_tile; - this->dest_trackdirs = GetTileTrackStatus(this->dest_tile, TRANSPORT_ROAD, GetRoadTramType(v->roadtype)).trackdirs; + this->dest_trackdirs = GetTileTrackStatus(this->dest_tile, TransportType::Road, GetRoadTramType(v->roadtype)).trackdirs; } } diff --git a/src/pathfinder/yapf/yapf_ship.cpp b/src/pathfinder/yapf/yapf_ship.cpp index bb3d1b6e83..e54b419d7f 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 = GetTileTrackStatus(this->dest_tile, TRANSPORT_WATER, RoadTramType::Invalid).trackdirs; + this->dest_trackdirs = GetTileTrackStatus(this->dest_tile, TransportType::Water, RoadTramType::Invalid).trackdirs; } } @@ -312,7 +312,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) & GetTileTrackStatus(v->tile, TRANSPORT_WATER, RoadTramType::Invalid, entry).trackdirs; + const TrackdirBits reverse_dirs = DiagdirReachesTrackdirs(entry) & GetTileTrackStatus(v->tile, TransportType::Water, RoadTramType::Invalid, entry).trackdirs; (void)ChooseShipTrack(v, v->tile, {}, reverse_dirs, path_found, dummy_cache, best_origin_dir); *trackdir = path_found && best_origin_dir != Trackdir::Invalid ? best_origin_dir : GetRandomTrackdir(reverse_dirs); return true; diff --git a/src/pbs.cpp b/src/pbs.cpp index 74aeb0c388..39721871fe 100644 --- a/src/pbs.cpp +++ b/src/pbs.cpp @@ -38,7 +38,7 @@ TrackBits GetReservedTrackbits(TileIndex t) break; case TileType::TunnelBridge: - if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) return GetTunnelBridgeReservationTrackBits(t); + if (GetTunnelBridgeTransportType(t) == TransportType::Rail) return GetTunnelBridgeReservationTrackBits(t); break; default: @@ -79,7 +79,7 @@ void SetRailStationPlatformReservation(TileIndex start, DiagDirection dir, bool */ bool TryReserveRailTrack(TileIndex tile, Track t, bool trigger_stations) { - assert(TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs).Test(t)); + assert(TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TransportType::Rail, RoadTramType::Invalid).trackdirs).Test(t)); if (_settings_client.gui.show_track_reservation) { /* show the reserved rail if needed */ @@ -124,7 +124,7 @@ bool TryReserveRailTrack(TileIndex tile, Track t, bool trigger_stations) break; case TileType::TunnelBridge: - if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL && GetTunnelBridgeReservationTrackBits(tile).None()) { + if (GetTunnelBridgeTransportType(tile) == TransportType::Rail && GetTunnelBridgeReservationTrackBits(tile).None()) { SetTunnelBridgeReservation(tile, true); return true; } @@ -143,7 +143,7 @@ bool TryReserveRailTrack(TileIndex tile, Track t, bool trigger_stations) */ void UnreserveRailTrack(TileIndex tile, Track t) { - assert(TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs).Test(t)); + assert(TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TransportType::Rail, RoadTramType::Invalid).trackdirs).Test(t)); if (_settings_client.gui.show_track_reservation) { if (IsBridgeTile(tile)) { @@ -178,7 +178,7 @@ void UnreserveRailTrack(TileIndex tile, Track t) break; case TileType::TunnelBridge: - if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL) SetTunnelBridgeReservation(tile, false); + if (GetTunnelBridgeTransportType(tile) == TransportType::Rail) SetTunnelBridgeReservation(tile, false); break; default: diff --git a/src/picker_gui.cpp b/src/picker_gui.cpp index 62eca62dc1..bd4f91892c 100644 --- a/src/picker_gui.cpp +++ b/src/picker_gui.cpp @@ -195,7 +195,7 @@ static const std::initializer_list _type static const std::initializer_list _collection_sorter_funcs = { &CollectionIDSorter }; ///< Sort functions of the #PickerCollectionList. -PickerWindow::PickerWindow(WindowDesc &desc, Window *parent, int window_number, PickerCallbacks &callbacks) : PickerWindowBase(desc, parent), callbacks(callbacks), +PickerWindow::PickerWindow(WindowDesc &desc, Window *parent, WindowNumber window_number, PickerCallbacks &callbacks) : PickerWindowBase(desc, parent), callbacks(callbacks), class_editbox(EDITBOX_MAX_SIZE * MAX_CHAR_LENGTH, EDITBOX_MAX_SIZE), type_editbox(EDITBOX_MAX_SIZE * MAX_CHAR_LENGTH, EDITBOX_MAX_SIZE) { diff --git a/src/picker_gui.h b/src/picker_gui.h index aa962c510f..2cf1b3636b 100644 --- a/src/picker_gui.h +++ b/src/picker_gui.h @@ -352,7 +352,7 @@ public: int preview_height = 0; ///< Height of preview images. std::set inactive; ///< Set of collections with inactive items. - PickerWindow(WindowDesc &desc, Window *parent, int window_number, PickerCallbacks &callbacks); + PickerWindow(WindowDesc &desc, Window *parent, WindowNumber window_number, PickerCallbacks &callbacks); void OnInit() override; void Close(int data = 0) override; void UpdateWidgetSize(WidgetID widget, Dimension &size, const Dimension &padding, Dimension &fill, Dimension &resize) override; diff --git a/src/rail.cpp b/src/rail.cpp index beaa6d0075..cb00a293cd 100644 --- a/src/rail.cpp +++ b/src/rail.cpp @@ -52,7 +52,7 @@ RailType GetTileRailType(Tile tile) break; case TileType::TunnelBridge: - if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL) return GetRailType(tile); + if (GetTunnelBridgeTransportType(tile) == TransportType::Rail) return GetRailType(tile); break; default: diff --git a/src/rail_cmd.cpp b/src/rail_cmd.cpp index c4546c7d63..535d2e59ee 100644 --- a/src/rail_cmd.cpp +++ b/src/rail_cmd.cpp @@ -1209,7 +1209,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 = GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs; + TrackdirBits trackdirbits = GetTileTrackStatus(tile, TransportType::Rail, RoadTramType::Invalid).trackdirs; if (TracksOverlap(TrackdirBitsToTrackBits(trackdirbits))) return false; trackdirbits &= TrackdirReachesTrackdirs(trackdir); @@ -1234,7 +1234,7 @@ static bool AdvanceSignalAutoFill(TileIndex &tile, Trackdir &trackdir, bool remo break; case TileType::TunnelBridge: { - if (GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) return false; + if (GetTunnelBridgeTransportType(tile) != TransportType::Rail) return false; if (GetTunnelBridgeDirection(tile) != TrackdirToExitdir(trackdir)) return false; break; } @@ -1575,7 +1575,7 @@ CommandCost CmdConvertRail(DoCommandFlags flags, TileIndex tile, TileIndex area_ } break; case TileType::TunnelBridge: - if (GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) continue; + if (GetTunnelBridgeTransportType(tile) != TransportType::Rail) continue; break; default: continue; } @@ -2772,7 +2772,7 @@ set_ground: 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))) { + if (mode == TransportType::Water && IsPlainRail(tile) && GetRailGroundType(tile) == RailGroundType::HalfTileWater && IsSlopeWithOneCornerRaised(GetTileSlope(tile))) { TrackBits tb = GetTrackBits(tile); switch (tb.base()) { default: NOT_REACHED(); @@ -2784,7 +2784,7 @@ static TrackStatus GetTileTrackStatus_Rail(TileIndex tile, TransportType mode, [ return {TrackBitsToTrackdirBits(tb), {}}; } - if (mode != TRANSPORT_RAIL) return {}; + if (mode != TransportType::Rail) return {}; TrackBits trackbits{}; TrackdirBits red_signals{}; diff --git a/src/rail_gui.cpp b/src/rail_gui.cpp index b47cdf6a5d..e8045a32f5 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 = TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs); + TrackBits trackbits = TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TransportType::Rail, RoadTramType::Invalid).trackdirs); if (trackbits.Any(TRACK_BIT_VERT)) { // N-S direction trackbits = (_tile_fract_coords.x <= _tile_fract_coords.y) ? Track::Right : Track::Left; @@ -448,7 +448,7 @@ struct BuildRailToolbarWindow : Window { BuildRailToolbarWindow(WindowDesc &desc, RailType railtype) : Window(desc), railtype(railtype) { this->CreateNestedTree(); - this->FinishInitNested(TRANSPORT_RAIL); + this->FinishInitNested(TransportType::Rail); this->DisableWidget(WID_RAT_REMOVE); this->OnInvalidateData(); @@ -484,10 +484,10 @@ struct BuildRailToolbarWindow : Window { bool can_build = CanBuildVehicleInfrastructure(VehicleType::Train); for (const WidgetID widget : can_build_widgets) this->SetWidgetDisabledState(widget, !can_build); if (!can_build) { - CloseWindowById(WindowClass::BuildSignal, TRANSPORT_RAIL); - CloseWindowById(WindowClass::BuildStation, TRANSPORT_RAIL); - CloseWindowById(WindowClass::BuildDepot, TRANSPORT_RAIL); - CloseWindowById(WindowClass::BuildWaypoint, TRANSPORT_RAIL); + CloseWindowById(WindowClass::BuildSignal, TransportType::Rail); + CloseWindowById(WindowClass::BuildStation, TransportType::Rail); + CloseWindowById(WindowClass::BuildDepot, TransportType::Rail); + CloseWindowById(WindowClass::BuildWaypoint, TransportType::Rail); CloseWindowById(WindowClass::JoinStation, 0); } } @@ -722,7 +722,7 @@ struct BuildRailToolbarWindow : Window { break; case WID_RAT_BUILD_TUNNEL: - Command::Post(STR_ERROR_CAN_T_BUILD_TUNNEL_HERE, CcBuildRailTunnel, tile, TRANSPORT_RAIL, _cur_railtype, INVALID_ROADTYPE); + Command::Post(STR_ERROR_CAN_T_BUILD_TUNNEL_HERE, CcBuildRailTunnel, tile, TransportType::Rail, _cur_railtype, INVALID_ROADTYPE); break; case WID_RAT_CONVERT_RAIL: @@ -753,7 +753,7 @@ struct BuildRailToolbarWindow : Window { default: NOT_REACHED(); case DDSP_BUILD_BRIDGE: if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace(); - ShowBuildBridgeWindow(start_tile, end_tile, TRANSPORT_RAIL, _cur_railtype, INVALID_ROADTYPE); + ShowBuildBridgeWindow(start_tile, end_tile, TransportType::Rail, _cur_railtype, INVALID_ROADTYPE); break; case DDSP_PLACE_RAIL: @@ -817,17 +817,17 @@ struct BuildRailToolbarWindow : Window { this->DisableWidget(WID_RAT_REMOVE); this->SetWidgetDirty(WID_RAT_REMOVE); - CloseWindowById(WindowClass::BuildSignal, TRANSPORT_RAIL); - CloseWindowById(WindowClass::BuildStation, TRANSPORT_RAIL); - CloseWindowById(WindowClass::BuildDepot, TRANSPORT_RAIL); - CloseWindowById(WindowClass::BuildWaypoint, TRANSPORT_RAIL); + CloseWindowById(WindowClass::BuildSignal, TransportType::Rail); + CloseWindowById(WindowClass::BuildStation, TransportType::Rail); + CloseWindowById(WindowClass::BuildDepot, TransportType::Rail); + CloseWindowById(WindowClass::BuildWaypoint, TransportType::Rail); CloseWindowById(WindowClass::JoinStation, 0); CloseWindowByClass(WindowClass::BuildBridge); } void OnPlacePresize([[maybe_unused]] Point pt, TileIndex tile) override { - Command::Do(DoCommandFlag::Auto, tile, TRANSPORT_RAIL, _cur_railtype, INVALID_ROADTYPE); + Command::Do(DoCommandFlag::Auto, tile, TransportType::Rail, _cur_railtype, INVALID_ROADTYPE); VpSetPresizeRange(tile, _build_tunnel_endtile == INVALID_TILE ? tile : _build_tunnel_endtile); } @@ -861,7 +861,7 @@ struct BuildRailToolbarWindow : Window { /* Update cursor and all sub windows. */ if (_thd.GetCallbackWnd() == this) SetCursor(this->GetCursorForWidget(this->last_user_action), PAL_NONE); - for (WindowClass cls : {WindowClass::BuildStation, WindowClass::BuildSignal, WindowClass::BuildWaypoint, WindowClass::BuildDepot}) SetWindowDirty(cls, TRANSPORT_RAIL); + for (WindowClass cls : {WindowClass::BuildStation, WindowClass::BuildSignal, WindowClass::BuildWaypoint, WindowClass::BuildDepot}) SetWindowDirty(cls, TransportType::Rail); return EventState::Handled; } @@ -1152,7 +1152,7 @@ private: } public: - BuildRailStationWindow(WindowDesc &desc, Window *parent) : PickerWindow(desc, parent, TRANSPORT_RAIL, StationPickerCallbacks::instance) + BuildRailStationWindow(WindowDesc &desc, Window *parent) : PickerWindow(desc, parent, TransportType::Rail, StationPickerCallbacks::instance) { this->coverage_height = 2 * GetCharacterHeight(FontSize::Normal) + WidgetDimensions::scaled.vsep_normal; this->ConstructWindow(); @@ -1432,7 +1432,7 @@ public: static EventState BuildRailStationGlobalHotkeys(int hotkey) { if (_game_mode == GameMode::Menu) return EventState::NotHandled; - Window *w = ShowStationBuilder(FindWindowById(WindowClass::BuildToolbar, TRANSPORT_RAIL)); + Window *w = ShowStationBuilder(FindWindowById(WindowClass::BuildToolbar, TransportType::Rail)); if (w == nullptr) return EventState::NotHandled; return w->OnHotkey(hotkey); } @@ -1550,7 +1550,7 @@ public: { this->CreateNestedTree(); this->SetSignalUIMode(); - this->FinishInitNested(TRANSPORT_RAIL); + this->FinishInitNested(TransportType::Rail); this->OnInvalidateData(); } @@ -1639,7 +1639,7 @@ public: /* If 'remove' button of rail build toolbar is active, disable it. */ if (_remove_button_clicked) { - Window *w = FindWindowById(WindowClass::BuildToolbar, TRANSPORT_RAIL); + Window *w = FindWindowById(WindowClass::BuildToolbar, TransportType::Rail); if (w != nullptr) ToggleRailButton_Remove(w); } @@ -1771,7 +1771,7 @@ static void ShowSignalBuilder(Window *parent) struct BuildRailDepotWindow : public PickerWindowBase { BuildRailDepotWindow(WindowDesc &desc, Window *parent) : PickerWindowBase(desc, parent) { - this->InitNested(TRANSPORT_RAIL); + this->InitNested(TransportType::Rail); this->LowerWidget(WID_BRAD_DEPOT_NE + _build_depot_direction); } @@ -1931,7 +1931,7 @@ public: /* static */ WaypointPickerCallbacks WaypointPickerCallbacks::instance; struct BuildRailWaypointWindow : public PickerWindow { - BuildRailWaypointWindow(WindowDesc &desc, Window *parent) : PickerWindow(desc, parent, TRANSPORT_RAIL, WaypointPickerCallbacks::instance) + BuildRailWaypointWindow(WindowDesc &desc, Window *parent) : PickerWindow(desc, parent, TransportType::Rail, WaypointPickerCallbacks::instance) { this->ConstructWindow(); } @@ -1990,7 +1990,7 @@ void ReinitGuiAfterToggleElrail(bool disable) { if (disable && _last_built_railtype == RAILTYPE_ELECTRIC) { _last_built_railtype = _cur_railtype = RAILTYPE_RAIL; - BuildRailToolbarWindow *w = dynamic_cast(FindWindowById(WindowClass::BuildToolbar, TRANSPORT_RAIL)); + BuildRailToolbarWindow *w = dynamic_cast(FindWindowById(WindowClass::BuildToolbar, TransportType::Rail)); if (w != nullptr) w->ModifyRailType(_cur_railtype); } MarkWholeScreenDirty(); diff --git a/src/road_cmd.cpp b/src/road_cmd.cpp index 9f70e3dfb8..5574ef111a 100644 --- a/src/road_cmd.cpp +++ b/src/road_cmd.cpp @@ -339,7 +339,7 @@ static CommandCost RemoveRoad(TileIndex tile, DoCommandFlags flags, RoadBits pie } case TileType::TunnelBridge: { - if (GetTunnelBridgeTransportType(tile) != TRANSPORT_ROAD) return CMD_ERROR; + if (GetTunnelBridgeTransportType(tile) != TransportType::Road) return CMD_ERROR; CommandCost ret = TunnelBridgeIsFree(tile, GetOtherTunnelBridgeEnd(tile)); if (ret.Failed()) return ret; break; @@ -790,7 +790,7 @@ CommandCost CmdBuildRoad(DoCommandFlags flags, TileIndex tile, RoadBits pieces, } case TileType::TunnelBridge: { - if (GetTunnelBridgeTransportType(tile) != TRANSPORT_ROAD) goto do_clear; + if (GetTunnelBridgeTransportType(tile) != TransportType::Road) goto do_clear; /* Only allow building the outer roadbit, so building long roads stops at existing bridges */ if (MirrorRoadBits(DiagDirToRoadBits(GetTunnelBridgeDirection(tile))) != pieces) goto do_clear; if (HasTileRoadType(tile, rtt)) return CommandCost(STR_ERROR_ALREADY_BUILT); @@ -2144,11 +2144,11 @@ static TrackStatus GetTileTrackStatus_Road(TileIndex tile, TransportType mode, R TrackdirBits trackdirbits{}; TrackdirBits red_signals{}; // crossing barred switch (mode) { - case TRANSPORT_RAIL: + case TransportType::Rail: if (IsLevelCrossing(tile)) trackdirbits = TrackBitsToTrackdirBits(GetCrossingRailTrack(tile)); break; - case TRANSPORT_ROAD: { + case TransportType::Road: { RoadTramType rtt = (RoadTramType)sub_mode; if (!HasTileRoadType(tile, rtt)) break; switch (GetRoadTileType(tile)) { @@ -2503,7 +2503,7 @@ CommandCost CmdConvertRoad(DoCommandFlags flags, TileIndex tile, TileIndex area_ } break; case TileType::TunnelBridge: - if (GetTunnelBridgeTransportType(tile) != TRANSPORT_ROAD) continue; + if (GetTunnelBridgeTransportType(tile) != TransportType::Road) continue; break; default: continue; } diff --git a/src/road_gui.cpp b/src/road_gui.cpp index 00a20493aa..c6e715343e 100644 --- a/src/road_gui.cpp +++ b/src/road_gui.cpp @@ -396,10 +396,10 @@ struct BuildRoadToolbarWindow : Window { WID_ROT_BUS_STATION, WID_ROT_TRUCK_STATION); if (!can_build) { - CloseWindowById(WindowClass::BuildBusStation, TRANSPORT_ROAD); - CloseWindowById(WindowClass::BuildTruckStation, TRANSPORT_ROAD); - CloseWindowById(WindowClass::BuildDepot, TRANSPORT_ROAD); - CloseWindowById(WindowClass::BuildWaypoint, TRANSPORT_ROAD); + CloseWindowById(WindowClass::BuildBusStation, TransportType::Road); + CloseWindowById(WindowClass::BuildTruckStation, TransportType::Road); + CloseWindowById(WindowClass::BuildDepot, TransportType::Road); + CloseWindowById(WindowClass::BuildWaypoint, TransportType::Road); } if (_game_mode != GameMode::Editor) { @@ -634,7 +634,7 @@ struct BuildRoadToolbarWindow : Window { this->ModifyRoadType(_cur_roadtype); if (_thd.GetCallbackWnd() == this) SetCursor(this->GetCursorForWidget(this->last_started_action), PAL_NONE); - for (WindowClass cls : {WindowClass::BuildBusStation, WindowClass::BuildTruckStation, WindowClass::BuildWaypoint, WindowClass::BuildDepot}) SetWindowDirty(cls, TRANSPORT_ROAD); + for (WindowClass cls : {WindowClass::BuildBusStation, WindowClass::BuildTruckStation, WindowClass::BuildWaypoint, WindowClass::BuildDepot}) SetWindowDirty(cls, TransportType::Road); return EventState::Handled; } @@ -697,7 +697,7 @@ struct BuildRoadToolbarWindow : Window { case WID_ROT_BUILD_TUNNEL: Command::Post(STR_ERROR_CAN_T_BUILD_TUNNEL_HERE, CcBuildRoadTunnel, - tile, TRANSPORT_ROAD, INVALID_RAILTYPE, _cur_roadtype); + tile, TransportType::Road, INVALID_RAILTYPE, _cur_roadtype); break; case WID_ROT_CONVERT_ROAD: @@ -721,10 +721,10 @@ struct BuildRoadToolbarWindow : Window { this->SetWidgetDirty(WID_ROT_ONE_WAY); } - CloseWindowById(WindowClass::BuildBusStation, TRANSPORT_ROAD); - CloseWindowById(WindowClass::BuildTruckStation, TRANSPORT_ROAD); - CloseWindowById(WindowClass::BuildDepot, TRANSPORT_ROAD); - CloseWindowById(WindowClass::BuildWaypoint, TRANSPORT_ROAD); + CloseWindowById(WindowClass::BuildBusStation, TransportType::Road); + CloseWindowById(WindowClass::BuildTruckStation, TransportType::Road); + CloseWindowById(WindowClass::BuildDepot, TransportType::Road); + CloseWindowById(WindowClass::BuildWaypoint, TransportType::Road); CloseWindowById(WindowClass::JoinStation, 0); CloseWindowByClass(WindowClass::BuildBridge); } @@ -780,7 +780,7 @@ struct BuildRoadToolbarWindow : Window { default: NOT_REACHED(); case DDSP_BUILD_BRIDGE: if (!_settings_client.gui.persistent_buildingtools) ResetObjectToPlace(); - ShowBuildBridgeWindow(start_tile, end_tile, TRANSPORT_ROAD, INVALID_RAILTYPE, _cur_roadtype); + ShowBuildBridgeWindow(start_tile, end_tile, TransportType::Road, INVALID_RAILTYPE, _cur_roadtype); break; case DDSP_DEMOLISH_AREA: @@ -862,7 +862,7 @@ struct BuildRoadToolbarWindow : Window { void OnPlacePresize([[maybe_unused]] Point pt, TileIndex tile) override { - Command::Do(DoCommandFlag::Auto, tile, TRANSPORT_ROAD, INVALID_RAILTYPE, _cur_roadtype); + Command::Do(DoCommandFlag::Auto, tile, TransportType::Road, INVALID_RAILTYPE, _cur_roadtype); VpSetPresizeRange(tile, _build_tunnel_endtile == INVALID_TILE ? tile : _build_tunnel_endtile); } @@ -1065,7 +1065,7 @@ Window *ShowBuildRoadToolbar(RoadType roadtype) CloseWindowByClass(WindowClass::BuildToolbar); _cur_roadtype = roadtype; - return AllocateWindowDescFront(RoadTypeIsRoad(_cur_roadtype) ? _build_road_desc : _build_tramway_desc, TRANSPORT_ROAD); + return AllocateWindowDescFront(RoadTypeIsRoad(_cur_roadtype) ? _build_road_desc : _build_tramway_desc, TransportType::Road); } static constexpr std::initializer_list _nested_build_road_scen_widgets = { @@ -1153,10 +1153,10 @@ static WindowDesc _build_tramway_scen_desc( */ Window *ShowBuildRoadScenToolbar(RoadType roadtype) { - CloseWindowById(WindowClass::ScenarioBuildToolbar, TRANSPORT_ROAD); + CloseWindowById(WindowClass::ScenarioBuildToolbar, TransportType::Road); _cur_roadtype = roadtype; - return AllocateWindowDescFront(RoadTypeIsRoad(_cur_roadtype) ? _build_road_scen_desc : _build_tramway_scen_desc, TRANSPORT_ROAD); + return AllocateWindowDescFront(RoadTypeIsRoad(_cur_roadtype) ? _build_road_scen_desc : _build_tramway_scen_desc, TransportType::Road); } struct BuildRoadDepotWindow : public PickerWindowBase { @@ -1172,7 +1172,7 @@ struct BuildRoadDepotWindow : public PickerWindowBase { } } - this->FinishInitNested(TRANSPORT_ROAD); + this->FinishInitNested(TransportType::Road); } void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override @@ -1390,7 +1390,7 @@ private: } public: - BuildRoadStationWindow(WindowDesc &desc, Window *parent, RoadStopType rs) : PickerWindow(desc, parent, TRANSPORT_ROAD, GetRoadStopPickerCallbacks(rs)) + BuildRoadStationWindow(WindowDesc &desc, Window *parent, RoadStopType rs) : PickerWindow(desc, parent, TransportType::Road, GetRoadStopPickerCallbacks(rs)) { this->coverage_height = 2 * GetCharacterHeight(FontSize::Normal) + WidgetDimensions::scaled.vsep_normal; @@ -1774,7 +1774,7 @@ public: /* static */ RoadWaypointPickerCallbacks RoadWaypointPickerCallbacks::instance; struct BuildRoadWaypointWindow : public PickerWindow { - BuildRoadWaypointWindow(WindowDesc &desc, Window *parent) : PickerWindow(desc, parent, TRANSPORT_ROAD, RoadWaypointPickerCallbacks::instance) + BuildRoadWaypointWindow(WindowDesc &desc, Window *parent) : PickerWindow(desc, parent, TransportType::Road, RoadWaypointPickerCallbacks::instance) { this->ConstructWindow(); } diff --git a/src/road_map.cpp b/src/road_map.cpp index e680d99a46..cc20148e89 100644 --- a/src/road_map.cpp +++ b/src/road_map.cpp @@ -28,7 +28,7 @@ bool MayHaveRoad(Tile t) return IsAnyRoadStop(t); case TileType::TunnelBridge: - return GetTunnelBridgeTransportType(t) == TRANSPORT_ROAD; + return GetTunnelBridgeTransportType(t) == TransportType::Road; default: return false; @@ -70,7 +70,7 @@ RoadBits GetAnyRoadBits(Tile tile, RoadTramType rtt, bool straight_tunnel_bridge return DiagDirToRoadBits(GetBayRoadStopDir(tile)); case TileType::TunnelBridge: - assert(GetTunnelBridgeTransportType(tile) == TRANSPORT_ROAD); // ensured by MayHaveRoad + assert(GetTunnelBridgeTransportType(tile) == TransportType::Road); // ensured by MayHaveRoad return straight_tunnel_bridge_entrance ? AxisToRoadBits(DiagDirToAxis(GetTunnelBridgeDirection(tile))) : DiagDirToRoadBits(ReverseDiagDir(GetTunnelBridgeDirection(tile))); diff --git a/src/roadveh.h b/src/roadveh.h index fc188f8d06..86416e2e00 100644 --- a/src/roadveh.h +++ b/src/roadveh.h @@ -287,7 +287,7 @@ protected: // These functions should not be called outside acceleration code. */ inline bool TileMayHaveSlopedTrack() const { - TrackStatus ts = GetTileTrackStatus(this->tile, TRANSPORT_ROAD, GetRoadTramType(this->roadtype)); + TrackStatus ts = GetTileTrackStatus(this->tile, TransportType::Road, GetRoadTramType(this->roadtype)); TrackBits trackbits = TrackdirBitsToTrackBits(ts.trackdirs); return trackbits == Track::X || trackbits == Track::Y; diff --git a/src/roadveh_cmd.cpp b/src/roadveh_cmd.cpp index 8b26c19896..c43ae5f50e 100644 --- a/src/roadveh_cmd.cpp +++ b/src/roadveh_cmd.cpp @@ -792,7 +792,7 @@ struct OvertakeData { static bool CheckRoadBlockedForOvertaking(OvertakeData *od) { if (!HasTileAnyRoadType(od->tile, od->v->compatible_roadtypes)) return true; - TrackStatus ts = GetTileTrackStatus(od->tile, TRANSPORT_ROAD, GetRoadTramType(od->v->roadtype)); + TrackStatus ts = GetTileTrackStatus(od->tile, TransportType::Road, GetRoadTramType(od->v->roadtype)); TrackBits trackbits = TrackdirBitsToTrackBits(ts.trackdirs); /* Track does not continue along overtaking direction || track has junction || levelcrossing is barred */ @@ -880,7 +880,7 @@ static Trackdir RoadFindPathToDest(RoadVehicle *v, TileIndex tile, DiagDirection { bool path_found = true; - TrackStatus ts = GetTileTrackStatus(tile, TRANSPORT_ROAD, GetRoadTramType(v->roadtype)); + TrackStatus ts = GetTileTrackStatus(tile, TransportType::Road, GetRoadTramType(v->roadtype)); /* Replaces the given trackdir with Trackdir::Invalid when there is red signal for that trackdir. */ auto FilterRedSignal = [&ts](Trackdir trackdir) { diff --git a/src/saveload/afterload.cpp b/src/saveload/afterload.cpp index 2798e72119..4633fba867 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 : EnumRange(DiagDirection::End)) { TileIndex tt{t + TileOffsByDiagDir(dd)}; - if (GetTileTrackStatus(t, TRANSPORT_RAIL, RoadTramType::Invalid, dd).trackdirs.Any() && - GetTileTrackStatus(tt, TRANSPORT_RAIL, RoadTramType::Invalid, ReverseDiagDir(dd)).trackdirs.Any() && + if (GetTileTrackStatus(t, TransportType::Rail, RoadTramType::Invalid, dd).trackdirs.Any() && + GetTileTrackStatus(tt, TransportType::Rail, RoadTramType::Invalid, ReverseDiagDir(dd)).trackdirs.Any() && Company::IsValidID(GetTileOwner(tt))) { SetTileOwner(t, GetTileOwner(tt)); return; @@ -1114,7 +1114,7 @@ bool AfterLoadGame() case TileType::TunnelBridge: /* Middle part of "old" bridges */ if (old_bridge && IsBridge(t) && HasBit(t.m5(), 6)) break; - if (((old_bridge && IsBridge(t)) ? (TransportType)GB(t.m5(), 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) { + if (((old_bridge && IsBridge(t)) ? (TransportType)GB(t.m5(), 1, 2) : GetTunnelBridgeTransportType(t)) == TransportType::Road) { SB(t.m7(), 6, 2, 1); // Set pre-NRT road type bits for conversion later. } break; @@ -1172,7 +1172,7 @@ bool AfterLoadGame() case TileType::TunnelBridge: if (old_bridge && IsBridge(t) && HasBit(t.m5(), 6)) break; - if (((old_bridge && IsBridge(t)) ? (TransportType)GB(t.m5(), 1, 2) : GetTunnelBridgeTransportType(t)) == TRANSPORT_ROAD) { + if (((old_bridge && IsBridge(t)) ? (TransportType)GB(t.m5(), 1, 2) : GetTunnelBridgeTransportType(t)) == TransportType::Road) { if (fix_roadtypes) SB(t.m7(), 6, 2, GB(t.m3(), 0, 3)); Owner o = GetTileOwner(t); @@ -1212,7 +1212,7 @@ bool AfterLoadGame() break; case TileType::TunnelBridge: - if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) { + if (GetTunnelBridgeTransportType(t) == TransportType::Rail) { SetRailType(t, (RailType)GB(t.m3(), 0, 4)); } break; @@ -1231,7 +1231,7 @@ bool AfterLoadGame() Axis axis = static_cast(GB(t.m5(), 0, 1)); if (HasBit(t.m5(), 5)) { // transport route under bridge? - if (GB(t.m5(), 3, 2) == TRANSPORT_RAIL) { + if (static_cast(GB(t.m5(), 3, 2)) == TransportType::Rail) { MakeRailNormal( t, GetTileOwner(t), @@ -1270,9 +1270,9 @@ bool AfterLoadGame() Axis axis = static_cast(GB(t.m5(), 0, 1)); uint north_south = GB(t.m5(), 5, 1); DiagDirection dir = ReverseDiagDir(XYNSToDiagDir(axis, north_south)); - TransportType type = (TransportType)GB(t.m5(), 1, 2); + TransportType type = static_cast(GB(t.m5(), 1, 2)); - t.m5() = 1 << 7 | type << 2 | to_underlying(dir); + t.m5() = 1 << 7 | to_underlying(type) << 2 | to_underlying(dir); } } } @@ -1316,7 +1316,7 @@ bool AfterLoadGame() has_road = IsAnyRoadStop(t); break; case TileType::TunnelBridge: - has_road = GetTunnelBridgeTransportType(t) == TRANSPORT_ROAD; + has_road = GetTunnelBridgeTransportType(t) == TransportType::Road; break; default: break; @@ -1364,7 +1364,7 @@ bool AfterLoadGame() break; case TileType::TunnelBridge: - if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) { + if (GetTunnelBridgeTransportType(t) == TransportType::Rail) { SetRailType(t, UpdateRailType(GetRailType(t), min_rail)); } break; @@ -2049,7 +2049,7 @@ bool AfterLoadGame() break; case TileType::TunnelBridge: // Clear PBS reservation on tunnels/bridges - if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) SetTunnelBridgeReservation(t, false); + if (GetTunnelBridgeTransportType(t) == TransportType::Rail) SetTunnelBridgeReservation(t, false); break; default: break; @@ -2770,7 +2770,7 @@ bool AfterLoadGame() if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) break; - TrackStatus ts = GetTileTrackStatus(rv->tile, TRANSPORT_ROAD, GetRoadTramType(rv->roadtype)); + TrackStatus ts = GetTileTrackStatus(rv->tile, TransportType::Road, GetRoadTramType(rv->roadtype)); TrackBits trackbits = TrackdirBitsToTrackBits(ts.trackdirs); /* Only X/Y tracks can be sloped. */ diff --git a/src/saveload/company_sl.cpp b/src/saveload/company_sl.cpp index 8518e99d33..c6233dac97 100644 --- a/src/saveload/company_sl.cpp +++ b/src/saveload/company_sl.cpp @@ -235,12 +235,12 @@ void AfterLoadCompanyStats() uint len = (GetTunnelBridgeLength(tile, other_end) + 2) * TUNNELBRIDGE_TRACKBIT_FACTOR; switch (GetTunnelBridgeTransportType(tile)) { - case TRANSPORT_RAIL: + case TransportType::Rail: c = Company::GetIfValid(GetTileOwner(tile)); if (c != nullptr) c->infrastructure.rail[GetRailType(tile)] += len; break; - case TRANSPORT_ROAD: { + case TransportType::Road: { /* Iterate all present road types as each can have a different owner. */ for (RoadTramType rtt : ROADTRAMTYPES_ALL) { RoadType rt = GetRoadType(tile, rtt); @@ -251,7 +251,7 @@ void AfterLoadCompanyStats() break; } - case TRANSPORT_WATER: + case TransportType::Water: c = Company::GetIfValid(GetTileOwner(tile)); if (c != nullptr) c->infrastructure.water += len; break; diff --git a/src/script/api/script_bridge.cpp b/src/script/api/script_bridge.cpp index 45ef9c4a6d..c2638ca451 100644 --- a/src/script/api/script_bridge.cpp +++ b/src/script/api/script_bridge.cpp @@ -86,11 +86,11 @@ static void _DoCommandReturnBuildBridge1(class ScriptInstance &instance) case ScriptVehicle::VT_ROAD: ScriptObject::SetCallbackVariable(0, start.base()); ScriptObject::SetCallbackVariable(1, end.base()); - return ScriptObject::Command::Do(&::_DoCommandReturnBuildBridge1, end, start, TRANSPORT_ROAD, bridge_type, INVALID_RAILTYPE, static_cast<::RoadType>(ScriptRoad::GetCurrentRoadType())); + return ScriptObject::Command::Do(&::_DoCommandReturnBuildBridge1, end, start, TransportType::Road, bridge_type, INVALID_RAILTYPE, static_cast<::RoadType>(ScriptRoad::GetCurrentRoadType())); case ScriptVehicle::VT_RAIL: - return ScriptObject::Command::Do(end, start, TRANSPORT_RAIL, bridge_type, static_cast<::RailType>(ScriptRail::GetCurrentRailType()), INVALID_ROADTYPE); + return ScriptObject::Command::Do(end, start, TransportType::Rail, bridge_type, static_cast<::RailType>(ScriptRail::GetCurrentRailType()), INVALID_ROADTYPE); case ScriptVehicle::VT_WATER: - return ScriptObject::Command::Do(end, start, TRANSPORT_WATER, bridge_type, INVALID_RAILTYPE, INVALID_ROADTYPE); + return ScriptObject::Command::Do(end, start, TransportType::Water, bridge_type, INVALID_RAILTYPE, INVALID_ROADTYPE); default: NOT_REACHED(); } } diff --git a/src/script/api/script_marine.cpp b/src/script/api/script_marine.cpp index 537e65b4df..d00fe95648 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 = ::TrackdirBitsToTrackBits(::GetTileTrackStatus(t1, TRANSPORT_WATER, RoadTramType::Invalid, ReverseDiagDir(to_other_tile)).trackdirs) & ::DiagdirReachesTracks(to_other_tile); + TrackBits gtts1 = ::TrackdirBitsToTrackBits(::GetTileTrackStatus(t1, TransportType::Water, RoadTramType::Invalid, ReverseDiagDir(to_other_tile)).trackdirs) & ::DiagdirReachesTracks(to_other_tile); if (gtts1.None()) return false; to_other_tile = ReverseDiagDir(to_other_tile); - TrackBits gtts2 = ::TrackdirBitsToTrackBits(::GetTileTrackStatus(t2, TRANSPORT_WATER, RoadTramType::Invalid, ReverseDiagDir(to_other_tile)).trackdirs) & ::DiagdirReachesTracks(to_other_tile); + TrackBits gtts2 = ::TrackdirBitsToTrackBits(::GetTileTrackStatus(t2, TransportType::Water, RoadTramType::Invalid, ReverseDiagDir(to_other_tile)).trackdirs) & ::DiagdirReachesTracks(to_other_tile); return gtts2.Any(); } diff --git a/src/script/api/script_tile.hpp b/src/script/api/script_tile.hpp index 515c3208fe..192f24697a 100644 --- a/src/script/api/script_tile.hpp +++ b/src/script/api/script_tile.hpp @@ -100,10 +100,10 @@ public: */ enum TransportType { /* Note: these values represent part of the in-game TransportType enum */ - TRANSPORT_RAIL = ::TRANSPORT_RAIL, ///< Tile with rail. - TRANSPORT_ROAD = ::TRANSPORT_ROAD, ///< Tile with road. - TRANSPORT_WATER = ::TRANSPORT_WATER, ///< Tile with navigable waterways. - TRANSPORT_AIR = ::TRANSPORT_AIR, ///< Tile with airport. + TRANSPORT_RAIL = to_underlying(::TransportType::Rail), ///< Tile with rail. + TRANSPORT_ROAD = to_underlying(::TransportType::Road), ///< Tile with road. + TRANSPORT_WATER = to_underlying(::TransportType::Water), ///< Tile with navigable waterways. + TRANSPORT_AIR = to_underlying(::TransportType::Air), ///< Tile with airport. /* Custom added value, only valid for this API */ TRANSPORT_INVALID = -1, ///< Tile without any transport type. diff --git a/src/script/api/script_tunnel.cpp b/src/script/api/script_tunnel.cpp index 40a49ad830..d23dd481a8 100644 --- a/src/script/api/script_tunnel.cpp +++ b/src/script/api/script_tunnel.cpp @@ -90,10 +90,10 @@ static void _DoCommandReturnBuildTunnel1(class ScriptInstance &instance) if (vehicle_type == ScriptVehicle::VT_RAIL) { /* For rail we do nothing special */ - return ScriptObject::Command::Do(start, TRANSPORT_RAIL, static_cast<::RailType>(ScriptRail::GetCurrentRailType()), INVALID_ROADTYPE); + return ScriptObject::Command::Do(start, TransportType::Rail, static_cast<::RailType>(ScriptRail::GetCurrentRailType()), INVALID_ROADTYPE); } else { ScriptObject::SetCallbackVariable(0, start.base()); - return ScriptObject::Command::Do(&::_DoCommandReturnBuildTunnel1, start, TRANSPORT_ROAD, INVALID_RAILTYPE, static_cast<::RoadType>(ScriptRoad::GetCurrentRoadType())); + return ScriptObject::Command::Do(&::_DoCommandReturnBuildTunnel1, start, TransportType::Road, INVALID_RAILTYPE, static_cast<::RoadType>(ScriptRoad::GetCurrentRoadType())); } } diff --git a/src/ship_cmd.cpp b/src/ship_cmd.cpp index 650fc8a5ca..8d7cad7a0b 100644 --- a/src/ship_cmd.cpp +++ b/src/ship_cmd.cpp @@ -54,7 +54,7 @@ WaterClass GetEffectiveWaterClass(TileIndex tile) { if (HasTileWaterClass(tile)) return GetWaterClass(tile); if (IsTileType(tile, TileType::TunnelBridge)) { - assert(GetTunnelBridgeTransportType(tile) == TRANSPORT_WATER); + assert(GetTunnelBridgeTransportType(tile) == TransportType::Water); return WaterClass::Canal; } if (IsTileType(tile, TileType::Railway)) { @@ -75,7 +75,7 @@ bool IsValidImageIndex(uint8_t image_index) static inline TrackBits GetTileShipTrackStatus(TileIndex tile) { - return TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid).trackdirs); + return TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TransportType::Water, RoadTramType::Invalid).trackdirs); } static void GetShipIcon(EngineID engine, EngineImageType image_type, VehicleSpriteSeq *result) @@ -675,7 +675,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 (TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid, exitdir).trackdirs).None()) return ReverseShip(v); + if (TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TransportType::Water, RoadTramType::Invalid, exitdir).trackdirs).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 7530514f82..f1a0ba3682 100644 --- a/src/signal.cpp +++ b/src/signal.cpp @@ -382,7 +382,7 @@ static SigFlags ExploreSegment(Owner owner) case TileType::TunnelBridge: { if (GetTileOwner(tile) != owner) continue; - if (GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) continue; + if (GetTunnelBridgeTransportType(tile) != TransportType::Rail) continue; DiagDirection dir = GetTunnelBridgeDirection(tile); if (enterdir == DiagDirection::Invalid) { // incoming from the wormhole @@ -507,7 +507,7 @@ static SigSegState UpdateSignalsInBuffer(Owner owner) switch (GetTileType(tile)) { case TileType::TunnelBridge: /* 'optimization assert' - do not try to update signals when it is not needed */ - assert(GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL); + assert(GetTunnelBridgeTransportType(tile) == TransportType::Rail); assert(dir == DiagDirection::Invalid || dir == ReverseDiagDir(GetTunnelBridgeDirection(tile))); _tbdset.Add(tile, DiagDirection::Invalid); // we can safely start from wormhole centre _tbdset.Add(GetOtherTunnelBridgeEnd(tile), DiagDirection::Invalid); @@ -524,7 +524,7 @@ static SigSegState UpdateSignalsInBuffer(Owner owner) case TileType::Station: case TileType::Road: - if (TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs).Any(_enterdir_to_trackbits[dir])) { + if (TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TransportType::Rail, RoadTramType::Invalid).trackdirs).Any(_enterdir_to_trackbits[dir])) { /* only add to set when there is some 'interesting' track */ _tbdset.Add(tile, dir); _tbdset.Add(tile + TileOffsByDiagDir(dir), ReverseDiagDir(dir)); @@ -536,7 +536,7 @@ static SigSegState UpdateSignalsInBuffer(Owner owner) /* jump to next tile */ tile = tile + TileOffsByDiagDir(dir); dir = ReverseDiagDir(dir); - if (TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs).Any(_enterdir_to_trackbits[dir])) { + if (TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TransportType::Rail, RoadTramType::Invalid).trackdirs).Any(_enterdir_to_trackbits[dir])) { _tbdset.Add(tile, dir); break; } diff --git a/src/smallmap_gui.cpp b/src/smallmap_gui.cpp index a7a1284dac..9de0b6faca 100644 --- a/src/smallmap_gui.cpp +++ b/src/smallmap_gui.cpp @@ -1338,9 +1338,9 @@ protected: TransportType tt = GetTunnelBridgeTransportType(ti); switch (tt) { - case TRANSPORT_RAIL: ttype = TileType::Railway; break; - case TRANSPORT_ROAD: ttype = TileType::Road; break; - default: ttype = TileType::Water; break; + case TransportType::Rail: ttype = TileType::Railway; break; + case TransportType::Road: ttype = TileType::Road; break; + default: ttype = TileType::Water; break; } break; } diff --git a/src/station_cmd.cpp b/src/station_cmd.cpp index ee6c1e1f6c..b41292e87c 100644 --- a/src/station_cmd.cpp +++ b/src/station_cmd.cpp @@ -3693,13 +3693,13 @@ static TrackStatus GetTileTrackStatus_Station(TileIndex tile, TransportType mode TrackBits trackbits{}; switch (mode) { - case TRANSPORT_RAIL: + case TransportType::Rail: if (HasStationRail(tile) && !IsStationTileBlocked(tile)) { trackbits = GetRailStationTrack(tile); } break; - case TRANSPORT_WATER: + case TransportType::Water: /* buoy is coded as a station, it is always on open water */ if (IsBuoy(tile)) { trackbits = TRACK_BIT_ALL; @@ -3710,7 +3710,7 @@ static TrackStatus GetTileTrackStatus_Station(TileIndex tile, TransportType mode } break; - case TRANSPORT_ROAD: + case TransportType::Road: if (IsAnyRoadStop(tile)) { RoadTramType rtt = (RoadTramType)sub_mode; if (!HasTileRoadType(tile, rtt)) break; diff --git a/src/town_cmd.cpp b/src/town_cmd.cpp index 683e53b420..832f9f36ee 100644 --- a/src/town_cmd.cpp +++ b/src/town_cmd.cpp @@ -1246,7 +1246,7 @@ static bool CanRoadContinueIntoNextTile(const Town *t, const TileIndex tile, con /* If the next tile is a bridge or tunnel, allow if it's continuing in the same direction. */ if (IsTileType(next_tile, TileType::TunnelBridge)) { - return GetTunnelBridgeTransportType(next_tile) == TRANSPORT_ROAD && GetTunnelBridgeDirection(next_tile) == road_dir; + return GetTunnelBridgeTransportType(next_tile) == TransportType::Road && GetTunnelBridgeDirection(next_tile) == road_dir; } /* If the next tile is a station, allow if it's a road station facing the proper direction. Otherwise return false. */ @@ -1338,7 +1338,7 @@ static bool GrowTownWithBridge(const Town *t, const TileIndex tile, const DiagDi if (!IsBridgeTile(search)) continue; /* Only consider road bridges. */ - if (GetTunnelBridgeTransportType(search) != TRANSPORT_ROAD) continue; + if (GetTunnelBridgeTransportType(search) != TransportType::Road) continue; /* If the bridge is facing the same direction as the proposed bridge, we've found a redundant bridge. */ if (GetTileSlope(search) & InclinedSlope(ReverseDiagDir(bridge_dir))) return false; @@ -1350,8 +1350,8 @@ static bool GrowTownWithBridge(const Town *t, const TileIndex tile, const DiagDi /* Can we actually build the bridge? */ RoadType rt = GetTownRoadType(); - if (Command::Do(CommandFlagsToDCFlags(GetCommandFlags()), tile, bridge_tile, TRANSPORT_ROAD, bridge_type, INVALID_RAILTYPE, rt).Succeeded()) { - Command::Do(CommandFlagsToDCFlags(GetCommandFlags()).Set(DoCommandFlag::Execute), tile, bridge_tile, TRANSPORT_ROAD, bridge_type, INVALID_RAILTYPE, rt); + if (Command::Do(CommandFlagsToDCFlags(GetCommandFlags()), tile, bridge_tile, TransportType::Road, bridge_type, INVALID_RAILTYPE, rt).Succeeded()) { + Command::Do(CommandFlagsToDCFlags(GetCommandFlags()).Set(DoCommandFlag::Execute), tile, bridge_tile, TransportType::Road, bridge_type, INVALID_RAILTYPE, rt); return true; } } @@ -1420,8 +1420,8 @@ static bool GrowTownWithTunnel(const Town *t, const TileIndex tile, const DiagDi /* Attempt to build the tunnel. Return false if it fails to let the town build a road instead. */ RoadType rt = GetTownRoadType(); - if (Command::Do(CommandFlagsToDCFlags(GetCommandFlags()), tile, TRANSPORT_ROAD, INVALID_RAILTYPE, rt).Succeeded()) { - Command::Do(CommandFlagsToDCFlags(GetCommandFlags()).Set(DoCommandFlag::Execute), tile, TRANSPORT_ROAD, INVALID_RAILTYPE, rt); + if (Command::Do(CommandFlagsToDCFlags(GetCommandFlags()), tile, TransportType::Road, INVALID_RAILTYPE, rt).Succeeded()) { + Command::Do(CommandFlagsToDCFlags(GetCommandFlags()).Set(DoCommandFlag::Execute), tile, TransportType::Road, INVALID_RAILTYPE, rt); return true; } @@ -1589,7 +1589,7 @@ static TownGrowthResult GrowTownInTile(TileIndex *tile_ptr, RoadBits cur_rb, Dia /* Reached a tunnel/bridge? Then continue at the other side of it, unless * it is the starting tile. Half the time, we stay on this side then.*/ if (IsTileType(tile, TileType::TunnelBridge)) { - if (GetTunnelBridgeTransportType(tile) == TRANSPORT_ROAD && (target_dir != DiagDirection::End || Chance16(1, 2))) { + if (GetTunnelBridgeTransportType(tile) == TransportType::Road && (target_dir != DiagDirection::End || Chance16(1, 2))) { *tile_ptr = GetOtherTunnelBridgeEnd(tile); } return TownGrowthResult::Continue; @@ -1739,7 +1739,7 @@ static bool CanFollowRoad(TileIndex tile, DiagDirection dir, TownExpandModes mod return IsDriveThroughStopTile(target_tile); case TileType::TunnelBridge: - return GetTunnelBridgeTransportType(target_tile) == TRANSPORT_ROAD; + return GetTunnelBridgeTransportType(target_tile) == TransportType::Road; case TileType::House: case TileType::Industry: diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp index 9b149a7e4d..adbee873b4 100644 --- a/src/train_cmd.cpp +++ b/src/train_cmd.cpp @@ -2882,7 +2882,7 @@ static Track ChooseTrainTrack(Train *consist, TileIndex tile, DiagDirection ente /* 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(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs) & DiagdirReachesTracks(exitdir); + TrackBits reachable = TrackdirBitsToTrackBits(GetTileTrackStatus(next_tile, TransportType::Rail, RoadTramType::Invalid).trackdirs) & DiagdirReachesTracks(exitdir); if (Rail90DegTurnDisallowed(GetTileRailType(res_dest.tile), GetTileRailType(next_tile))) { reachable.Reset(TrackCrossesTracks(TrackdirToTrack(res_dest.trackdir))); } @@ -2984,7 +2984,7 @@ bool TryPathReserve(Train *consist, bool mark_as_stuck, bool first_tile_okay) DiagDirection exitdir = TrackdirToExitdir(origin.trackdir); TileIndex new_tile = TileAddByDiagDir(origin.tile, exitdir); - TrackBits reachable = TrackdirBitsToTrackBits(GetTileTrackStatus(new_tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs & DiagdirReachesTrackdirs(exitdir)); + TrackBits reachable = TrackdirBitsToTrackBits(GetTileTrackStatus(new_tile, TransportType::Rail, RoadTramType::Invalid).trackdirs & DiagdirReachesTrackdirs(exitdir)); if (Rail90DegTurnDisallowed(GetTileRailType(origin.tile), GetTileRailType(new_tile))) reachable.Reset(TrackCrossesTracks(TrackdirToTrack(origin.trackdir))); @@ -3387,7 +3387,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, RoadTramType::Invalid, ReverseDiagDir(enterdir)); + TrackStatus ts = GetTileTrackStatus(gp.new_tile, TransportType::Rail, RoadTramType::Invalid, ReverseDiagDir(enterdir)); TrackdirBits reachable_trackdirs = DiagdirReachesTrackdirs(enterdir); TrackdirBits trackdirbits = ts.trackdirs & reachable_trackdirs; @@ -3966,7 +3966,7 @@ static bool TrainCheckIfLineEnds(Train *moving_front, bool reverse) TileIndex tile = moving_front->tile + TileOffsByDiagDir(dir); /* Determine the track status on the next tile */ - TrackStatus ts = GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid, ReverseDiagDir(dir)); + TrackStatus ts = GetTileTrackStatus(tile, TransportType::Rail, RoadTramType::Invalid, ReverseDiagDir(dir)); TrackdirBits reachable_trackdirs = DiagdirReachesTrackdirs(dir); TrackdirBits trackdirbits = ts.trackdirs & reachable_trackdirs; diff --git a/src/transport_type.h b/src/transport_type.h index fc5921a6ba..f51bd4a82e 100644 --- a/src/transport_type.h +++ b/src/transport_type.h @@ -14,20 +14,18 @@ typedef uint16_t UnitID; /** Available types of transport */ -enum TransportType : uint8_t { +enum class TransportType : uint8_t { /* These constants are for now linked to the representation of bridges * and tunnels, so they can be used by GetTileTrackStatus_TunnelBridge. * In an ideal world, these constants would be used everywhere when * accessing tunnels and bridges. For now, you should just not change * the values for road and rail. */ - TRANSPORT_BEGIN = 0, ///< Begin of the iterator. - TRANSPORT_RAIL = TRANSPORT_BEGIN, ///< Transport by train - TRANSPORT_ROAD, ///< Transport by road vehicle - TRANSPORT_WATER, ///< Transport over water - TRANSPORT_AIR, ///< Transport through air - TRANSPORT_END, ///< End of iterations. - INVALID_TRANSPORT = 0xff, ///< Sentinel for invalid transport types. + Rail, ///< Transport by train + Road, ///< Transport by road vehicle + Water, ///< Transport over water + Air, ///< Transport through air + Invalid = 0xFF, ///< Sentinel for invalid transport types. }; #endif /* TRANSPORT_TYPE_H */ diff --git a/src/tunnel_map.h b/src/tunnel_map.h index 999bca42b2..b6817b1e58 100644 --- a/src/tunnel_map.h +++ b/src/tunnel_map.h @@ -55,7 +55,7 @@ inline void MakeRoadTunnel(Tile t, Owner o, DiagDirection d, RoadType road_rt, R t.m2() = 0; t.m3() = 0; t.m4() = 0; - t.m5() = TRANSPORT_ROAD << 2 | to_underlying(d); + t.m5() = to_underlying(TransportType::Road) << 2 | to_underlying(d); SB(t.m6(), 2, 6, 0); t.m7() = 0; t.m8() = 0; @@ -78,7 +78,7 @@ inline void MakeRailTunnel(Tile t, Owner o, DiagDirection d, RailType r) t.m2() = 0; t.m3() = 0; t.m4() = 0; - t.m5() = TRANSPORT_RAIL << 2 | to_underlying(d); + t.m5() = to_underlying(TransportType::Rail) << 2 | to_underlying(d); SB(t.m6(), 2, 6, 0); t.m7() = 0; t.m8() = 0; diff --git a/src/tunnelbridge_cmd.cpp b/src/tunnelbridge_cmd.cpp index 996a5be0a5..7d29ce1ac1 100644 --- a/src/tunnelbridge_cmd.cpp +++ b/src/tunnelbridge_cmd.cpp @@ -172,8 +172,8 @@ static std::span GetBridgeSpriteTable(BridgeType bridge_type, static uint8_t GetBridgeSpriteTableBaseOffset(TransportType transport_type, TileIndex ramp) { switch (transport_type) { - case TRANSPORT_RAIL: return GetRailTypeInfo(GetRailType(ramp))->bridge_offset; - case TRANSPORT_ROAD: return 8; + case TransportType::Rail: return GetRailTypeInfo(GetRailType(ramp))->bridge_offset; + case TransportType::Road: return 8; default: NOT_REACHED(); } } @@ -267,7 +267,7 @@ static Money TunnelBridgeClearCost(TileIndex tile, Price base_price) /* Add the cost of the transport that is on the tunnel/bridge. */ switch (GetTunnelBridgeTransportType(tile)) { - case TRANSPORT_ROAD: { + case TransportType::Road: { RoadType road_rt = GetRoadTypeRoad(tile); RoadType tram_rt = GetRoadTypeTram(tile); @@ -279,9 +279,9 @@ static Money TunnelBridgeClearCost(TileIndex tile, Price base_price) } } break; - case TRANSPORT_RAIL: base_cost += RailClearCost(GetRailType(tile)); break; + case TransportType::Rail: base_cost += RailClearCost(GetRailType(tile)); break; /* Aqueducts have their own clear price. */ - case TRANSPORT_WATER: base_cost = _price[Price::ClearAqueduct]; break; + case TransportType::Water: base_cost = _price[Price::ClearAqueduct]; break; default: break; } @@ -316,20 +316,20 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t if (!IsValidTile(t)) return CommandCost(STR_ERROR_BRIDGE_THROUGH_MAP_BORDER); /* User cannot modify height of tiles with one coordinate equal to zero, they are always at the sea level, and you can't build bridge in the sea. * Furthermore, they are void tiles unless map is infinite water. If we don't return for them here, we will still fail as their slope is invalid. */ - if (TileX(t) == 0 || TileY(t) == 0) return CommandCost(transport_type == TRANSPORT_WATER ? STR_ERROR_BRIDGE_THROUGH_MAP_BORDER : STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP); + if (TileX(t) == 0 || TileY(t) == 0) return CommandCost(transport_type == TransportType::Water ? STR_ERROR_BRIDGE_THROUGH_MAP_BORDER : STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP); } /* type of bridge */ switch (transport_type) { - case TRANSPORT_ROAD: + case TransportType::Road: if (!ValParamRoadType(roadtype)) return CMD_ERROR; break; - case TRANSPORT_RAIL: + case TransportType::Rail: if (!ValParamRailType(railtype)) return CMD_ERROR; break; - case TRANSPORT_WATER: + case TransportType::Water: break; default: @@ -338,7 +338,7 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t } if (company == OWNER_DEITY) { - if (transport_type != TRANSPORT_ROAD) return CMD_ERROR; + if (transport_type != TransportType::Road) return CMD_ERROR; const Town *town = CalcClosestTownFromTile(tile_start); company = OWNER_TOWN; @@ -365,7 +365,7 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t if (tile_end < tile_start) std::swap(tile_start, tile_end); uint bridge_len = GetTunnelBridgeLength(tile_start, tile_end); - if (transport_type != TRANSPORT_WATER) { + if (transport_type != TransportType::Water) { /* set and test bridge length, availability */ CommandCost ret = CheckBridgeAvailability(bridge_type, bridge_len, flags); if (ret.Failed()) return ret; @@ -382,7 +382,7 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t CommandCost terraform_cost_south = CheckBridgeSlope(BRIDGE_PIECE_SOUTH, direction, tileh_end, z_end); /* Aqueducts can't be built of flat land. */ - if (transport_type == TRANSPORT_WATER && (tileh_start == SLOPE_FLAT || tileh_end == SLOPE_FLAT)) return CommandCost(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION); + if (transport_type == TransportType::Water && (tileh_start == SLOPE_FLAT || tileh_end == SLOPE_FLAT)) return CommandCost(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION); if (z_start != z_end) return CommandCost(STR_ERROR_BRIDGEHEADS_NOT_SAME_HEIGHT); CommandCost cost(ExpensesType::Construction); @@ -396,12 +396,12 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t /* Replace a current bridge. */ switch (transport_type) { - case TRANSPORT_RAIL: + case TransportType::Rail: /* Keep the reservation, the path stays valid. */ pbs_reservation = HasTunnelBridgeReservation(tile_start); break; - case TRANSPORT_ROAD: + case TransportType::Road: /* Do not remove road types when upgrading a bridge */ road_rt = GetRoadTypeRoad(tile_start); tram_rt = GetRoadTypeTram(tile_start); @@ -411,12 +411,12 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t } /* If this is a railway bridge, make sure the railtypes match. */ - if (transport_type == TRANSPORT_RAIL && GetRailType(tile_start) != railtype) { + if (transport_type == TransportType::Rail && GetRailType(tile_start) != railtype) { return CommandCost(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST); } /* If this is a road bridge, make sure the roadtype matches. */ - if (transport_type == TRANSPORT_ROAD) { + if (transport_type == TransportType::Road) { RoadType existing_rt = RoadTypeIsRoad(roadtype) ? road_rt : tram_rt; if (existing_rt != roadtype && existing_rt != INVALID_ROADTYPE) { return CommandCost(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST); @@ -425,7 +425,7 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t if (!flags.Test(DoCommandFlag::QueryCost)) { /* Do not replace the bridge with the same bridge type. */ - if ((bridge_type == GetBridgeType(tile_start)) && (transport_type != TRANSPORT_ROAD || road_rt == roadtype || tram_rt == roadtype)) { + if ((bridge_type == GetBridgeType(tile_start)) && (transport_type != TransportType::Road || road_rt == roadtype || tram_rt == roadtype)) { return CommandCost(STR_ERROR_ALREADY_BUILT); } @@ -465,7 +465,7 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t } else { /* Build a new bridge. */ - bool allow_on_slopes = (_settings_game.construction.build_on_slopes && transport_type != TRANSPORT_WATER); + bool allow_on_slopes = (_settings_game.construction.build_on_slopes && transport_type != TransportType::Water); /* Try and clear the start landscape */ CommandCost ret = Command::Do(flags, tile_start); @@ -530,7 +530,7 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t bool hasroad = road_rt != INVALID_ROADTYPE; bool hastram = tram_rt != INVALID_ROADTYPE; - if (transport_type == TRANSPORT_ROAD) { + if (transport_type == TransportType::Road) { if (RoadTypeIsRoad(roadtype)) road_rt = roadtype; if (RoadTypeIsTram(roadtype)) tram_rt = roadtype; } @@ -541,7 +541,7 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t Company *c = Company::GetIfValid(company); switch (transport_type) { - case TRANSPORT_RAIL: + case TransportType::Rail: /* Add to company infrastructure count if required. */ if (is_new_owner && c != nullptr) c->infrastructure.rail[railtype] += bridge_len * TUNNELBRIDGE_TRACKBIT_FACTOR; MakeRailBridgeRamp(tile_start, owner, bridge_type, dir, railtype); @@ -550,7 +550,7 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t SetTunnelBridgeReservation(tile_end, pbs_reservation); break; - case TRANSPORT_ROAD: { + case TransportType::Road: { if (is_new_owner) { /* Also give unowned present roadtypes to new owner */ if (hasroad && GetRoadOwner(tile_start, RoadTramType::Road) == OWNER_NONE) hasroad = false; @@ -574,7 +574,7 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t break; } - case TRANSPORT_WATER: + case TransportType::Water: if (is_new_owner && c != nullptr) c->infrastructure.water += bridge_len * TUNNELBRIDGE_TRACKBIT_FACTOR; MakeAqueductBridgeRamp(tile_start, owner, dir); MakeAqueductBridgeRamp(tile_end, owner, ReverseDiagDir(dir)); @@ -591,7 +591,7 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t DirtyCompanyInfrastructureWindows(company); } - if (flags.Test(DoCommandFlag::Execute) && transport_type == TRANSPORT_RAIL) { + if (flags.Test(DoCommandFlag::Execute) && transport_type == TransportType::Rail) { Track track = AxisToTrack(direction); AddSideToSignalBuffer(tile_start, DiagDirection::Invalid, company); YapfNotifyTrackLayoutChange(tile_start, track); @@ -604,7 +604,7 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t Company *c = Company::GetIfValid(company); if (!flags.Test(DoCommandFlag::QueryCost) || (c != nullptr && c->is_ai && company != _local_company)) { switch (transport_type) { - case TRANSPORT_ROAD: + case TransportType::Road: if (road_rt != INVALID_ROADTYPE) { cost.AddCost(bridge_len * 2 * RoadBuildCost(road_rt)); } @@ -613,13 +613,13 @@ CommandCost CmdBuildBridge(DoCommandFlags flags, TileIndex tile_end, TileIndex t } break; - case TRANSPORT_RAIL: cost.AddCost(bridge_len * RailBuildCost(railtype)); break; + case TransportType::Rail: cost.AddCost(bridge_len * RailBuildCost(railtype)); break; default: break; } if (c != nullptr) bridge_len = CalcBridgeLenCostFactor(bridge_len); - if (transport_type != TRANSPORT_WATER) { + if (transport_type != TransportType::Water) { cost.AddCost((int64_t)bridge_len * _price[Price::BuildBridge] * GetBridgeSpec(bridge_type)->price >> 8); } else { /* Aqueducts use a separate base cost. */ @@ -647,11 +647,11 @@ CommandCost CmdBuildTunnel(DoCommandFlags flags, TileIndex start_tile, Transport _build_tunnel_endtile = INVALID_TILE; switch (transport_type) { - case TRANSPORT_RAIL: + case TransportType::Rail: if (!ValParamRailType(railtype)) return CMD_ERROR; break; - case TRANSPORT_ROAD: + case TransportType::Road: if (!ValParamRoadType(roadtype)) return CMD_ERROR; break; @@ -659,7 +659,7 @@ CommandCost CmdBuildTunnel(DoCommandFlags flags, TileIndex start_tile, Transport } if (company == OWNER_DEITY) { - if (transport_type != TRANSPORT_ROAD) return CMD_ERROR; + if (transport_type != TransportType::Road) return CMD_ERROR; const Town *town = CalcClosestTownFromTile(start_tile); company = OWNER_TOWN; @@ -778,15 +778,15 @@ CommandCost CmdBuildTunnel(DoCommandFlags flags, TileIndex start_tile, Transport /* Pay for the rail/road in the tunnel including entrances */ switch (transport_type) { - case TRANSPORT_ROAD: cost.AddCost((tiles + 2) * RoadBuildCost(roadtype) * 2); break; - case TRANSPORT_RAIL: cost.AddCost((tiles + 2) * RailBuildCost(railtype)); break; + case TransportType::Road: cost.AddCost((tiles + 2) * RoadBuildCost(roadtype) * 2); break; + case TransportType::Rail: cost.AddCost((tiles + 2) * RailBuildCost(railtype)); break; default: NOT_REACHED(); } if (flags.Test(DoCommandFlag::Execute)) { Company *c = Company::GetIfValid(company); uint num_pieces = (tiles + 2) * TUNNELBRIDGE_TRACKBIT_FACTOR; - if (transport_type == TRANSPORT_RAIL) { + if (transport_type == TransportType::Rail) { if (c != nullptr) c->infrastructure.rail[railtype] += num_pieces; MakeRailTunnel(start_tile, company, direction, railtype); MakeRailTunnel(end_tile, company, ReverseDiagDir(direction), railtype); @@ -817,7 +817,7 @@ static inline CommandCost CheckAllowRemoveTunnelBridge(TileIndex tile) if (_current_company == OWNER_WATER || _game_mode == GameMode::Editor) return CommandCost(); switch (GetTunnelBridgeTransportType(tile)) { - case TRANSPORT_ROAD: { + case TransportType::Road: { RoadType road_rt = GetRoadTypeRoad(tile); RoadType tram_rt = GetRoadTypeTram(tile); Owner road_owner = _current_company; @@ -839,10 +839,10 @@ static inline CommandCost CheckAllowRemoveTunnelBridge(TileIndex tile) return ret; } - case TRANSPORT_RAIL: + case TransportType::Rail: return CheckOwnership(GetTileOwner(tile)); - case TRANSPORT_WATER: { + case TransportType::Water: { /* Always allow to remove aqueducts without owner. */ Owner aqueduct_owner = GetTileOwner(tile); if (aqueduct_owner == OWNER_NONE) aqueduct_owner = _current_company; @@ -891,7 +891,7 @@ static CommandCost DoClearTunnel(TileIndex tile, DoCommandFlags flags) uint len = GetTunnelBridgeLength(tile, endtile) + 2; // Don't forget the end tiles. if (flags.Test(DoCommandFlag::Execute)) { - if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL) { + if (GetTunnelBridgeTransportType(tile) == TransportType::Rail) { /* We first need to request values before calling DoClearSquare */ DiagDirection dir = GetTunnelBridgeDirection(tile); Track track = DiagDirToDiagTrack(dir); @@ -973,7 +973,7 @@ static CommandCost DoClearBridge(TileIndex tile, DoCommandFlags flags) if (flags.Test(DoCommandFlag::Execute)) { /* read this value before actual removal of bridge */ - bool rail = GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL; + bool rail = GetTunnelBridgeTransportType(tile) == TransportType::Rail; Owner owner = GetTileOwner(tile); int height = GetBridgeHeight(tile); Train *v = nullptr; @@ -986,7 +986,7 @@ static CommandCost DoClearBridge(TileIndex tile, DoCommandFlags flags) /* Update company infrastructure counts. */ if (rail) { if (Company::IsValidID(owner)) Company::Get(owner)->infrastructure.rail[GetRailType(tile)] -= len * TUNNELBRIDGE_TRACKBIT_FACTOR; - } else if (GetTunnelBridgeTransportType(tile) == TRANSPORT_ROAD) { + } else if (GetTunnelBridgeTransportType(tile) == TransportType::Road) { /* A full diagonal road tile has two road bits. */ 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)); @@ -1327,7 +1327,7 @@ static void DrawTile_TunnelBridge(TileInfo *ti) SpriteID image; SpriteID railtype_overlay = 0; - if (transport_type == TRANSPORT_RAIL) { + if (transport_type == TransportType::Rail) { const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile)); image = rti->base_sprites.tunnel; if (rti->UsesOverlay()) { @@ -1344,7 +1344,7 @@ static void DrawTile_TunnelBridge(TileInfo *ti) image += to_underlying(tunnelbridge_direction) * 2; DrawGroundSprite(image, PAL_NONE); - if (transport_type == TRANSPORT_ROAD) { + if (transport_type == TransportType::Road) { RoadType road_rt = GetRoadTypeRoad(ti->tile); RoadType tram_rt = GetRoadTypeTram(ti->tile); const RoadTypeInfo *road_rti = road_rt == INVALID_ROADTYPE ? nullptr : GetRoadTypeInfo(road_rt); @@ -1443,7 +1443,7 @@ static void DrawTile_TunnelBridge(TileInfo *ti) uint base_offset = GetBridgeRampDirectionBaseOffset(tunnelbridge_direction); std::span psid; - if (transport_type != TRANSPORT_WATER) { + if (transport_type != TransportType::Water) { BridgeType bridge_type = GetBridgeType(ti->tile); if (ti->tileh == SLOPE_FLAT) base_offset += 4; // sloped bridge head base_offset += GetBridgeSpriteTableBaseOffset(transport_type, ti->tile); @@ -1468,7 +1468,7 @@ static void DrawTile_TunnelBridge(TileInfo *ti) /* draw ramp */ /* Draw Trambits and PBS Reservation as SpriteCombine */ - if (transport_type == TRANSPORT_ROAD || transport_type == TRANSPORT_RAIL) StartSpriteCombine(); + if (transport_type == TransportType::Road || transport_type == TransportType::Rail) StartSpriteCombine(); /* HACK set the height of the BB of a sloped ramp to 1 so a vehicle on * it doesn't disappear behind it @@ -1476,7 +1476,7 @@ static void DrawTile_TunnelBridge(TileInfo *ti) /* Bridge heads are drawn solid no matter how invisibility/transparency is set */ AddSortableSpriteToDraw(psid[0].sprite, psid[0].pal, *ti, {{}, {TILE_SIZE, TILE_SIZE, static_cast(ti->tileh == SLOPE_FLAT ? 0 : TILE_HEIGHT)}, {}}); - if (transport_type == TRANSPORT_ROAD) { + if (transport_type == TransportType::Road) { uint offset = to_underlying(tunnelbridge_direction); int z = ti->z; if (ti->tileh != SLOPE_FLAT) { @@ -1490,7 +1490,7 @@ static void DrawTile_TunnelBridge(TileInfo *ti) DrawBridgeRoadBits(ti->tile, ti->x, ti->y, z, offset, true, is_custom_layout); EndSpriteCombine(); - } else if (transport_type == TRANSPORT_RAIL) { + } else if (transport_type == TransportType::Rail) { const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile)); if (is_custom_layout || rti->UsesOverlay()) { SpriteID surface = rti->UsesOverlay() ? GetCustomRailSprite(rti, ti->tile, RailSpriteType::Bridge) : rti->base_sprites.bridge_deck; @@ -1582,7 +1582,7 @@ static BridgePieces CalcBridgePiece(uint north, uint south) */ static BridgePillarFlags GetBridgeTilePillarFlags(TileIndex tile, TileIndex rampnorth, TileIndex rampsouth, BridgeType type, TransportType transport_type) { - if (transport_type == TRANSPORT_WATER) return BRIDGEPILLARFLAGS_ALL_CORNERS; + if (transport_type == TransportType::Water) return BRIDGEPILLARFLAGS_ALL_CORNERS; const BridgeSpec *spec = GetBridgeSpec(type); if (!spec->ctrl_flags.Test(BridgeSpec::ControlFlag::InvalidPillarFlags)) { @@ -1630,7 +1630,7 @@ void DrawBridgeMiddle(const TileInfo *ti, BridgePillarFlags blocked_pillars) uint base_offset = GetBridgeMiddleAxisBaseOffset(axis); std::span psid; bool drawfarpillar; - if (transport_type != TRANSPORT_WATER) { + if (transport_type != TransportType::Water) { BridgeType bridge_type = GetBridgeType(rampsouth); BridgePieces bridge_piece = CalcBridgePiece(GetTunnelBridgeLength(ti->tile, rampnorth) + 1, GetTunnelBridgeLength(ti->tile, rampsouth) + 1); drawfarpillar = !HasBit(GetBridgeSpec(bridge_type)->flags, 0); @@ -1654,7 +1654,7 @@ void DrawBridgeMiddle(const TileInfo *ti, BridgePillarFlags blocked_pillars) AddSortableSpriteToDraw(SPR_EMPTY_BOUNDING_BOX, PAL_NONE, x, y, bridge_z - TILE_HEIGHT + BB_Z_SEPARATOR, {{}, {TILE_SIZE, TILE_SIZE, 1}, {}}); /* Draw Trambits as SpriteCombine */ - if (transport_type == TRANSPORT_ROAD || transport_type == TRANSPORT_RAIL) StartSpriteCombine(); + if (transport_type == TransportType::Road || transport_type == TransportType::Rail) StartSpriteCombine(); /* Draw floor and far part of bridge*/ if (!IsInvisibilitySet(TransparencyOption::Bridges)) { @@ -1665,10 +1665,10 @@ void DrawBridgeMiddle(const TileInfo *ti, BridgePillarFlags blocked_pillars) } } - if (transport_type == TRANSPORT_ROAD) { + if (transport_type == TransportType::Road) { /* DrawBridgeRoadBits() calls EndSpriteCombine() and StartSpriteCombine() */ DrawBridgeRoadBits(rampsouth, x, y, bridge_z, to_underlying(OtherAxis(axis)), false, is_custom_layout); - } else if (transport_type == TRANSPORT_RAIL) { + } else if (transport_type == TransportType::Rail) { const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(rampsouth)); if ((is_custom_layout || rti->UsesOverlay()) && !IsInvisibilitySet(TransparencyOption::Bridges)) { SpriteID surface = rti->UsesOverlay() ? GetCustomRailSprite(rti, rampsouth, RailSpriteType::Bridge, TCX_ON_BRIDGE) : rti->base_sprites.bridge_deck; @@ -1705,7 +1705,7 @@ void DrawBridgeMiddle(const TileInfo *ti, BridgePillarFlags blocked_pillars) } /* Draw TramFront as SpriteCombine */ - if (transport_type == TRANSPORT_ROAD) EndSpriteCombine(); + if (transport_type == TransportType::Road) EndSpriteCombine(); /* Do not draw anything more if bridges are invisible */ if (IsInvisibilitySet(TransparencyOption::Bridges)) return; @@ -1759,16 +1759,16 @@ static void GetTileDesc_TunnelBridge(TileIndex tile, TileDesc &td) TransportType tt = GetTunnelBridgeTransportType(tile); if (IsTunnel(tile)) { - td.str = (tt == TRANSPORT_RAIL) ? STR_LAI_TUNNEL_DESCRIPTION_RAILROAD : STR_LAI_TUNNEL_DESCRIPTION_ROAD; + td.str = (tt == TransportType::Rail) ? STR_LAI_TUNNEL_DESCRIPTION_RAILROAD : STR_LAI_TUNNEL_DESCRIPTION_ROAD; } else { // IsBridge(tile) - td.str = (tt == TRANSPORT_WATER) ? STR_LAI_BRIDGE_DESCRIPTION_AQUEDUCT : GetBridgeSpec(GetBridgeType(tile))->transport_name[tt]; + td.str = (tt == TransportType::Water) ? STR_LAI_BRIDGE_DESCRIPTION_AQUEDUCT : GetBridgeSpec(GetBridgeType(tile))->transport_name[to_underlying(tt)]; } td.owner[0] = GetTileOwner(tile); Owner road_owner = INVALID_OWNER; Owner tram_owner = INVALID_OWNER; - RoadType road_rt = (tt == TRANSPORT_ROAD) ? GetRoadTypeRoad(tile) : INVALID_ROADTYPE; - RoadType tram_rt = (tt == TRANSPORT_ROAD) ? GetRoadTypeTram(tile) : INVALID_ROADTYPE; + RoadType road_rt = (tt == TransportType::Road) ? GetRoadTypeRoad(tile) : INVALID_ROADTYPE; + RoadType tram_rt = (tt == TransportType::Road) ? GetRoadTypeTram(tile) : INVALID_ROADTYPE; if (road_rt != INVALID_ROADTYPE) { const RoadTypeInfo *rti = GetRoadTypeInfo(road_rt); td.roadtype = rti->strings.name; @@ -1797,7 +1797,7 @@ static void GetTileDesc_TunnelBridge(TileIndex tile, TileDesc &td) } } - if (tt == TRANSPORT_RAIL) { + if (tt == TransportType::Rail) { const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(tile)); td.rail_speed = rti->max_speed; td.railtype = rti->strings.name; @@ -1810,7 +1810,7 @@ static void GetTileDesc_TunnelBridge(TileIndex tile, TileDesc &td) td.rail_speed = spd; } } - } else if (tt == TRANSPORT_ROAD && !IsTunnel(tile)) { + } else if (tt == TransportType::Road && !IsTunnel(tile)) { uint16_t spd = GetBridgeSpec(GetBridgeType(tile))->speed; /* road speed special-cases 0 as unlimited, hides display of limit etc. */ if (spd == UINT16_MAX) spd = 0; @@ -1853,7 +1853,7 @@ static void TileLoop_TunnelBridge(TileIndex tile) 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 {}; + if (transport_type != mode || (transport_type == TransportType::Road && !HasTileRoadType(tile, (RoadTramType)sub_mode))) return {}; DiagDirection dir = GetTunnelBridgeDirection(tile); if (side != DiagDirection::Invalid && side != ReverseDiagDir(dir)) return {}; @@ -1870,7 +1870,7 @@ static void ChangeTileOwner_TunnelBridge(TileIndex tile, Owner old_owner, Owner TransportType tt = GetTunnelBridgeTransportType(tile); - if (tt == TRANSPORT_ROAD) { + if (tt == TransportType::Road) { for (RoadTramType rtt : ROADTRAMTYPES_ALL) { /* Update all roadtypes, no matter if they are present */ if (GetRoadOwner(tile, rtt) == old_owner) { @@ -1892,10 +1892,10 @@ static void ChangeTileOwner_TunnelBridge(TileIndex tile, Owner old_owner, Owner /* Update company infrastructure counts for rail and water as well. * No need to dirty windows here, we'll redraw the whole screen anyway. */ Company *old = Company::Get(old_owner); - if (tt == TRANSPORT_RAIL) { + if (tt == TransportType::Rail) { old->infrastructure.rail[GetRailType(tile)] -= num_pieces; if (new_owner != INVALID_OWNER) Company::Get(new_owner)->infrastructure.rail[GetRailType(tile)] += num_pieces; - } else if (tt == TRANSPORT_WATER) { + } else if (tt == TransportType::Water) { old->infrastructure.water -= num_pieces; if (new_owner != INVALID_OWNER) Company::Get(new_owner)->infrastructure.water += num_pieces; } @@ -1903,7 +1903,7 @@ static void ChangeTileOwner_TunnelBridge(TileIndex tile, Owner old_owner, Owner if (new_owner != INVALID_OWNER) { SetTileOwner(tile, new_owner); } else { - if (tt == TRANSPORT_RAIL) { + if (tt == TransportType::Rail) { /* Since all of our vehicles have been removed, it is safe to remove the rail * bridge / tunnel. */ [[maybe_unused]] CommandCost ret = Command::Do({DoCommandFlag::Execute, DoCommandFlag::Bankrupt}, tile); @@ -2099,7 +2099,7 @@ static VehicleEnterTileStates VehicleEnterTile_TunnelBridge(Vehicle *v, TileInde /** @copydoc TerraformTileProc */ static CommandCost TerraformTile_TunnelBridge(TileIndex tile, DoCommandFlags flags, int z_new, Slope tileh_new) { - if (_settings_game.construction.build_on_slopes && AutoslopeEnabled() && IsBridge(tile) && GetTunnelBridgeTransportType(tile) != TRANSPORT_WATER) { + if (_settings_game.construction.build_on_slopes && AutoslopeEnabled() && IsBridge(tile) && GetTunnelBridgeTransportType(tile) != TransportType::Water) { DiagDirection direction = GetTunnelBridgeDirection(tile); Axis axis = DiagDirToAxis(direction); CommandCost res; diff --git a/src/tunnelbridge_map.h b/src/tunnelbridge_map.h index ebdbbffb18..5170406c41 100644 --- a/src/tunnelbridge_map.h +++ b/src/tunnelbridge_map.h @@ -84,33 +84,33 @@ inline TileIndex GetOtherTunnelBridgeEnd(Tile t) /** * Get the reservation state of the rail tunnel/bridge - * @pre IsTileType(t, TileType::TunnelBridge) && GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL + * @pre IsTileType(t, TileType::TunnelBridge) && GetTunnelBridgeTransportType(t) == TransportType::Rail * @param t the tile * @return reservation state */ inline bool HasTunnelBridgeReservation(Tile t) { assert(IsTileType(t, TileType::TunnelBridge)); - assert(GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL); + assert(GetTunnelBridgeTransportType(t) == TransportType::Rail); return HasBit(t.m5(), 4); } /** * Set the reservation state of the rail tunnel/bridge - * @pre IsTileType(t, TileType::TunnelBridge) && GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL + * @pre IsTileType(t, TileType::TunnelBridge) && GetTunnelBridgeTransportType(t) == TransportType::Rail * @param t the tile * @param b the reservation state */ inline void SetTunnelBridgeReservation(Tile t, bool b) { assert(IsTileType(t, TileType::TunnelBridge)); - assert(GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL); + assert(GetTunnelBridgeTransportType(t) == TransportType::Rail); AssignBit(t.m5(), 4, b); } /** * Get the reserved track bits for a rail tunnel/bridge - * @pre IsTileType(t, TileType::TunnelBridge) && GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL + * @pre IsTileType(t, TileType::TunnelBridge) && GetTunnelBridgeTransportType(t) == TransportType::Rail * @param t the tile * @return reserved track bits */ diff --git a/src/water_cmd.cpp b/src/water_cmd.cpp index a738acb1b9..240cb2d69e 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 TrackdirBitsToTrackBits(GetTileTrackStatus(t, TRANSPORT_WATER, RoadTramType::Invalid).trackdirs).Any(); + return TrackdirBitsToTrackBits(GetTileTrackStatus(t, TransportType::Water, RoadTramType::Invalid).trackdirs).Any(); default: return false; @@ -728,7 +728,7 @@ bool IsWateredTile(TileIndex tile, Direction from) case TileType::Object: return IsTileOnWater(tile); - case TileType::TunnelBridge: return GetTunnelBridgeTransportType(tile) == TRANSPORT_WATER && ReverseDiagDir(GetTunnelBridgeDirection(tile)) == DirToDiagDir(from); + case TileType::TunnelBridge: return GetTunnelBridgeTransportType(tile) == TransportType::Water && ReverseDiagDir(GetTunnelBridgeDirection(tile)) == DirToDiagDir(from); case TileType::Void: return true; // consider map border as water, esp. for rivers @@ -1386,7 +1386,7 @@ static TrackStatus GetTileTrackStatus_Water(TileIndex tile, TransportType mode, TrackBits ts; - if (mode != TRANSPORT_WATER) return {}; + if (mode != TransportType::Water) return {}; switch (GetWaterTileType(tile)) { case WaterTileType::Clear: ts = IsTileFlat(tile) ? TRACK_BIT_ALL : TrackBits{}; break; diff --git a/src/window_type.h b/src/window_type.h index 65056410e1..c4ace37015 100644 --- a/src/window_type.h +++ b/src/window_type.h @@ -82,17 +82,17 @@ enum class WindowClass : uint16_t { /** * Build toolbar; %Window numbers: - * - #TRANSPORT_RAIL = #RailToolbarWidgets - * - #TRANSPORT_AIR = #AirportToolbarWidgets - * - #TRANSPORT_WATER = #DockToolbarWidgets - * - #TRANSPORT_ROAD = #RoadToolbarWidgets + * - #TransportType::Rail = #RailToolbarWidgets + * - #TransportType::Air = #AirportToolbarWidgets + * - #TransportType::Water = #DockToolbarWidgets + * - #TransportType::Road = #RoadToolbarWidgets */ BuildToolbar, /** * Scenario build toolbar; %Window numbers: - * - #TRANSPORT_WATER = #DockToolbarWidgets - * - #TRANSPORT_ROAD = #RoadToolbarWidgets + * - #TransportType::Water = #DockToolbarWidgets + * - #TransportType::Road = #RoadToolbarWidgets */ ScenarioBuildToolbar, @@ -110,7 +110,7 @@ enum class WindowClass : uint16_t { /** * Build signal toolbar; %Window numbers: - * - #TRANSPORT_RAIL = #BuildSignalWidgets + * - #TransportType::Rail = #BuildSignalWidgets */ BuildSignal, @@ -413,35 +413,35 @@ enum class WindowClass : uint16_t { /** * Build station; %Window numbers: - * - #TRANSPORT_AIR = #AirportPickerWidgets - * - #TRANSPORT_WATER = #DockToolbarWidgets - * - #TRANSPORT_RAIL = #BuildRailStationWidgets + * - #TransportType::Air = #AirportPickerWidgets + * - #TransportType::Water = #DockToolbarWidgets + * - #TransportType::Rail = #BuildRailStationWidgets */ BuildStation, /** * Build bus station; %Window numbers: - * - #TRANSPORT_ROAD = #BuildRoadStationWidgets + * - #TransportType::Road = #BuildRoadStationWidgets */ BuildBusStation, /** * Build truck station; %Window numbers: - * - #TRANSPORT_ROAD = #BuildRoadStationWidgets + * - #TransportType::Road = #BuildRoadStationWidgets */ BuildTruckStation, /** * Build depot; %Window numbers: - * - #TRANSPORT_WATER = #BuildDockDepotWidgets - * - #TRANSPORT_RAIL = #BuildRailDepotWidgets - * - #TRANSPORT_ROAD = #BuildRoadDepotWidgets + * - #TransportType::Water = #BuildDockDepotWidgets + * - #TransportType::Rail = #BuildRailDepotWidgets + * - #TransportType::Road = #BuildRoadDepotWidgets */ BuildDepot, /** * Build waypoint; %Window numbers: - * - #TRANSPORT_RAIL = #BuildRailWaypointWidgets + * - #TransportType::Rail = #BuildRailWaypointWidgets */ BuildWaypoint,