From 28cd6a3d336eebe8d0ea7330d46c8f4c2a19d6e8 Mon Sep 17 00:00:00 2001 From: Peter Nelson Date: Sun, 31 May 2026 18:09:26 +0100 Subject: [PATCH] Codechange: make TrackStatus a struct instead of opaque uint32_t (#15653) --- src/disaster_vehicle.cpp | 2 +- src/elrail.cpp | 2 +- src/newgrf_station.cpp | 2 +- src/pathfinder/follow_track.hpp | 4 +-- src/pathfinder/pathfinder_func.h | 6 ++-- src/pathfinder/water_regions.cpp | 2 +- src/pathfinder/yapf/yapf_destrail.hpp | 2 +- src/pathfinder/yapf/yapf_road.cpp | 2 +- src/pathfinder/yapf/yapf_ship.cpp | 4 +-- src/pbs.cpp | 4 +-- src/rail_cmd.cpp | 8 ++--- src/rail_gui.cpp | 2 +- src/road_cmd.cpp | 2 +- src/roadveh.h | 2 +- src/roadveh_cmd.cpp | 34 +++++++++---------- src/saveload/afterload.cpp | 6 ++-- src/script/api/script_marine.cpp | 4 +-- src/script/api/script_tile.cpp | 6 ++-- src/ship_cmd.cpp | 4 +-- src/signal.cpp | 4 +-- src/station_cmd.cpp | 2 +- src/track_func.h | 47 --------------------------- src/track_type.h | 6 +++- src/train_cmd.cpp | 16 ++++----- src/tunnelbridge_cmd.cpp | 6 ++-- src/water_cmd.cpp | 8 ++--- 26 files changed, 70 insertions(+), 117 deletions(-) diff --git a/src/disaster_vehicle.cpp b/src/disaster_vehicle.cpp index b17fe6027a..f6169cb8e6 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 = TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid)); + TrackBits trackbits = TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_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/elrail.cpp b/src/elrail.cpp index 79b3282c71..dead4b87b7 100644 --- a/src/elrail.cpp +++ b/src/elrail.cpp @@ -141,7 +141,7 @@ static TrackBits MaskWireBits(TileIndex t, TrackBits tracks) TileIndex next_tile = TileAddByDiagDir(t, d); RailType rt = GetTileRailType(next_tile); if (rt == INVALID_RAILTYPE || !HasRailCatenary(rt) || - ((TrackStatusToTrackBits(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, RoadTramType::Invalid)) & DiagdirReachesTracks(d)) == TRACK_BIT_NONE && + ((TrackdirBitsToTrackBits(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs) & DiagdirReachesTracks(d)) == TRACK_BIT_NONE && (!HasStationTileRail(next_tile) || GetRailStationAxis(next_tile) != DiagDirToAxis(d) || !CanStationTileHaveWires(next_tile)))) { neighbour_tdb |= DiagdirReachesTrackdirs(ReverseDiagDir(d)); } diff --git a/src/newgrf_station.cpp b/src/newgrf_station.cpp index 322550276b..21c18b20df 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 = TrackStatusToTrackBits(GetTileTrackStatus(neighbour_tile, TRANSPORT_RAIL, RoadTramType::Invalid)); + TrackBits trackbits = TrackdirBitsToTrackBits(GetTileTrackStatus(neighbour_tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs); if (trackbits != TRACK_BIT_NONE) { /* If there is any track on the tile, set the bit in the second byte */ SetBit(res, i + 8); diff --git a/src/pathfinder/follow_track.hpp b/src/pathfinder/follow_track.hpp index e5f30723b2..36c80a7576 100644 --- a/src/pathfinder/follow_track.hpp +++ b/src/pathfinder/follow_track.hpp @@ -133,7 +133,7 @@ struct CFollowTrackT { assert([&]() { if (this->IsTram() && this->GetSingleTramBit(this->old_tile) != DiagDirection::Invalid) return true; // Skip the check for single tram bits const RoadTramType sub_mode = (IsRoadTT() && this->veh != nullptr) ? (this->IsTram() ? RoadTramType::Tram : RoadTramType::Road) : RoadTramType::Invalid; - const TrackdirBits old_tile_valid_dirs = TrackStatusToTrackdirBits(GetTileTrackStatus(this->old_tile, TT(), sub_mode)); + const TrackdirBits old_tile_valid_dirs = GetTileTrackStatus(this->old_tile, TT(), sub_mode).trackdirs; return (old_tile_valid_dirs & TrackdirToTrackdirBits(this->old_td)) != TRACKDIR_BIT_NONE; }()); @@ -253,7 +253,7 @@ protected: } else if (IsRoadTT()) { this->new_td_bits = GetTrackdirBitsForRoad(this->new_tile, this->IsTram() ? RoadTramType::Tram : RoadTramType::Road); } else { - this->new_td_bits = TrackStatusToTrackdirBits(GetTileTrackStatus(this->new_tile, TT(), RoadTramType::Invalid)); + this->new_td_bits = GetTileTrackStatus(this->new_tile, TT(), RoadTramType::Invalid).trackdirs; } return (this->new_td_bits != TRACKDIR_BIT_NONE); } diff --git a/src/pathfinder/pathfinder_func.h b/src/pathfinder/pathfinder_func.h index 51ce6da478..28bbe08d46 100644 --- a/src/pathfinder/pathfinder_func.h +++ b/src/pathfinder/pathfinder_func.h @@ -47,8 +47,8 @@ inline TileIndex CalcClosestStationTile(StationID station, TileIndex tile, Stati } /** - * Wrapper around GetTileTrackStatus() and TrackStatusToTrackdirBits(), as for - * single tram bits GetTileTrackStatus() returns 0. The reason for this is + * Wrapper around GetTileTrackStatus(), as for single tram bits + * GetTileTrackStatus() returns 0. The reason for this is * that there are no half-tile TrackBits in OpenTTD. * This tile, however, is a valid tile for trams, one on which they can * reverse safely. To "fix" this, pretend that if we are on a half-tile, we @@ -61,7 +61,7 @@ inline TileIndex CalcClosestStationTile(StationID station, TileIndex tile, Stati */ inline TrackdirBits GetTrackdirBitsForRoad(TileIndex tile, RoadTramType rtt) { - TrackdirBits bits = TrackStatusToTrackdirBits(GetTileTrackStatus(tile, TRANSPORT_ROAD, rtt)); + TrackdirBits bits = GetTileTrackStatus(tile, TRANSPORT_ROAD, rtt).trackdirs; if (rtt == RoadTramType::Tram && bits == TRACKDIR_BIT_NONE) { if (IsNormalRoadTile(tile)) { diff --git a/src/pathfinder/water_regions.cpp b/src/pathfinder/water_regions.cpp index c39d999098..e30b9210d0 100644 --- a/src/pathfinder/water_regions.cpp +++ b/src/pathfinder/water_regions.cpp @@ -28,7 +28,7 @@ constexpr WaterRegionPatchLabel FIRST_REGION_LABEL{1}; static_assert(sizeof(WaterRegionTraversabilityBits) * 8 == WATER_REGION_EDGE_LENGTH); static_assert(sizeof(WaterRegionPatchLabel) == sizeof(uint8_t)); // Important for the hash calculation. -static inline TrackBits GetWaterTracks(TileIndex tile) { return TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid)); } +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 int GetWaterRegionX(TileIndex tile) { return TileX(tile) / WATER_REGION_EDGE_LENGTH; } diff --git a/src/pathfinder/yapf/yapf_destrail.hpp b/src/pathfinder/yapf/yapf_destrail.hpp index 6f9caba4ed..49d8840f42 100644 --- a/src/pathfinder/yapf/yapf_destrail.hpp +++ b/src/pathfinder/yapf/yapf_destrail.hpp @@ -154,7 +154,7 @@ public: default: this->dest_tile = v->dest_tile == INVALID_TILE ? TileIndex{} : v->dest_tile; this->dest_station_id = StationID::Invalid(); - this->dest_trackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(this->dest_tile, TRANSPORT_RAIL, RoadTramType::Invalid)); + this->dest_trackdirs = GetTileTrackStatus(this->dest_tile, TRANSPORT_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 059a2e8fc4..e361252682 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 = TrackStatusToTrackdirBits(GetTileTrackStatus(this->dest_tile, TRANSPORT_ROAD, GetRoadTramType(v->roadtype))); + this->dest_trackdirs = GetTileTrackStatus(this->dest_tile, TRANSPORT_ROAD, GetRoadTramType(v->roadtype)).trackdirs; } } diff --git a/src/pathfinder/yapf/yapf_ship.cpp b/src/pathfinder/yapf/yapf_ship.cpp index 60aa0bcabe..01413068e6 100644 --- a/src/pathfinder/yapf/yapf_ship.cpp +++ b/src/pathfinder/yapf/yapf_ship.cpp @@ -50,7 +50,7 @@ public: } else { this->dest_station = StationID::Invalid(); this->dest_tile = v->dest_tile == INVALID_TILE ? TileIndex{} : v->dest_tile; - this->dest_trackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(this->dest_tile, TRANSPORT_WATER, RoadTramType::Invalid)); + this->dest_trackdirs = GetTileTrackStatus(this->dest_tile, TRANSPORT_WATER, RoadTramType::Invalid).trackdirs; } } @@ -313,7 +313,7 @@ public: } else { /* This gets called when a ship suddenly can't move forward, e.g. due to terraforming. */ const DiagDirection entry = ReverseDiagDir(VehicleExitDir(v->direction, v->state)); - const TrackdirBits reverse_dirs = DiagdirReachesTrackdirs(entry) & TrackStatusToTrackdirBits(GetTileTrackStatus(v->tile, TRANSPORT_WATER, RoadTramType::Invalid, entry)); + const TrackdirBits reverse_dirs = DiagdirReachesTrackdirs(entry) & GetTileTrackStatus(v->tile, TRANSPORT_WATER, RoadTramType::Invalid, entry).trackdirs; (void)ChooseShipTrack(v, v->tile, TRACKDIR_BIT_NONE, reverse_dirs, path_found, dummy_cache, best_origin_dir); *trackdir = path_found && best_origin_dir != INVALID_TRACKDIR ? best_origin_dir : GetRandomTrackdir(reverse_dirs); return true; diff --git a/src/pbs.cpp b/src/pbs.cpp index 3184b84c8e..91f30cc2d7 100644 --- a/src/pbs.cpp +++ b/src/pbs.cpp @@ -79,7 +79,7 @@ void SetRailStationPlatformReservation(TileIndex start, DiagDirection dir, bool */ bool TryReserveRailTrack(TileIndex tile, Track t, bool trigger_stations) { - assert(HasTrack(TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid)), t)); + assert(HasTrack(TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs), t)); if (_settings_client.gui.show_track_reservation) { /* show the reserved rail if needed */ @@ -143,7 +143,7 @@ bool TryReserveRailTrack(TileIndex tile, Track t, bool trigger_stations) */ void UnreserveRailTrack(TileIndex tile, Track t) { - assert(HasTrack(TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid)), t)); + assert(HasTrack(TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs), t)); if (_settings_client.gui.show_track_reservation) { if (IsBridgeTile(tile)) { diff --git a/src/rail_cmd.cpp b/src/rail_cmd.cpp index 57f576a753..51e4776d01 100644 --- a/src/rail_cmd.cpp +++ b/src/rail_cmd.cpp @@ -1200,7 +1200,7 @@ static bool AdvanceSignalAutoFill(TileIndex &tile, Trackdir &trackdir, bool remo if (tile == INVALID_TILE) return false; /* Check for track bits on the new tile */ - TrackdirBits trackdirbits = TrackStatusToTrackdirBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid)); + TrackdirBits trackdirbits = GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs; if (TracksOverlap(TrackdirBitsToTrackBits(trackdirbits))) return false; trackdirbits &= TrackdirReachesTrackdirs(trackdir); @@ -2760,10 +2760,10 @@ static TrackStatus GetTileTrackStatus_Rail(TileIndex tile, TransportType mode, [ case TRACK_BIT_LEFT: tb = TRACK_BIT_RIGHT; break; case TRACK_BIT_RIGHT: tb = TRACK_BIT_LEFT; break; } - return CombineTrackStatus(TrackBitsToTrackdirBits(tb), TRACKDIR_BIT_NONE); + return {TrackBitsToTrackdirBits(tb), TRACKDIR_BIT_NONE}; } - if (mode != TRANSPORT_RAIL) return 0; + if (mode != TRANSPORT_RAIL) return {}; TrackBits trackbits = TRACK_BIT_NONE; TrackdirBits red_signals = TRACKDIR_BIT_NONE; @@ -2807,7 +2807,7 @@ static TrackStatus GetTileTrackStatus_Rail(TileIndex tile, TransportType mode, [ } } - return CombineTrackStatus(TrackBitsToTrackdirBits(trackbits), red_signals); + return {TrackBitsToTrackdirBits(trackbits), red_signals}; } /** @copydoc ClickTileProc */ diff --git a/src/rail_gui.cpp b/src/rail_gui.cpp index f0b7f803b3..7b78a33b74 100644 --- a/src/rail_gui.cpp +++ b/src/rail_gui.cpp @@ -237,7 +237,7 @@ static void PlaceRail_Station(TileIndex tile) */ static void GenericPlaceSignals(TileIndex tile) { - TrackBits trackbits = TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid)); + TrackBits trackbits = TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs); if (trackbits & TRACK_BIT_VERT) { // N-S direction trackbits = (_tile_fract_coords.x <= _tile_fract_coords.y) ? TRACK_BIT_RIGHT : TRACK_BIT_LEFT; diff --git a/src/road_cmd.cpp b/src/road_cmd.cpp index e8e1e55687..d08a2ea7aa 100644 --- a/src/road_cmd.cpp +++ b/src/road_cmd.cpp @@ -2201,7 +2201,7 @@ static TrackStatus GetTileTrackStatus_Road(TileIndex tile, TransportType mode, R default: break; } - return CombineTrackStatus(trackdirbits, red_signals); + return {trackdirbits, red_signals}; } static const StringID _road_tile_strings[] = { diff --git a/src/roadveh.h b/src/roadveh.h index df10463db6..1472e0ce12 100644 --- a/src/roadveh.h +++ b/src/roadveh.h @@ -288,7 +288,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)); - TrackBits trackbits = TrackStatusToTrackBits(ts); + TrackBits trackbits = TrackdirBitsToTrackBits(ts.trackdirs); return trackbits == TRACK_BIT_X || trackbits == TRACK_BIT_Y; } diff --git a/src/roadveh_cmd.cpp b/src/roadveh_cmd.cpp index 799c3f121a..6a0d8e69e1 100644 --- a/src/roadveh_cmd.cpp +++ b/src/roadveh_cmd.cpp @@ -793,12 +793,10 @@ 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)); - TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts); - TrackdirBits red_signals = TrackStatusToRedSignals(ts); // barred level crossing - TrackBits trackbits = TrackdirBitsToTrackBits(trackdirbits); + TrackBits trackbits = TrackdirBitsToTrackBits(ts.trackdirs); /* Track does not continue along overtaking direction || track has junction || levelcrossing is barred */ - if (!HasBit(trackdirbits, od->trackdir) || (trackbits & ~TRACK_BIT_CROSS) || (red_signals != TRACKDIR_BIT_NONE)) return true; + if (!HasBit(ts.trackdirs, od->trackdir) || (trackbits & ~TRACK_BIT_CROSS) || (ts.signals != TRACKDIR_BIT_NONE)) return true; /* Are there more vehicles on the tile except the two vehicles involved in overtaking */ return HasVehicleOnTile(od->tile, [&](const Vehicle *v) { @@ -892,39 +890,37 @@ static Trackdir RoadFindPathToDest(RoadVehicle *v, TileIndex tile, DiagDirection bool path_found = true; TrackStatus ts = GetTileTrackStatus(tile, TRANSPORT_ROAD, GetRoadTramType(v->roadtype)); - TrackdirBits red_signals = TrackStatusToRedSignals(ts); // crossing - TrackdirBits trackdirs = TrackStatusToTrackdirBits(ts); /* Replaces the given track with INVALID_TRACK when there is red signal for that track. */ - auto FilterRedSignal = [&red_signals](auto track) { - if (HasBit(red_signals, track)) return INVALID_TRACKDIR; + auto FilterRedSignal = [&ts](auto track) { + if (HasBit(ts.signals, track)) return INVALID_TRACKDIR; return static_cast(track); }; if (IsTileType(tile, TileType::Road)) { if (IsRoadDepot(tile) && (!IsTileOwner(tile, v->owner) || GetRoadDepotDirection(tile) == enterdir)) { /* Road depot owned by another company or with the wrong orientation */ - trackdirs = TRACKDIR_BIT_NONE; + ts.trackdirs = TRACKDIR_BIT_NONE; } } else if (IsTileType(tile, TileType::Station) && IsBayRoadStopTile(tile)) { /* Standard road stop (drive-through stops are treated as normal road) */ if (!IsTileOwner(tile, v->owner) || GetBayRoadStopDir(tile) == enterdir || v->HasArticulatedPart()) { /* different station owner or wrong orientation or the vehicle has articulated parts */ - trackdirs = TRACKDIR_BIT_NONE; + ts.trackdirs = TRACKDIR_BIT_NONE; } else { /* Our station */ RoadStopType rstype = v->IsBus() ? RoadStopType::Bus : RoadStopType::Truck; if (GetRoadStopType(tile) != rstype) { /* Wrong station type */ - trackdirs = TRACKDIR_BIT_NONE; + ts.trackdirs = TRACKDIR_BIT_NONE; } else { /* Proper station type, check if there is free loading bay */ if (!_settings_game.pf.roadveh_queue && IsBayRoadStopTile(tile) && !RoadStop::GetByTile(tile, rstype)->HasFreeBay()) { /* Station is full and RV queuing is off */ - trackdirs = TRACKDIR_BIT_NONE; + ts.trackdirs = TRACKDIR_BIT_NONE; } } } @@ -935,8 +931,8 @@ static Trackdir RoadFindPathToDest(RoadVehicle *v, TileIndex tile, DiagDirection */ /* Remove tracks unreachable from the enter dir */ - trackdirs &= DiagdirReachesTrackdirs(enterdir); - if (trackdirs == TRACKDIR_BIT_NONE) { + ts.trackdirs &= DiagdirReachesTrackdirs(enterdir); + if (ts.trackdirs == TRACKDIR_BIT_NONE) { /* If vehicle expected a path, it no longer exists, so invalidate it. */ if (!v->path.empty()) v->path.clear(); /* No reachable tracks, so we'll reverse */ @@ -963,16 +959,16 @@ static Trackdir RoadFindPathToDest(RoadVehicle *v, TileIndex tile, DiagDirection if (v->dest_tile == INVALID_TILE) { /* We've got no destination, pick a random track */ - return FilterRedSignal(PickRandomBit(trackdirs)); + return FilterRedSignal(PickRandomBit(ts.trackdirs)); } /* Only one track to choose between? */ - if (KillFirstBit(trackdirs) == TRACKDIR_BIT_NONE) { + if (KillFirstBit(ts.trackdirs) == TRACKDIR_BIT_NONE) { if (!v->path.empty() && v->path.back().tile == tile) { /* Vehicle expected a choice here, invalidate its path. */ v->path.clear(); } - return FilterRedSignal(FindFirstBit(trackdirs)); + return FilterRedSignal(FindFirstBit(ts.trackdirs)); } /* Attempt to follow cached path. */ @@ -983,7 +979,7 @@ static Trackdir RoadFindPathToDest(RoadVehicle *v, TileIndex tile, DiagDirection } else { Trackdir trackdir = v->path.back().trackdir; - if (HasBit(trackdirs, trackdir)) { + if (HasBit(ts.trackdirs, trackdir)) { v->path.pop_back(); return FilterRedSignal(trackdir); } @@ -993,7 +989,7 @@ static Trackdir RoadFindPathToDest(RoadVehicle *v, TileIndex tile, DiagDirection } } - Trackdir best_track = YapfRoadVehicleChooseTrack(v, tile, enterdir, trackdirs, path_found, v->path); + Trackdir best_track = YapfRoadVehicleChooseTrack(v, tile, enterdir, ts.trackdirs, path_found, v->path); v->HandlePathfindingResult(path_found); diff --git a/src/saveload/afterload.cpp b/src/saveload/afterload.cpp index 97def66fa5..94f0f9aebe 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 = DiagDirection::Begin; dd < DiagDirection::End; dd++) { TileIndex tt{t + TileOffsByDiagDir(dd)}; - if (GetTileTrackStatus(t, TRANSPORT_RAIL, RoadTramType::Invalid, dd) != 0 && - GetTileTrackStatus(tt, TRANSPORT_RAIL, RoadTramType::Invalid, ReverseDiagDir(dd)) != 0 && + if (GetTileTrackStatus(t, TRANSPORT_RAIL, RoadTramType::Invalid, dd).trackdirs != TRACKDIR_BIT_NONE && + GetTileTrackStatus(tt, TRANSPORT_RAIL, RoadTramType::Invalid, ReverseDiagDir(dd)).trackdirs != TRACKDIR_BIT_NONE && Company::IsValidID(GetTileOwner(tt))) { SetTileOwner(t, GetTileOwner(tt)); return; @@ -2773,7 +2773,7 @@ bool AfterLoadGame() if (rv->state == RVSB_IN_DEPOT || rv->state == RVSB_WORMHOLE) break; TrackStatus ts = GetTileTrackStatus(rv->tile, TRANSPORT_ROAD, GetRoadTramType(rv->roadtype)); - TrackBits trackbits = TrackStatusToTrackBits(ts); + TrackBits trackbits = TrackdirBitsToTrackBits(ts.trackdirs); /* Only X/Y tracks can be sloped. */ if (trackbits != TRACK_BIT_X && trackbits != TRACK_BIT_Y) break; diff --git a/src/script/api/script_marine.cpp b/src/script/api/script_marine.cpp index 2dc69a8a55..5251f3a770 100644 --- a/src/script/api/script_marine.cpp +++ b/src/script/api/script_marine.cpp @@ -67,11 +67,11 @@ DiagDirection to_other_tile = ::DiagdirBetweenTiles(t2, t1); /* Determine the reachable tracks from the shared edge */ - TrackBits gtts1 = ::TrackStatusToTrackBits(::GetTileTrackStatus(t1, TRANSPORT_WATER, RoadTramType::Invalid, ReverseDiagDir(to_other_tile))) & ::DiagdirReachesTracks(to_other_tile); + TrackBits gtts1 = ::TrackdirBitsToTrackBits(::GetTileTrackStatus(t1, TRANSPORT_WATER, RoadTramType::Invalid, ReverseDiagDir(to_other_tile)).trackdirs) & ::DiagdirReachesTracks(to_other_tile); if (gtts1 == TRACK_BIT_NONE) return false; to_other_tile = ReverseDiagDir(to_other_tile); - TrackBits gtts2 = ::TrackStatusToTrackBits(::GetTileTrackStatus(t2, TRANSPORT_WATER, RoadTramType::Invalid, ReverseDiagDir(to_other_tile))) & ::DiagdirReachesTracks(to_other_tile); + TrackBits gtts2 = ::TrackdirBitsToTrackBits(::GetTileTrackStatus(t2, TRANSPORT_WATER, RoadTramType::Invalid, ReverseDiagDir(to_other_tile)).trackdirs) & ::DiagdirReachesTracks(to_other_tile); return gtts2 != TRACK_BIT_NONE; } diff --git a/src/script/api/script_tile.cpp b/src/script/api/script_tile.cpp index 90f9ad9863..b66a790caf 100644 --- a/src/script/api/script_tile.cpp +++ b/src/script/api/script_tile.cpp @@ -219,10 +219,10 @@ if (!::IsValidTile(tile)) return false; if (transport_type == TRANSPORT_ROAD) { - return ::TrackStatusToTrackdirBits(::GetTileTrackStatus(tile, (::TransportType)transport_type, ::RoadTramType::Road)) != TRACKDIR_BIT_NONE || - ::TrackStatusToTrackdirBits(::GetTileTrackStatus(tile, (::TransportType)transport_type, ::RoadTramType::Tram)) != TRACKDIR_BIT_NONE; + return ::GetTileTrackStatus(tile, (::TransportType)transport_type, ::RoadTramType::Road).trackdirs != TRACKDIR_BIT_NONE || + ::GetTileTrackStatus(tile, (::TransportType)transport_type, ::RoadTramType::Tram).trackdirs != TRACKDIR_BIT_NONE; } else { - return ::TrackStatusToTrackdirBits(::GetTileTrackStatus(tile, (::TransportType)transport_type, ::RoadTramType::Invalid)) != TRACKDIR_BIT_NONE; + return ::GetTileTrackStatus(tile, (::TransportType)transport_type, ::RoadTramType::Invalid).trackdirs != TRACKDIR_BIT_NONE; } } diff --git a/src/ship_cmd.cpp b/src/ship_cmd.cpp index 975d2cd0c1..b0bdc9502d 100644 --- a/src/ship_cmd.cpp +++ b/src/ship_cmd.cpp @@ -75,7 +75,7 @@ bool IsValidImageIndex(uint8_t image_index) static inline TrackBits GetTileShipTrackStatus(TileIndex tile) { - return TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid)); + return TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_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 (TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid, exitdir)) == TRACK_BIT_NONE) return ReverseShip(v); + if (TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, RoadTramType::Invalid, exitdir).trackdirs) == TRACK_BIT_NONE) return ReverseShip(v); } else if (v->dest_tile != INVALID_TILE) { /* We have a target, let's see if we reached it... */ if (v->current_order.IsType(OT_GOTO_WAYPOINT) && diff --git a/src/signal.cpp b/src/signal.cpp index ba9e3b9998..ae3693a80e 100644 --- a/src/signal.cpp +++ b/src/signal.cpp @@ -522,7 +522,7 @@ static SigSegState UpdateSignalsInBuffer(Owner owner) case TileType::Station: case TileType::Road: - if ((TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid)) & _enterdir_to_trackbits[dir]) != TRACK_BIT_NONE) { + if ((TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs) & _enterdir_to_trackbits[dir]) != TRACK_BIT_NONE) { /* only add to set when there is some 'interesting' track */ _tbdset.Add(tile, dir); _tbdset.Add(tile + TileOffsByDiagDir(dir), ReverseDiagDir(dir)); @@ -534,7 +534,7 @@ static SigSegState UpdateSignalsInBuffer(Owner owner) /* jump to next tile */ tile = tile + TileOffsByDiagDir(dir); dir = ReverseDiagDir(dir); - if ((TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid)) & _enterdir_to_trackbits[dir]) != TRACK_BIT_NONE) { + if ((TrackdirBitsToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs) & _enterdir_to_trackbits[dir]) != TRACK_BIT_NONE) { _tbdset.Add(tile, dir); break; } diff --git a/src/station_cmd.cpp b/src/station_cmd.cpp index 5ca6d3a6c5..1a6c6272c6 100644 --- a/src/station_cmd.cpp +++ b/src/station_cmd.cpp @@ -3734,7 +3734,7 @@ static TrackStatus GetTileTrackStatus_Station(TileIndex tile, TransportType mode break; } - return CombineTrackStatus(TrackBitsToTrackdirBits(trackbits), TRACKDIR_BIT_NONE); + return {TrackBitsToTrackdirBits(trackbits), TRACKDIR_BIT_NONE}; } diff --git a/src/track_func.h b/src/track_func.h index d0ccdf5594..c9ea2bd793 100644 --- a/src/track_func.h +++ b/src/track_func.h @@ -345,53 +345,6 @@ inline bool HasTrackdir(TrackdirBits trackdirs, Trackdir trackdir) return HasBit(trackdirs, trackdir); } -/** - * Returns the present-trackdir-information of a TrackStatus. - * - * @param ts The TrackStatus returned by GetTileTrackStatus() - * @return the present trackdirs - */ -inline TrackdirBits TrackStatusToTrackdirBits(TrackStatus ts) -{ - return static_cast(ts & TRACKDIR_BIT_MASK); -} - -/** - * Returns the present-track-information of a TrackStatus. - * - * @param ts The TrackStatus returned by GetTileTrackStatus() - * @return the present tracks - */ -inline TrackBits TrackStatusToTrackBits(TrackStatus ts) -{ - return TrackdirBitsToTrackBits(TrackStatusToTrackdirBits(ts)); -} - -/** - * Returns the red-signal-information of a TrackStatus. - * - * Note: The result may contain red signals for non-present tracks. - * - * @param ts The TrackStatus returned by GetTileTrackStatus() - * @return the The trackdirs that are blocked by red-signals - */ -inline TrackdirBits TrackStatusToRedSignals(TrackStatus ts) -{ - return static_cast((ts >> 16) & TRACKDIR_BIT_MASK); -} - -/** - * Builds a TrackStatus - * - * @param trackdirbits present trackdirs - * @param red_signals red signals - * @return the TrackStatus representing the given information - */ -inline TrackStatus CombineTrackStatus(TrackdirBits trackdirbits, TrackdirBits red_signals) -{ - return (TrackStatus)(trackdirbits | (red_signals << 16)); -} - /** * Maps a trackdir to the trackdir that you will end up on if you go straight * ahead. diff --git a/src/track_type.h b/src/track_type.h index 9576c0cec2..72a316ea9d 100644 --- a/src/track_type.h +++ b/src/track_type.h @@ -128,6 +128,10 @@ enum TrackdirBits : uint16_t { }; DECLARE_ENUM_AS_BIT_SET(TrackdirBits) -typedef uint32_t TrackStatus; +/** Track status of a tile. */ +struct TrackStatus { + TrackdirBits trackdirs; ///< Trackdirs present on the tile. + TrackdirBits signals; ///< Red signals on the tile. +}; #endif /* TRACK_TYPE_H */ diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp index 6ffacf35c3..295d7bc216 100644 --- a/src/train_cmd.cpp +++ b/src/train_cmd.cpp @@ -2883,8 +2883,8 @@ static Track ChooseTrainTrack(Train *consist, TileIndex tile, DiagDirection ente while (!IsSafeWaitingPosition(consist, res_dest.tile, res_dest.trackdir, true, _settings_game.pf.forbid_90_deg)) { /* 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 = TrackStatusToTrackBits(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, RoadTramType::Invalid)) & DiagdirReachesTracks(exitdir); + TileIndex next_tile = TileAddByDiagDir(res_dest.tile, exitdir); + TrackBits reachable = TrackdirBitsToTrackBits(GetTileTrackStatus(next_tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs) & DiagdirReachesTracks(exitdir); if (Rail90DegTurnDisallowed(GetTileRailType(res_dest.tile), GetTileRailType(next_tile))) { reachable &= ~TrackCrossesTracks(TrackdirToTrack(res_dest.trackdir)); } @@ -2985,8 +2985,8 @@ 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(TrackStatusToTrackdirBits(GetTileTrackStatus(new_tile, TRANSPORT_RAIL, RoadTramType::Invalid)) & DiagdirReachesTrackdirs(exitdir)); + TileIndex new_tile = TileAddByDiagDir(origin.tile, exitdir); + TrackBits reachable = TrackdirBitsToTrackBits(GetTileTrackStatus(new_tile, TRANSPORT_RAIL, RoadTramType::Invalid).trackdirs & DiagdirReachesTrackdirs(exitdir)); if (Rail90DegTurnDisallowed(GetTileRailType(origin.tile), GetTileRailType(new_tile))) reachable &= ~TrackCrossesTracks(TrackdirToTrack(origin.trackdir)); @@ -3392,8 +3392,8 @@ bool TrainController(Train *v, Vehicle *nomove, bool reverse) TrackStatus ts = GetTileTrackStatus(gp.new_tile, TRANSPORT_RAIL, RoadTramType::Invalid, ReverseDiagDir(enterdir)); TrackdirBits reachable_trackdirs = DiagdirReachesTrackdirs(enterdir); - TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts) & reachable_trackdirs; - TrackBits red_signals = TrackdirBitsToTrackBits(TrackStatusToRedSignals(ts) & reachable_trackdirs); + TrackdirBits trackdirbits = ts.trackdirs & reachable_trackdirs; + TrackBits red_signals = TrackdirBitsToTrackBits(ts.signals & reachable_trackdirs); TrackBits bits = TrackdirBitsToTrackBits(trackdirbits); if (Rail90DegTurnDisallowed(GetTileRailType(gp.old_tile), GetTileRailType(gp.new_tile)) && prev == nullptr) { @@ -3971,8 +3971,8 @@ static bool TrainCheckIfLineEnds(Train *moving_front, bool reverse) TrackStatus ts = GetTileTrackStatus(tile, TRANSPORT_RAIL, RoadTramType::Invalid, ReverseDiagDir(dir)); TrackdirBits reachable_trackdirs = DiagdirReachesTrackdirs(dir); - TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts) & reachable_trackdirs; - TrackdirBits red_signals = TrackStatusToRedSignals(ts) & reachable_trackdirs; + TrackdirBits trackdirbits = ts.trackdirs & reachable_trackdirs; + TrackdirBits red_signals = ts.signals & reachable_trackdirs; /* We are sure the train is not entering a depot, it is detected above */ diff --git a/src/tunnelbridge_cmd.cpp b/src/tunnelbridge_cmd.cpp index 27b004c4da..28545a87ef 100644 --- a/src/tunnelbridge_cmd.cpp +++ b/src/tunnelbridge_cmd.cpp @@ -1853,11 +1853,11 @@ 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 0; + if (transport_type != mode || (transport_type == TRANSPORT_ROAD && !HasTileRoadType(tile, (RoadTramType)sub_mode))) return {}; DiagDirection dir = GetTunnelBridgeDirection(tile); - if (side != DiagDirection::Invalid && side != ReverseDiagDir(dir)) return 0; - return CombineTrackStatus(TrackBitsToTrackdirBits(DiagDirToDiagTrackBits(dir)), TRACKDIR_BIT_NONE); + if (side != DiagDirection::Invalid && side != ReverseDiagDir(dir)) return {}; + return {TrackBitsToTrackdirBits(DiagDirToDiagTrackBits(dir)), TRACKDIR_BIT_NONE}; } /** @copydoc ChangeTileOwnerProc */ diff --git a/src/water_cmd.cpp b/src/water_cmd.cpp index 375e3b3b1e..325561c1fd 100644 --- a/src/water_cmd.cpp +++ b/src/water_cmd.cpp @@ -186,7 +186,7 @@ bool IsPossibleDockingTile(Tile t) case TileType::Railway: case TileType::Station: case TileType::TunnelBridge: - return TrackStatusToTrackBits(GetTileTrackStatus(t, TRANSPORT_WATER, RoadTramType::Invalid)) != TRACK_BIT_NONE; + return TrackdirBitsToTrackBits(GetTileTrackStatus(t, TRANSPORT_WATER, RoadTramType::Invalid).trackdirs) != TRACK_BIT_NONE; default: return false; @@ -1387,14 +1387,14 @@ static TrackStatus GetTileTrackStatus_Water(TileIndex tile, TransportType mode, TrackBits ts; - if (mode != TRANSPORT_WATER) return 0; + if (mode != TRANSPORT_WATER) return {}; switch (GetWaterTileType(tile)) { case WaterTileType::Clear: ts = IsTileFlat(tile) ? TRACK_BIT_ALL : TRACK_BIT_NONE; break; case WaterTileType::Coast: ts = coast_tracks[GetTileSlope(tile) & 0xF]; break; case WaterTileType::Lock: ts = DiagDirToDiagTrackBits(GetLockDirection(tile)); break; case WaterTileType::Depot: ts = AxisToTrackBits(GetShipDepotAxis(tile)); break; - default: return 0; + default: return {}; } if (TileX(tile) == 0) { /* NE border: remove tracks that connects NE tile edge */ @@ -1404,7 +1404,7 @@ static TrackStatus GetTileTrackStatus_Water(TileIndex tile, TransportType mode, /* NW border: remove tracks that connects NW tile edge */ ts &= ~(TRACK_BIT_Y | TRACK_BIT_LEFT | TRACK_BIT_UPPER); } - return CombineTrackStatus(TrackBitsToTrackdirBits(ts), TRACKDIR_BIT_NONE); + return {TrackBitsToTrackdirBits(ts), TRACKDIR_BIT_NONE}; } /** @copydoc ClickTileProc */