amacocian/OpenTTD
1
0
Fork 0
mirror of https://github.com/OpenTTD/OpenTTD.git synced 2026-07-24 03:56:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Codechange: make TrackStatus a struct instead of opaque uint32_t (#15653)

Browse Source
This commit is contained in:
Peter Nelson
2026-05-31 18:09:26 +01:00
committed by GitHub
parent a687f02e87
commit 28cd6a3d33
26 changed files with 70 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/disaster_vehicle.cpp
+1 -1
View File
@@ -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);
src/elrail.cpp
+1 -1
View File
@@ -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));
}
src/newgrf_station.cpp
+1 -1
View File
@@ -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);
src/pathfinder/follow_track.hpp
+2 -2
View File
@@ -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);
}
src/pathfinder/pathfinder_func.h
+3 -3
View File
@@ -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)) {
src/pathfinder/water_regions.cpp
+1 -1
View File
@@ -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; }
src/pathfinder/yapf/yapf_destrail.hpp
+1 -1
View File
@@ -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);
src/pathfinder/yapf/yapf_road.cpp
+1 -1
View File
@@ -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;
}
}
src/pathfinder/yapf/yapf_ship.cpp
+2 -2
View File
@@ -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;
src/pbs.cpp
+2 -2
View File
@@ -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)) {
src/rail_cmd.cpp
+4 -4
View File
@@ -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 */
src/rail_gui.cpp
+1 -1
View File
@@ -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;
src/road_cmd.cpp
+1 -1
View File
@@ -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[] = {
src/roadveh.h
+1 -1
View File
@@ -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;
}
src/roadveh_cmd.cpp
+15 -19
View File
@@ -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<Trackdir>(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);
src/saveload/afterload.cpp
+3 -3
View File
@@ -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;
src/script/api/script_marine.cpp
+2 -2
View File
@@ -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;
}
src/script/api/script_tile.cpp
+3 -3
View File
@@ -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;
}
}
src/ship_cmd.cpp
+2 -2
View File
@@ -75,7 +75,7 @@ bool IsValidImageIndex<VehicleType::Ship>(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) &&
src/signal.cpp
+2 -2
View File
@@ -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;
}
src/station_cmd.cpp
+1 -1
View File
@@ -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};
}
src/track_func.h
-47
View File
@@ -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<TrackdirBits>(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<TrackdirBits>((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.
src/track_type.h
+5 -1
View File
@@ -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 */
src/train_cmd.cpp
+8 -8
View File
@@ -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 */
src/tunnelbridge_cmd.cpp
+3 -3
View File
@@ -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 */
src/water_cmd.cpp
+4 -4
View File
@@ -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 */