mirror
/
OpenTTD
mirror of https://github.com/OpenTTD/OpenTTD
1
0
Fork 0
Code Issues

Codechange: Add `this->` to YAPF.

pull/13030/head
Peter Nelson 2024-10-14 20:34:19 +01:00 committed by Peter Nelson
parent 5b73654f94
commit a6f412c615
15 changed files with 464 additions and 456 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

302
src/pathfinder/follow_track.hpp
View File

@ -58,38 +58,40 @@ struct CFollowTrackT
inline CFollowTrackT(Owner o, RailTypes railtype_override = INVALID_RAILTYPES)
{
assert(IsRailTT());
m_veh = nullptr;
this->m_veh = nullptr;
Init(o, railtype_override);
}
inline void Init(const VehicleType *v, RailTypes railtype_override)
{
assert(!IsRailTT() || (v != nullptr && v->type == VEH_TRAIN));
m_veh = v;
this->m_veh = v;
Init(v != nullptr ? v->owner : INVALID_OWNER, IsRailTT() && railtype_override == INVALID_RAILTYPES ? Train::From(v)->compatible_railtypes : railtype_override);
}
inline void Init(Owner o, RailTypes railtype_override)
{
assert(!IsRoadTT() || m_veh != nullptr);
assert(!IsRoadTT() || this->m_veh != nullptr);
assert(!IsRailTT() || railtype_override != INVALID_RAILTYPES);
m_veh_owner = o;
this->m_veh_owner = o;
/* don't worry, all is inlined so compiler should remove unnecessary initializations */
m_old_tile = INVALID_TILE;
m_old_td = INVALID_TRACKDIR;
m_new_tile = INVALID_TILE;
m_new_td_bits = TRACKDIR_BIT_NONE;
m_exitdir = INVALID_DIAGDIR;
m_is_station = m_is_bridge = m_is_tunnel = false;
m_tiles_skipped = 0;
m_err = EC_NONE;
m_railtypes = railtype_override;
this->m_old_tile = INVALID_TILE;
this->m_old_td = INVALID_TRACKDIR;
this->m_new_tile = INVALID_TILE;
this->m_new_td_bits = TRACKDIR_BIT_NONE;
this->m_exitdir = INVALID_DIAGDIR;
this->m_is_station = false;
this->m_is_bridge = false;
this->m_is_tunnel = false;
this->m_tiles_skipped = 0;
this->m_err = EC_NONE;
this->m_railtypes = railtype_override;
}
debug_inline static TransportType TT() { return Ttr_type_; }
debug_inline static bool IsWaterTT() { return TT() == TRANSPORT_WATER; }
debug_inline static bool IsRailTT() { return TT() == TRANSPORT_RAIL; }
inline bool IsTram() { return IsRoadTT() && RoadTypeIsTram(RoadVehicle::From(m_veh)->roadtype); }
inline bool IsTram() { return IsRoadTT() && RoadTypeIsTram(RoadVehicle::From(this->m_veh)->roadtype); }
debug_inline static bool IsRoadTT() { return TT() == TRANSPORT_ROAD; }
inline static bool Allow90degTurns() { return T90deg_turns_allowed_; }
inline static bool DoTrackMasking() { return Tmask_reserved_tracks; }
@ -97,7 +99,7 @@ struct CFollowTrackT
/** Tests if a tile is a road tile with a single tramtrack (tram can reverse) */
inline DiagDirection GetSingleTramBit(TileIndex tile)
{
assert(IsTram()); // this function shouldn't be called in other cases
assert(this->IsTram()); // this function shouldn't be called in other cases
if (IsNormalRoadTile(tile)) {
RoadBits rb = GetRoadBits(tile, RTT_TRAM);
@ -118,24 +120,24 @@ struct CFollowTrackT
*/
inline bool Follow(TileIndex old_tile, Trackdir old_td)
{
m_old_tile = old_tile;
m_old_td = old_td;
m_err = EC_NONE;
this->m_old_tile = old_tile;
this->m_old_td = old_td;
this->m_err = EC_NONE;
assert([&]() {
if (IsTram() && GetSingleTramBit(m_old_tile) != INVALID_DIAGDIR) return true; // Skip the check for single tram bits
const uint sub_mode = (IsRoadTT() && m_veh != nullptr) ? (this->IsTram() ? RTT_TRAM : RTT_ROAD) : 0;
const TrackdirBits old_tile_valid_dirs = TrackStatusToTrackdirBits(GetTileTrackStatus(m_old_tile, TT(), sub_mode));
return (old_tile_valid_dirs & TrackdirToTrackdirBits(m_old_td)) != TRACKDIR_BIT_NONE;
if (this->IsTram() && this->GetSingleTramBit(this->m_old_tile) != INVALID_DIAGDIR) return true; // Skip the check for single tram bits
const uint sub_mode = (IsRoadTT() && this->m_veh != nullptr) ? (this->IsTram() ? RTT_TRAM : RTT_ROAD) : 0;
const TrackdirBits old_tile_valid_dirs = TrackStatusToTrackdirBits(GetTileTrackStatus(this->m_old_tile, TT(), sub_mode));
return (old_tile_valid_dirs & TrackdirToTrackdirBits(this->m_old_td)) != TRACKDIR_BIT_NONE;
}());
m_exitdir = TrackdirToExitdir(m_old_td);
if (ForcedReverse()) return true;
if (!CanExitOldTile()) return false;
FollowTileExit();
if (!QueryNewTileTrackStatus()) return TryReverse();
m_new_td_bits &= DiagdirReachesTrackdirs(m_exitdir);
if (m_new_td_bits == TRACKDIR_BIT_NONE || !CanEnterNewTile()) {
this->m_exitdir = TrackdirToExitdir(this->m_old_td);
if (this->ForcedReverse()) return true;
if (!this->CanExitOldTile()) return false;
this->FollowTileExit();
if (!this->QueryNewTileTrackStatus()) return TryReverse();
this->m_new_td_bits &= DiagdirReachesTrackdirs(this->m_exitdir);
if (this->m_new_td_bits == TRACKDIR_BIT_NONE || !this->CanEnterNewTile()) {
/* In case we can't enter the next tile, but are
* a normal road vehicle, then we can actually
* try to reverse as this is the end of the road.
@ -147,19 +149,19 @@ struct CFollowTrackT
* that function failed can have to do with a
* missing road bit, or inability to connect the
* different bits due to slopes. */
if (IsRoadTT() && !IsTram() && TryReverse()) return true;
if (IsRoadTT() && !this->IsTram() && this->TryReverse()) return true;
/* CanEnterNewTile already set a reason.
* Do NOT overwrite it (important for example for EC_RAIL_ROAD_TYPE).
* Only set a reason if CanEnterNewTile was not called */
if (m_new_td_bits == TRACKDIR_BIT_NONE) m_err = EC_NO_WAY;
if (this->m_new_td_bits == TRACKDIR_BIT_NONE) this->m_err = EC_NO_WAY;
return false;
}
if ((!IsRailTT() && !Allow90degTurns()) || (IsRailTT() && Rail90DegTurnDisallowed(GetTileRailType(m_old_tile), GetTileRailType(m_new_tile), !Allow90degTurns()))) {
m_new_td_bits &= (TrackdirBits)~(int)TrackdirCrossesTrackdirs(m_old_td);
if (m_new_td_bits == TRACKDIR_BIT_NONE) {
m_err = EC_90DEG;
if ((!IsRailTT() && !Allow90degTurns()) || (IsRailTT() && Rail90DegTurnDisallowed(GetTileRailType(this->m_old_tile), GetTileRailType(this->m_new_tile), !Allow90degTurns()))) {
this->m_new_td_bits &= (TrackdirBits)~(int)TrackdirCrossesTrackdirs(this->m_old_td);
if (this->m_new_td_bits == TRACKDIR_BIT_NONE) {
this->m_err = EC_90DEG;
return false;
}
}
@ -170,27 +172,27 @@ struct CFollowTrackT
{
if (!DoTrackMasking()) return true;
if (m_is_station) {
if (this->m_is_station) {
/* Check skipped station tiles as well. */
TileIndexDiff diff = TileOffsByDiagDir(m_exitdir);
for (TileIndex tile = m_new_tile - diff * m_tiles_skipped; tile != m_new_tile; tile += diff) {
TileIndexDiff diff = TileOffsByDiagDir(this->m_exitdir);
for (TileIndex tile = this->m_new_tile - diff * this->m_tiles_skipped; tile != this->m_new_tile; tile += diff) {
if (HasStationReservation(tile)) {
m_new_td_bits = TRACKDIR_BIT_NONE;
m_err = EC_RESERVED;
this->m_new_td_bits = TRACKDIR_BIT_NONE;
this->m_err = EC_RESERVED;
return false;
}
}
}
TrackBits reserved = GetReservedTrackbits(m_new_tile);
TrackBits reserved = GetReservedTrackbits(this->m_new_tile);
/* Mask already reserved trackdirs. */
m_new_td_bits &= ~TrackBitsToTrackdirBits(reserved);
this->m_new_td_bits &= ~TrackBitsToTrackdirBits(reserved);
/* Mask out all trackdirs that conflict with the reservation. */
for (Track t : SetTrackBitIterator(TrackdirBitsToTrackBits(m_new_td_bits))) {
if (TracksOverlap(reserved | TrackToTrackBits(t))) m_new_td_bits &= ~TrackToTrackdirBits(t);
for (Track t : SetTrackBitIterator(TrackdirBitsToTrackBits(this->m_new_td_bits))) {
if (TracksOverlap(reserved | TrackToTrackBits(t))) this->m_new_td_bits &= ~TrackToTrackdirBits(t);
}
if (m_new_td_bits == TRACKDIR_BIT_NONE) {
m_err = EC_RESERVED;
if (this->m_new_td_bits == TRACKDIR_BIT_NONE) {
this->m_err = EC_RESERVED;
return false;
}
return true;
@ -200,77 +202,79 @@ protected:
/** Follow the m_exitdir from m_old_tile and fill m_new_tile and m_tiles_skipped */
inline void FollowTileExit()
{
m_is_station = m_is_bridge = m_is_tunnel = false;
m_tiles_skipped = 0;
this->m_is_station = false;
this->m_is_bridge = false;
this->m_is_tunnel = false;
this->m_tiles_skipped = 0;
/* extra handling for tunnels and bridges in our direction */
if (IsTileType(m_old_tile, MP_TUNNELBRIDGE)) {
DiagDirection enterdir = GetTunnelBridgeDirection(m_old_tile);
if (enterdir == m_exitdir) {
if (IsTileType(this->m_old_tile, MP_TUNNELBRIDGE)) {
DiagDirection enterdir = GetTunnelBridgeDirection(this->m_old_tile);
if (enterdir == this->m_exitdir) {
/* we are entering the tunnel / bridge */
if (IsTunnel(m_old_tile)) {
m_is_tunnel = true;
m_new_tile = GetOtherTunnelEnd(m_old_tile);
if (IsTunnel(this->m_old_tile)) {
this->m_is_tunnel = true;
this->m_new_tile = GetOtherTunnelEnd(this->m_old_tile);
} else { // IsBridge(m_old_tile)
m_is_bridge = true;
m_new_tile = GetOtherBridgeEnd(m_old_tile);
this->m_is_bridge = true;
this->m_new_tile = GetOtherBridgeEnd(this->m_old_tile);
}
m_tiles_skipped = GetTunnelBridgeLength(m_new_tile, m_old_tile);
this->m_tiles_skipped = GetTunnelBridgeLength(this->m_new_tile, this->m_old_tile);
return;
}
assert(ReverseDiagDir(enterdir) == m_exitdir);
assert(ReverseDiagDir(enterdir) == this->m_exitdir);
}
/* normal or station tile, do one step */
m_new_tile = TileAddByDiagDir(m_old_tile, m_exitdir);
this->m_new_tile = TileAddByDiagDir(this->m_old_tile, this->m_exitdir);
/* special handling for stations */
if (IsRailTT() && HasStationTileRail(m_new_tile)) {
m_is_station = true;
} else if (IsRoadTT() && IsStationRoadStopTile(m_new_tile)) {
m_is_station = true;
if (IsRailTT() && HasStationTileRail(this->m_new_tile)) {
this->m_is_station = true;
} else if (IsRoadTT() && IsStationRoadStopTile(this->m_new_tile)) {
this->m_is_station = true;
}
}
/** stores track status (available trackdirs) for the new tile into m_new_td_bits */
inline bool QueryNewTileTrackStatus()
{
if (IsRailTT() && IsPlainRailTile(m_new_tile)) {
m_new_td_bits = (TrackdirBits)(GetTrackBits(m_new_tile) * 0x101);
if (IsRailTT() && IsPlainRailTile(this->m_new_tile)) {
this->m_new_td_bits = (TrackdirBits)(GetTrackBits(this->m_new_tile) * 0x101);
} else if (IsRoadTT()) {
m_new_td_bits = GetTrackdirBitsForRoad(m_new_tile, this->IsTram() ? RTT_TRAM : RTT_ROAD);
this->m_new_td_bits = GetTrackdirBitsForRoad(this->m_new_tile, this->IsTram() ? RTT_TRAM : RTT_ROAD);
} else {
m_new_td_bits = TrackStatusToTrackdirBits(GetTileTrackStatus(m_new_tile, TT(), 0));
this->m_new_td_bits = TrackStatusToTrackdirBits(GetTileTrackStatus(this->m_new_tile, TT(), 0));
}
return (m_new_td_bits != TRACKDIR_BIT_NONE);
return (this->m_new_td_bits != TRACKDIR_BIT_NONE);
}
/** return true if we can leave m_old_tile in m_exitdir */
inline bool CanExitOldTile()
{
/* road stop can be left at one direction only unless it's a drive-through stop */
if (IsRoadTT() && IsBayRoadStopTile(m_old_tile)) {
DiagDirection exitdir = GetBayRoadStopDir(m_old_tile);
if (exitdir != m_exitdir) {
m_err = EC_NO_WAY;
if (IsRoadTT() && IsBayRoadStopTile(this->m_old_tile)) {
DiagDirection exitdir = GetBayRoadStopDir(this->m_old_tile);
if (exitdir != this->m_exitdir) {
this->m_err = EC_NO_WAY;
return false;
}
}
/* single tram bits can only be left in one direction */
if (IsTram()) {
DiagDirection single_tram = GetSingleTramBit(m_old_tile);
if (single_tram != INVALID_DIAGDIR && single_tram != m_exitdir) {
m_err = EC_NO_WAY;
if (this->IsTram()) {
DiagDirection single_tram = GetSingleTramBit(this->m_old_tile);
if (single_tram != INVALID_DIAGDIR && single_tram != this->m_exitdir) {
this->m_err = EC_NO_WAY;
return false;
}
}
/* road depots can be also left in one direction only */
if (IsRoadTT() && IsDepotTypeTile(m_old_tile, TT())) {
DiagDirection exitdir = GetRoadDepotDirection(m_old_tile);
if (exitdir != m_exitdir) {
m_err = EC_NO_WAY;
if (IsRoadTT() && IsDepotTypeTile(this->m_old_tile, TT())) {
DiagDirection exitdir = GetRoadDepotDirection(this->m_old_tile);
if (exitdir != this->m_exitdir) {
this->m_err = EC_NO_WAY;
return false;
}
}
@ -280,88 +284,88 @@ protected:
/** return true if we can enter m_new_tile from m_exitdir */
inline bool CanEnterNewTile()
{
if (IsRoadTT() && IsBayRoadStopTile(m_new_tile)) {
if (IsRoadTT() && IsBayRoadStopTile(this->m_new_tile)) {
/* road stop can be entered from one direction only unless it's a drive-through stop */
DiagDirection exitdir = GetBayRoadStopDir(m_new_tile);
if (ReverseDiagDir(exitdir) != m_exitdir) {
m_err = EC_NO_WAY;
DiagDirection exitdir = GetBayRoadStopDir(this->m_new_tile);
if (ReverseDiagDir(exitdir) != this->m_exitdir) {
this->m_err = EC_NO_WAY;
return false;
}
}
/* single tram bits can only be entered from one direction */
if (IsTram()) {
DiagDirection single_tram = GetSingleTramBit(m_new_tile);
if (single_tram != INVALID_DIAGDIR && single_tram != ReverseDiagDir(m_exitdir)) {
m_err = EC_NO_WAY;
if (this->IsTram()) {
DiagDirection single_tram = this->GetSingleTramBit(this->m_new_tile);
if (single_tram != INVALID_DIAGDIR && single_tram != ReverseDiagDir(this->m_exitdir)) {
this->m_err = EC_NO_WAY;
return false;
}
}
/* road and rail depots can also be entered from one direction only */
if (IsRoadTT() && IsDepotTypeTile(m_new_tile, TT())) {
DiagDirection exitdir = GetRoadDepotDirection(m_new_tile);
if (ReverseDiagDir(exitdir) != m_exitdir) {
m_err = EC_NO_WAY;
if (IsRoadTT() && IsDepotTypeTile(this->m_new_tile, TT())) {
DiagDirection exitdir = GetRoadDepotDirection(this->m_new_tile);
if (ReverseDiagDir(exitdir) != this->m_exitdir) {
this->m_err = EC_NO_WAY;
return false;
}
/* don't try to enter other company's depots */
if (GetTileOwner(m_new_tile) != m_veh_owner) {
m_err = EC_OWNER;
if (GetTileOwner(this->m_new_tile) != this->m_veh_owner) {
this->m_err = EC_OWNER;
return false;
}
}
if (IsRailTT() && IsDepotTypeTile(m_new_tile, TT())) {
DiagDirection exitdir = GetRailDepotDirection(m_new_tile);
if (ReverseDiagDir(exitdir) != m_exitdir) {
m_err = EC_NO_WAY;
if (IsRailTT() && IsDepotTypeTile(this->m_new_tile, TT())) {
DiagDirection exitdir = GetRailDepotDirection(this->m_new_tile);
if (ReverseDiagDir(exitdir) != this->m_exitdir) {
this->m_err = EC_NO_WAY;
return false;
}
}
/* rail transport is possible only on tiles with the same owner as vehicle */
if (IsRailTT() && GetTileOwner(m_new_tile) != m_veh_owner) {
if (IsRailTT() && GetTileOwner(this->m_new_tile) != this->m_veh_owner) {
/* different owner */
m_err = EC_NO_WAY;
this->m_err = EC_NO_WAY;
return false;
}
/* rail transport is possible only on compatible rail types */
if (IsRailTT()) {
RailType rail_type = GetTileRailType(m_new_tile);
if (!HasBit(m_railtypes, rail_type)) {
RailType rail_type = GetTileRailType(this->m_new_tile);
if (!HasBit(this->m_railtypes, rail_type)) {
/* incompatible rail type */
m_err = EC_RAIL_ROAD_TYPE;
this->m_err = EC_RAIL_ROAD_TYPE;
return false;
}
}
/* road transport is possible only on compatible road types */
if (IsRoadTT()) {
const RoadVehicle *v = RoadVehicle::From(m_veh);
RoadType roadtype = GetRoadType(m_new_tile, GetRoadTramType(v->roadtype));
const RoadVehicle *v = RoadVehicle::From(this->m_veh);
RoadType roadtype = GetRoadType(this->m_new_tile, GetRoadTramType(v->roadtype));
if (!HasBit(v->compatible_roadtypes, roadtype)) {
/* incompatible road type */
m_err = EC_RAIL_ROAD_TYPE;
this->m_err = EC_RAIL_ROAD_TYPE;
return false;
}
}
/* tunnel holes and bridge ramps can be entered only from proper direction */
if (IsTileType(m_new_tile, MP_TUNNELBRIDGE)) {
if (IsTunnel(m_new_tile)) {
if (!m_is_tunnel) {
DiagDirection tunnel_enterdir = GetTunnelBridgeDirection(m_new_tile);
if (tunnel_enterdir != m_exitdir) {
m_err = EC_NO_WAY;
if (IsTileType(this->m_new_tile, MP_TUNNELBRIDGE)) {
if (IsTunnel(this->m_new_tile)) {
if (!this->m_is_tunnel) {
DiagDirection tunnel_enterdir = GetTunnelBridgeDirection(this->m_new_tile);
if (tunnel_enterdir != this->m_exitdir) {
this->m_err = EC_NO_WAY;
return false;
}
}
} else { // IsBridge(m_new_tile)
if (!m_is_bridge) {
DiagDirection ramp_enderdir = GetTunnelBridgeDirection(m_new_tile);
if (ramp_enderdir != m_exitdir) {
m_err = EC_NO_WAY;
if (!this->m_is_bridge) {
DiagDirection ramp_enderdir = GetTunnelBridgeDirection(this->m_new_tile);
if (ramp_enderdir != this->m_exitdir) {
this->m_err = EC_NO_WAY;
return false;
}
}
@ -369,16 +373,16 @@ protected:
}
/* special handling for rail stations - get to the end of platform */
if (IsRailTT() && m_is_station) {
if (IsRailTT() && this->m_is_station) {
/* entered railway station
* get platform length */
uint length = BaseStation::GetByTile(m_new_tile)->GetPlatformLength(m_new_tile, TrackdirToExitdir(m_old_td));
uint length = BaseStation::GetByTile(this->m_new_tile)->GetPlatformLength(this->m_new_tile, TrackdirToExitdir(this->m_old_td));
/* how big step we must do to get to the last platform tile? */
m_tiles_skipped = length - 1;
this->m_tiles_skipped = length - 1;
/* move to the platform end */
TileIndexDiff diff = TileOffsByDiagDir(m_exitdir);
diff *= m_tiles_skipped;
m_new_tile = TileAdd(m_new_tile, diff);
TileIndexDiff diff = TileOffsByDiagDir(this->m_exitdir);
diff *= this->m_tiles_skipped;
this->m_new_tile = TileAdd(this->m_new_tile, diff);
return true;
}
@ -389,28 +393,32 @@ protected:
inline bool ForcedReverse()
{
/* rail and road depots cause reversing */
if (!IsWaterTT() && IsDepotTypeTile(m_old_tile, TT())) {
DiagDirection exitdir = IsRailTT() ? GetRailDepotDirection(m_old_tile) : GetRoadDepotDirection(m_old_tile);
if (exitdir != m_exitdir) {
if (!IsWaterTT() && IsDepotTypeTile(this->m_old_tile, TT())) {
DiagDirection exitdir = IsRailTT() ? GetRailDepotDirection(this->m_old_tile) : GetRoadDepotDirection(this->m_old_tile);
if (exitdir != this->m_exitdir) {
/* reverse */
m_new_tile = m_old_tile;
m_new_td_bits = TrackdirToTrackdirBits(ReverseTrackdir(m_old_td));
m_exitdir = exitdir;
m_tiles_skipped = 0;
m_is_tunnel = m_is_bridge = m_is_station = false;
this->m_new_tile = this->m_old_tile;
this->m_new_td_bits = TrackdirToTrackdirBits(ReverseTrackdir(this->m_old_td));
this->m_exitdir = exitdir;
this->m_tiles_skipped = 0;
this->m_is_tunnel = false;
this->m_is_bridge = false;
this->m_is_station = false;
return true;
}
}
/* Single tram bits and standard road stops cause reversing. */
if (IsRoadTT() && ((IsTram() && GetSingleTramBit(m_old_tile) == ReverseDiagDir(m_exitdir)) ||
(IsBayRoadStopTile(m_old_tile) && GetBayRoadStopDir(m_old_tile) == ReverseDiagDir(m_exitdir)))) {
if (IsRoadTT() && ((this->IsTram() && GetSingleTramBit(this->m_old_tile) == ReverseDiagDir(this->m_exitdir)) ||
(IsBayRoadStopTile(this->m_old_tile) && GetBayRoadStopDir(this->m_old_tile) == ReverseDiagDir(this->m_exitdir)))) {
/* reverse */
m_new_tile = m_old_tile;
m_new_td_bits = TrackdirToTrackdirBits(ReverseTrackdir(m_old_td));
m_exitdir = ReverseDiagDir(m_exitdir);
m_tiles_skipped = 0;
m_is_tunnel = m_is_bridge = m_is_station = false;
this->m_new_tile = this->m_old_tile;
this->m_new_td_bits = TrackdirToTrackdirBits(ReverseTrackdir(this->m_old_td));
this->m_exitdir = ReverseDiagDir(this->m_exitdir);
this->m_tiles_skipped = 0;
this->m_is_tunnel = false;
this->m_is_bridge = false;
this->m_is_station = false;
return true;
}
@ -420,20 +428,20 @@ protected:
/** return true if we successfully reversed at end of road/track */
inline bool TryReverse()
{
if (IsRoadTT() && !IsTram()) {
if (IsRoadTT() && !this->IsTram()) {
/* if we reached the end of road, we can reverse the RV and continue moving */
m_exitdir = ReverseDiagDir(m_exitdir);
this->m_exitdir = ReverseDiagDir(this->m_exitdir);
/* new tile will be the same as old one */
m_new_tile = m_old_tile;
this->m_new_tile = this->m_old_tile;
/* set new trackdir bits to all reachable trackdirs */
QueryNewTileTrackStatus();
m_new_td_bits &= DiagdirReachesTrackdirs(m_exitdir);
if (m_new_td_bits != TRACKDIR_BIT_NONE) {
this->m_new_td_bits &= DiagdirReachesTrackdirs(this->m_exitdir);
if (this->m_new_td_bits != TRACKDIR_BIT_NONE) {
/* we have some trackdirs reachable after reversal */
return true;
}
}
m_err = EC_NO_WAY;
this->m_err = EC_NO_WAY;
return false;
}
@ -445,19 +453,19 @@ public:
int max_speed = INT_MAX; // no limit
/* Check for on-bridge speed limit */
if (!IsWaterTT() && IsBridgeTile(m_old_tile)) {
int spd = GetBridgeSpec(GetBridgeType(m_old_tile))->speed;
if (!IsWaterTT() && IsBridgeTile(this->m_old_tile)) {
int spd = GetBridgeSpec(GetBridgeType(this->m_old_tile))->speed;
if (IsRoadTT()) spd *= 2;
max_speed = std::min(max_speed, spd);
}
/* Check for speed limit imposed by railtype */
if (IsRailTT()) {
uint16_t rail_speed = GetRailTypeInfo(GetRailType(m_old_tile))->max_speed;
uint16_t rail_speed = GetRailTypeInfo(GetRailType(this->m_old_tile))->max_speed;
if (rail_speed > 0) max_speed = std::min<int>(max_speed, rail_speed);
}
if (IsRoadTT()) {
/* max_speed is already in roadvehicle units, no need to further modify (divide by 2) */
uint16_t road_speed = GetRoadTypeInfo(GetRoadType(m_old_tile, GetRoadTramType(RoadVehicle::From(m_veh)->roadtype)))->max_speed;
uint16_t road_speed = GetRoadTypeInfo(GetRoadType(this->m_old_tile, GetRoadTramType(RoadVehicle::From(this->m_veh)->roadtype)))->max_speed;
if (road_speed > 0) max_speed = std::min<int>(max_speed, road_speed);
}

54
src/pathfinder/yapf/nodelist.hpp
View File

@ -39,7 +39,7 @@ public:
/** default constructor */
CNodeList_HashTableT() : m_open_queue(2048)
{
m_new_node = nullptr;
this->m_new_node = nullptr;
}
/** destructor */
@ -50,28 +50,28 @@ public:
/** return number of open nodes */
inline int OpenCount()
{
return m_open.Count();
return this->m_open.Count();
}
/** return number of closed nodes */
inline int ClosedCount()
{
return m_closed.Count();
return this->m_closed.Count();
}
/** allocate new data item from m_arr */
inline Titem_ *CreateNewNode()
{
if (m_new_node == nullptr) m_new_node = &m_arr.emplace_back();
return m_new_node;
if (this->m_new_node == nullptr) this->m_new_node = &this->m_arr.emplace_back();
return this->m_new_node;
}
/** Notify the nodelist that we don't want to discard the given node. */
inline void FoundBestNode(Titem_ &item)
{
/* for now it is enough to invalidate m_new_node if it is our given node */
if (&item == m_new_node) {
m_new_node = nullptr;
if (&item == this->m_new_node) {
this->m_new_node = nullptr;
}
/* TODO: do we need to store best nodes found in some extra list/array? Probably not now. */
}
@ -79,19 +79,19 @@ public:
/** insert given item as open node (into m_open and m_open_queue) */
inline void InsertOpenNode(Titem_ &item)
{
assert(m_closed.Find(item.GetKey()) == nullptr);
m_open.Push(item);
m_open_queue.Include(&item);
if (&item == m_new_node) {
m_new_node = nullptr;
assert(this->m_closed.Find(item.GetKey()) == nullptr);
this->m_open.Push(item);
this->m_open_queue.Include(&item);
if (&item == this->m_new_node) {
this->m_new_node = nullptr;
}
}
/** return the best open node */
inline Titem_ *GetBestOpenNode()
{
if (!m_open_queue.IsEmpty()) {
return m_open_queue.Begin();
if (!this->m_open_queue.IsEmpty()) {
return this->m_open_queue.Begin();
}
return nullptr;
}
@ -99,9 +99,9 @@ public:
/** remove and return the best open node */
inline Titem_ *PopBestOpenNode()
{
if (!m_open_queue.IsEmpty()) {
Titem_ *item = m_open_queue.Shift();
m_open.Pop(*item);
if (!this->m_open_queue.IsEmpty()) {
Titem_ *item = this->m_open_queue.Shift();
this->m_open.Pop(*item);
return item;
}
return nullptr;
@ -110,49 +110,49 @@ public:
/** return the open node specified by a key or nullptr if not found */
inline Titem_ *FindOpenNode(const Key &key)
{
Titem_ *item = m_open.Find(key);
Titem_ *item = this->m_open.Find(key);
return item;
}
/** remove and return the open node specified by a key */
inline Titem_ &PopOpenNode(const Key &key)
{
Titem_ &item = m_open.Pop(key);
size_t idxPop = m_open_queue.FindIndex(item);
m_open_queue.Remove(idxPop);
Titem_ &item = this->m_open.Pop(key);
size_t idxPop = this->m_open_queue.FindIndex(item);
this->m_open_queue.Remove(idxPop);
return item;
}
/** close node */
inline void InsertClosedNode(Titem_ &item)
{
assert(m_open.Find(item.GetKey()) == nullptr);
m_closed.Push(item);
assert(this->m_open.Find(item.GetKey()) == nullptr);
this->m_closed.Push(item);
}
/** return the closed node specified by a key or nullptr if not found */
inline Titem_ *FindClosedNode(const Key &key)
{
Titem_ *item = m_closed.Find(key);
Titem_ *item = this->m_closed.Find(key);
return item;
}
/** The number of items. */
inline int TotalCount()
{
return m_arr.Length();
return this->m_arr.Length();
}
/** Get a particular item. */
inline Titem_ &ItemAt(int idx)
{
return m_arr[idx];
return this->m_arr[idx];
}
/** Helper for creating output of this array. */
template <class D> void Dump(D &dmp) const
{
dmp.WriteStructT("m_arr", &m_arr);
dmp.WriteStructT("m_arr", &this->m_arr);
}
};

62
src/pathfinder/yapf/yapf_base.hpp
View File

@ -98,7 +98,7 @@ public:
/** return current settings (can be custom - company based - but later) */
inline const YAPFSettings &PfGetSettings() const
{
return *m_settings;
return *this->m_settings;
}
/**
@ -112,38 +112,38 @@ public:
*/
inline bool FindPath(const VehicleType *v)
{
m_veh = v;
this->m_veh = v;
Yapf().PfSetStartupNodes();
for (;;) {
m_num_steps++;
Node *best_open_node = m_nodes.GetBestOpenNode();
this->m_num_steps++;
Node *best_open_node = this->m_nodes.GetBestOpenNode();
if (best_open_node == nullptr) break;
if (Yapf().PfDetectDestination(*best_open_node)) {
m_pBestDestNode = best_open_node;
this->m_pBestDestNode = best_open_node;
break;
}
Yapf().PfFollowNode(*best_open_node);
if (m_max_search_nodes != 0 && m_nodes.ClosedCount() >= m_max_search_nodes) break;
if (this->m_max_search_nodes != 0 && this->m_nodes.ClosedCount() >= this->m_max_search_nodes) break;
m_nodes.PopOpenNode(best_open_node->GetKey());
m_nodes.InsertClosedNode(*best_open_node);
this->m_nodes.PopOpenNode(best_open_node->GetKey());
this->m_nodes.InsertClosedNode(*best_open_node);
}
const bool destination_found = (m_pBestDestNode != nullptr);
const bool destination_found = (this->m_pBestDestNode != nullptr);
if (_debug_yapf_level >= 3) {
const UnitID veh_idx = (m_veh != nullptr) ? m_veh->unitnumber : 0;
const UnitID veh_idx = (this->m_veh != nullptr) ? this->m_veh->unitnumber : 0;
const char ttc = Yapf().TransportTypeChar();
const float cache_hit_ratio = (m_stats_cache_hits == 0) ? 0.0f : ((float)m_stats_cache_hits / (float)(m_stats_cache_hits + m_stats_cost_calcs) * 100.0f);
const int cost = destination_found ? m_pBestDestNode->m_cost : -1;
const int dist = destination_found ? m_pBestDestNode->m_estimate - m_pBestDestNode->m_cost : -1;
const float cache_hit_ratio = (this->m_stats_cache_hits == 0) ? 0.0f : ((float)this->m_stats_cache_hits / (float)(this->m_stats_cache_hits + this->m_stats_cost_calcs) * 100.0f);
const int cost = destination_found ? this->m_pBestDestNode->m_cost : -1;
const int dist = destination_found ? this->m_pBestDestNode->m_estimate - this->m_pBestDestNode->m_cost : -1;
Debug(yapf, 3, "[YAPF{}]{}{:4d} - {} rounds - {} open - {} closed - CHR {:4.1f}% - C {} D {}",
ttc, destination_found ? '-' : '!', veh_idx, m_num_steps, m_nodes.OpenCount(), m_nodes.ClosedCount(), cache_hit_ratio, cost, dist
ttc, destination_found ? '-' : '!', veh_idx, this->m_num_steps, this->m_nodes.OpenCount(), this->m_nodes.ClosedCount(), cache_hit_ratio, cost, dist
);
}
@ -156,7 +156,7 @@ public:
*/
inline Node *GetBestNode()
{
return (m_pBestDestNode != nullptr) ? m_pBestDestNode : m_pBestIntermediateNode;
return (this->m_pBestDestNode != nullptr) ? this->m_pBestDestNode : this->m_pBestIntermediateNode;
}
/**
@ -165,7 +165,7 @@ public:
*/
inline Node &CreateNewNode()
{
Node &node = *m_nodes.CreateNewNode();
Node &node = *this->m_nodes.CreateNewNode();
return node;
}
@ -174,8 +174,8 @@ public:
{
Yapf().PfNodeCacheFetch(n);
/* insert the new node only if it is not there */
if (m_nodes.FindOpenNode(n.m_key) == nullptr) {
m_nodes.InsertOpenNode(n);
if (this->m_nodes.FindOpenNode(n.m_key) == nullptr) {
this->m_nodes.InsertOpenNode(n);
} else {
/* if we are here, it means that node is already there - how it is possible?
* probably the train is in the position that both its ends point to the same tile/exit-dir
@ -222,9 +222,9 @@ public:
/* evaluate the node */
bool bCached = Yapf().PfNodeCacheFetch(n);
if (!bCached) {
m_stats_cost_calcs++;
this->m_stats_cost_calcs++;
} else {
m_stats_cache_hits++;
this->m_stats_cache_hits++;
}
bool bValid = Yapf().PfCalcCost(n, &tf);
@ -236,26 +236,26 @@ public:
/* The new node can be set as the best intermediate node only once we're
* certain it will be finalized by being inserted into the open list. */
bool set_intermediate = m_max_search_nodes > 0 && (m_pBestIntermediateNode == nullptr || (m_pBestIntermediateNode->GetCostEstimate() - m_pBestIntermediateNode->GetCost()) > (n.GetCostEstimate() - n.GetCost()));
bool set_intermediate = this->m_max_search_nodes > 0 && (this->m_pBestIntermediateNode == nullptr || (this->m_pBestIntermediateNode->GetCostEstimate() - this->m_pBestIntermediateNode->GetCost()) > (n.GetCostEstimate() - n.GetCost()));
/* check new node against open list */
Node *openNode = m_nodes.FindOpenNode(n.GetKey());
Node *openNode = this->m_nodes.FindOpenNode(n.GetKey());
if (openNode != nullptr) {
/* another node exists with the same key in the open list
* is it better than new one? */
if (n.GetCostEstimate() < openNode->GetCostEstimate()) {
/* update the old node by value from new one */
m_nodes.PopOpenNode(n.GetKey());
this->m_nodes.PopOpenNode(n.GetKey());
*openNode = n;
/* add the updated old node back to open list */
m_nodes.InsertOpenNode(*openNode);
if (set_intermediate) m_pBestIntermediateNode = openNode;
this->m_nodes.InsertOpenNode(*openNode);
if (set_intermediate) this->m_pBestIntermediateNode = openNode;
}
return;
}
/* check new node against closed list */
Node *closedNode = m_nodes.FindClosedNode(n.GetKey());
Node *closedNode = this->m_nodes.FindClosedNode(n.GetKey());
if (closedNode != nullptr) {
/* another node exists with the same key in the closed list
* is it better than new one? */
@ -274,19 +274,19 @@ public:
}
/* the new node is really new
* add it to the open list */
m_nodes.InsertOpenNode(n);
if (set_intermediate) m_pBestIntermediateNode = &n;
this->m_nodes.InsertOpenNode(n);
if (set_intermediate) this->m_pBestIntermediateNode = &n;
}
const VehicleType * GetVehicle() const
{
return m_veh;
return this->m_veh;
}
void DumpBase(DumpTarget &dmp) const
{
dmp.WriteStructT("m_nodes", &m_nodes);
dmp.WriteValue("m_num_steps", m_num_steps);
dmp.WriteStructT("m_nodes", &this->m_nodes);
dmp.WriteValue("m_num_steps", this->m_num_steps);
}
};

46
src/pathfinder/yapf/yapf_common.hpp
View File

@ -40,18 +40,18 @@ public:
/** Set origin tile / trackdir mask */
void SetOrigin(TileIndex tile, TrackdirBits trackdirs)
{
m_orgTile = tile;
m_orgTrackdirs = trackdirs;
this->m_orgTile = tile;
this->m_orgTrackdirs = trackdirs;
}
/** Called when YAPF needs to place origin nodes into open list */
void PfSetStartupNodes()
{
bool is_choice = (KillFirstBit(m_orgTrackdirs) != TRACKDIR_BIT_NONE);
for (TrackdirBits tdb = m_orgTrackdirs; tdb != TRACKDIR_BIT_NONE; tdb = KillFirstBit(tdb)) {
bool is_choice = (KillFirstBit(this->m_orgTrackdirs) != TRACKDIR_BIT_NONE);
for (TrackdirBits tdb = this->m_orgTrackdirs; tdb != TRACKDIR_BIT_NONE; tdb = KillFirstBit(tdb)) {
Trackdir td = (Trackdir)FindFirstBit(tdb);
Node &n1 = Yapf().CreateNewNode();
n1.Set(nullptr, m_orgTile, td, is_choice);
n1.Set(nullptr, this->m_orgTile, td, is_choice);
Yapf().AddStartupNode(n1);
}
}
@ -84,26 +84,26 @@ public:
/** set origin (tiles, trackdirs, etc.) */
void SetOrigin(TileIndex tile, Trackdir td, TileIndex tiler = INVALID_TILE, Trackdir tdr = INVALID_TRACKDIR, int reverse_penalty = 0, bool treat_first_red_two_way_signal_as_eol = true)
{
m_orgTile = tile;
m_orgTd = td;
m_revTile = tiler;
m_revTd = tdr;
m_reverse_penalty = reverse_penalty;
m_treat_first_red_two_way_signal_as_eol = treat_first_red_two_way_signal_as_eol;
this->m_orgTile = tile;
this->m_orgTd = td;
this->m_revTile = tiler;
this->m_revTd = tdr;
this->m_reverse_penalty = reverse_penalty;
this->m_treat_first_red_two_way_signal_as_eol = treat_first_red_two_way_signal_as_eol;
}
/** Called when YAPF needs to place origin nodes into open list */
void PfSetStartupNodes()
{
if (m_orgTile != INVALID_TILE && m_orgTd != INVALID_TRACKDIR) {
if (this->m_orgTile != INVALID_TILE && this->m_orgTd != INVALID_TRACKDIR) {
Node &n1 = Yapf().CreateNewNode();
n1.Set(nullptr, m_orgTile, m_orgTd, false);
n1.Set(nullptr, this->m_orgTile, this->m_orgTd, false);
Yapf().AddStartupNode(n1);
}
if (m_revTile != INVALID_TILE && m_revTd != INVALID_TRACKDIR) {
if (this->m_revTile != INVALID_TILE && this->m_revTd != INVALID_TRACKDIR) {
Node &n2 = Yapf().CreateNewNode();
n2.Set(nullptr, m_revTile, m_revTd, false);
n2.m_cost = m_reverse_penalty;
n2.Set(nullptr, this->m_revTile, this->m_revTd, false);
n2.m_cost = this->m_reverse_penalty;
Yapf().AddStartupNode(n2);
}
}
@ -111,7 +111,7 @@ public:
/** return true if first two-way signal should be treated as dead end */
inline bool TreatFirstRedTwoWaySignalAsEOL()
{
return Yapf().PfGetSettings().rail_firstred_twoway_eol && m_treat_first_red_two_way_signal_as_eol;
return Yapf().PfGetSettings().rail_firstred_twoway_eol && this->m_treat_first_red_two_way_signal_as_eol;
}
};
@ -132,8 +132,8 @@ public:
/** set the destination tile / more trackdirs */
void SetDestination(TileIndex tile, TrackdirBits trackdirs)
{
m_destTile = tile;
m_destTrackdirs = trackdirs;
this->m_destTile = tile;
this->m_destTrackdirs = trackdirs;
}
protected:
@ -147,7 +147,7 @@ public:
/** Called by YAPF to detect if node ends in the desired destination */
inline bool PfDetectDestination(Node &n)
{
return (n.m_key.m_tile == m_destTile) && HasTrackdir(m_destTrackdirs, n.GetTrackdir());
return (n.m_key.m_tile == this->m_destTile) && HasTrackdir(this->m_destTrackdirs, n.GetTrackdir());
}
/**
@ -158,7 +158,7 @@ public:
{
static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};
if (PfDetectDestination(n)) {
if (this->PfDetectDestination(n)) {
n.m_estimate = n.m_cost;
return true;
}
@ -167,8 +167,8 @@ public:
DiagDirection exitdir = TrackdirToExitdir(n.GetTrackdir());
int x1 = 2 * TileX(tile) + dg_dir_to_x_offs[(int)exitdir];
int y1 = 2 * TileY(tile) + dg_dir_to_y_offs[(int)exitdir];
int x2 = 2 * TileX(m_destTile);
int y2 = 2 * TileY(m_destTile);
int x2 = 2 * TileX(this->m_destTile);
int y2 = 2 * TileY(this->m_destTile);
int dx = abs(x1 - x2);
int dy = abs(y1 - y2);
int dmin = std::min(dx, dy);

12
src/pathfinder/yapf/yapf_costcache.hpp
View File

@ -81,17 +81,17 @@ struct CSegmentCostCacheT : public CSegmentCostCacheBase {
/** flush (clear) the cache */
inline void Flush()
{
m_map.Clear();
m_heap.clear();
this->m_map.Clear();
this->m_heap.clear();
}
inline Tsegment &Get(Key &key, bool *found)
{
Tsegment *item = m_map.Find(key);
Tsegment *item = this->m_map.Find(key);
if (item == nullptr) {
*found = false;
item = &m_heap.emplace_back(key);
m_map.Push(*item);
this->m_map.Push(*item);
} else {
*found = true;
}
@ -150,12 +150,12 @@ public:
CacheKey key(n.GetKey());
if (!Yapf().CanUseGlobalCache(n)) {
Yapf().ConnectNodeToCachedData(n, m_local_cache.emplace_back(key));
Yapf().ConnectNodeToCachedData(n, this->m_local_cache.emplace_back(key));
return false;
}
bool found;
CachedData &item = m_global_cache.Get(key, &found);
CachedData &item = this->m_global_cache.Get(key, &found);
Yapf().ConnectNodeToCachedData(n, item);
return found;
}

22
src/pathfinder/yapf/yapf_costrail.hpp
View File

@ -61,10 +61,10 @@ protected:
int p0 = Yapf().PfGetSettings().rail_look_ahead_signal_p0;
int p1 = Yapf().PfGetSettings().rail_look_ahead_signal_p1;
int p2 = Yapf().PfGetSettings().rail_look_ahead_signal_p2;
m_sig_look_ahead_costs.clear();
m_sig_look_ahead_costs.reserve(Yapf().PfGetSettings().rail_look_ahead_max_signals);
this->m_sig_look_ahead_costs.clear();
this->m_sig_look_ahead_costs.reserve(Yapf().PfGetSettings().rail_look_ahead_max_signals);
for (uint i = 0; i < Yapf().PfGetSettings().rail_look_ahead_max_signals; i++) {
m_sig_look_ahead_costs.push_back(p0 + i * (p1 + i * p2));
this->m_sig_look_ahead_costs.push_back(p0 + i * (p1 + i * p2));
}
}
@ -145,7 +145,7 @@ public:
/** The cost for reserved tiles, including skipped ones. */
inline int ReservationCost(Node &n, TileIndex tile, Trackdir trackdir, int skipped)
{
if (n.m_num_signals_passed >= m_sig_look_ahead_costs.size() / 2) return 0;
if (n.m_num_signals_passed >= this->m_sig_look_ahead_costs.size() / 2) return 0;
if (!IsPbsSignal(n.m_last_signal_type)) return 0;
if (IsRailStationTile(tile) && IsAnyStationTileReserved(tile, trackdir, skipped)) {
@ -176,7 +176,7 @@ public:
n.m_last_signal_type = sig_type;
/* cache the look-ahead polynomial constant only if we didn't pass more signals than the look-ahead limit is */
int look_ahead_cost = (n.m_num_signals_passed < m_sig_look_ahead_costs.size()) ? m_sig_look_ahead_costs[n.m_num_signals_passed] : 0;
int look_ahead_cost = (n.m_num_signals_passed < this->m_sig_look_ahead_costs.size()) ? this->m_sig_look_ahead_costs[n.m_num_signals_passed] : 0;
if (sig_state != SIGNAL_STATE_RED) {
/* green signal */
n.flags_u.flags_s.m_last_signal_was_red = false;
@ -250,7 +250,7 @@ public:
public:
inline void SetMaxCost(int max_cost)
{
m_max_cost = max_cost;
this->m_max_cost = max_cost;
}
/**
@ -450,7 +450,7 @@ no_entry_cost: // jump here at the beginning if the node has no parent (it is th
/* Apply min/max speed penalties only when inside the look-ahead radius. Otherwise
* it would cause desync in MP. */
if (n.m_num_signals_passed < m_sig_look_ahead_costs.size())
if (n.m_num_signals_passed < this->m_sig_look_ahead_costs.size())
{
int min_speed = 0;
int max_speed = tf->GetSpeedLimit(&min_speed);
@ -465,7 +465,7 @@ no_entry_cost: // jump here at the beginning if the node has no parent (it is th
/* Finish if we already exceeded the maximum path cost (i.e. when
* searching for the nearest depot). */
if (m_max_cost > 0 && (parent_cost + segment_entry_cost + segment_cost) > m_max_cost) {
if (this->m_max_cost > 0 && (parent_cost + segment_entry_cost + segment_cost) > this->m_max_cost) {
end_segment_reason |= ESRB_PATH_TOO_LONG;
}
@ -603,9 +603,9 @@ no_entry_cost: // jump here at the beginning if the node has no parent (it is th
inline bool CanUseGlobalCache(Node &n) const
{
return !m_disable_cache
return !this->m_disable_cache
&& (n.m_parent != nullptr)
&& (n.m_parent->m_num_signals_passed >= m_sig_look_ahead_costs.size());
&& (n.m_parent->m_num_signals_passed >= this->m_sig_look_ahead_costs.size());
}
inline void ConnectNodeToCachedData(Node &n, CachedData &ci)
@ -619,7 +619,7 @@ no_entry_cost: // jump here at the beginning if the node has no parent (it is th
void DisableCache(bool disable)
{
m_disable_cache = disable;
this->m_disable_cache = disable;
}
};

46
src/pathfinder/yapf/yapf_destrail.hpp
View File

@ -21,18 +21,18 @@ protected:
public:
void SetDestination(const Train *v, bool override_rail_type = false)
{
m_compatible_railtypes = v->compatible_railtypes;
if (override_rail_type) m_compatible_railtypes |= GetRailTypeInfo(v->railtype)->compatible_railtypes;
this->m_compatible_railtypes = v->compatible_railtypes;
if (override_rail_type) this->m_compatible_railtypes |= GetRailTypeInfo(v->railtype)->compatible_railtypes;
}
bool IsCompatibleRailType(RailType rt)
{
return HasBit(m_compatible_railtypes, rt);
return HasBit(this->m_compatible_railtypes, rt);
}
RailTypes GetCompatibleRailTypes() const
{
return m_compatible_railtypes;
return this->m_compatible_railtypes;
}
};
@ -52,7 +52,7 @@ public:
/** Called by YAPF to detect if node ends in the desired destination */
inline bool PfDetectDestination(Node &n)
{
return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
return this->PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
}
/** Called by YAPF to detect if node ends in the desired destination */
@ -90,7 +90,7 @@ public:
/** Called by YAPF to detect if node ends in the desired destination */
inline bool PfDetectDestination(Node &n)
{
return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
return this->PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
}
/** Called by YAPF to detect if node ends in the desired destination */
@ -133,7 +133,7 @@ protected:
public:
void SetDestination(const Train *v)
{
m_any_depot = false;
this->m_any_depot = false;
switch (v->current_order.GetType()) {
case OT_GOTO_WAYPOINT:
if (!Waypoint::Get(v->current_order.GetDestination())->IsSingleTile()) {
@ -147,46 +147,46 @@ public:
[[fallthrough]];
case OT_GOTO_STATION:
m_destTile = CalcClosestStationTile(v->current_order.GetDestination(), v->tile, v->current_order.IsType(OT_GOTO_STATION) ? STATION_RAIL : STATION_WAYPOINT);
m_dest_station_id = v->current_order.GetDestination();
m_destTrackdirs = INVALID_TRACKDIR_BIT;
this->m_destTile = CalcClosestStationTile(v->current_order.GetDestination(), v->tile, v->current_order.IsType(OT_GOTO_STATION) ? STATION_RAIL : STATION_WAYPOINT);
this->m_dest_station_id = v->current_order.GetDestination();
this->m_destTrackdirs = INVALID_TRACKDIR_BIT;
break;
case OT_GOTO_DEPOT:
if (v->current_order.GetDepotActionType() & ODATFB_NEAREST_DEPOT) {
m_any_depot = true;
this->m_any_depot = true;
}
[[fallthrough]];
default:
m_destTile = v->dest_tile;
m_dest_station_id = INVALID_STATION;
m_destTrackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(v->dest_tile, TRANSPORT_RAIL, 0));
this->m_destTile = v->dest_tile;
this->m_dest_station_id = INVALID_STATION;
this->m_destTrackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(v->dest_tile, TRANSPORT_RAIL, 0));
break;
}
CYapfDestinationRailBase::SetDestination(v);
this->CYapfDestinationRailBase::SetDestination(v);
}
/** Called by YAPF to detect if node ends in the desired destination */
inline bool PfDetectDestination(Node &n)
{
return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
return this->PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
}
/** Called by YAPF to detect if node ends in the desired destination */
inline bool PfDetectDestination(TileIndex tile, Trackdir td)
{
if (m_dest_station_id != INVALID_STATION) {
if (this->m_dest_station_id != INVALID_STATION) {
return HasStationTileRail(tile)
&& (GetStationIndex(tile) == m_dest_station_id)
&& (GetStationIndex(tile) == this->m_dest_station_id)
&& (GetRailStationTrack(tile) == TrackdirToTrack(td));
}
if (m_any_depot) {
if (this->m_any_depot) {
return IsRailDepotTile(tile);
}
return (tile == m_destTile) && HasTrackdir(m_destTrackdirs, td);
return (tile == this->m_destTile) && HasTrackdir(this->m_destTrackdirs, td);
}
/**
@ -197,7 +197,7 @@ public:
{
static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};
if (PfDetectDestination(n)) {
if (this->PfDetectDestination(n)) {
n.m_estimate = n.m_cost;
return true;
}
@ -206,8 +206,8 @@ public:
DiagDirection exitdir = TrackdirToExitdir(n.GetLastTrackdir());
int x1 = 2 * TileX(tile) + dg_dir_to_x_offs[(int)exitdir];
int y1 = 2 * TileY(tile) + dg_dir_to_y_offs[(int)exitdir];
int x2 = 2 * TileX(m_destTile);
int y2 = 2 * TileY(m_destTile);
int x2 = 2 * TileX(this->m_destTile);
int y2 = 2 * TileY(this->m_destTile);
int dx = abs(x1 - x2);
int dy = abs(y1 - y2);
int dmin = std::min(dx, dy);

58
src/pathfinder/yapf/yapf_node.hpp
View File

@ -21,26 +21,26 @@ struct CYapfNodeKeyExitDir {
inline void Set(TileIndex tile, Trackdir td)
{
m_tile = tile;
m_td = td;
m_exitdir = (m_td == INVALID_TRACKDIR) ? INVALID_DIAGDIR : TrackdirToExitdir(m_td);
this->m_tile = tile;
this->m_td = td;
this->m_exitdir = (this->m_td == INVALID_TRACKDIR) ? INVALID_DIAGDIR : TrackdirToExitdir(this->m_td);
}
inline int CalcHash() const
{
return m_exitdir | (m_tile.base() << 2);
return this->m_exitdir | (this->m_tile.base() << 2);
}
inline bool operator==(const CYapfNodeKeyExitDir &other) const
{
return m_tile == other.m_tile && m_exitdir == other.m_exitdir;
return this->m_tile == other.m_tile && this->m_exitdir == other.m_exitdir;
}
void Dump(DumpTarget &dmp) const
{
dmp.WriteTile("m_tile", m_tile);
dmp.WriteEnumT("m_td", m_td);
dmp.WriteEnumT("m_exitdir", m_exitdir);
dmp.WriteTile("m_tile", this->m_tile);
dmp.WriteEnumT("m_td", this->m_td);
dmp.WriteEnumT("m_exitdir", this->m_exitdir);
}
};
@ -48,12 +48,12 @@ struct CYapfNodeKeyTrackDir : public CYapfNodeKeyExitDir
{
inline int CalcHash() const
{
return m_td | (m_tile.base() << 4);
return this->m_td | (this->m_tile.base() << 4);
}
inline bool operator==(const CYapfNodeKeyTrackDir &other) const
{
return m_tile == other.m_tile && m_td == other.m_td;
return this->m_tile == other.m_tile && this->m_td == other.m_td;
}
};
@ -72,65 +72,65 @@ struct CYapfNodeT {
inline void Set(Node *parent, TileIndex tile, Trackdir td, bool is_choice)
{
m_key.Set(tile, td);
m_hash_next = nullptr;
m_parent = parent;
m_cost = 0;
m_estimate = 0;
m_is_choice = is_choice;
this->m_key.Set(tile, td);
this->m_hash_next = nullptr;
this->m_parent = parent;
this->m_cost = 0;
this->m_estimate = 0;
this->m_is_choice = is_choice;
}
inline Node *GetHashNext()
{
return m_hash_next;
return this->m_hash_next;
}
inline void SetHashNext(Node *pNext)
{
m_hash_next = pNext;
this->m_hash_next = pNext;
}
inline TileIndex GetTile() const
{
return m_key.m_tile;
return this->m_key.m_tile;
}
inline Trackdir GetTrackdir() const
{
return m_key.m_td;
return this->m_key.m_td;
}
inline const Tkey_ &GetKey() const
{
return m_key;
return this->m_key;
}
inline int GetCost() const
{
return m_cost;
return this->m_cost;
}
inline int GetCostEstimate() const
{
return m_estimate;
return this->m_estimate;
}
inline bool GetIsChoice() const
{
return m_is_choice;
return this->m_is_choice;
}
inline bool operator<(const Node &other) const
{
return m_estimate < other.m_estimate;
return this->m_estimate < other.m_estimate;
}
void Dump(DumpTarget &dmp) const
{
dmp.WriteStructT("m_key", &m_key);
dmp.WriteStructT("m_parent", m_parent);
dmp.WriteValue("m_cost", m_cost);
dmp.WriteValue("m_estimate", m_estimate);
dmp.WriteStructT("m_key", &this->m_key);
dmp.WriteStructT("m_parent", this->m_parent);
dmp.WriteValue("m_cost", this->m_cost);
dmp.WriteValue("m_estimate", this->m_estimate);
}
};

96
src/pathfinder/yapf/yapf_node_rail.hpp
View File

@ -23,43 +23,43 @@ struct CYapfRailSegmentKey
inline CYapfRailSegmentKey(const CYapfNodeKeyTrackDir &node_key)
{
Set(node_key);
this->Set(node_key);
}
inline void Set(const CYapfRailSegmentKey &src)
{
m_value = src.m_value;
this->m_value = src.m_value;
}
inline void Set(const CYapfNodeKeyTrackDir &node_key)
{
m_value = (node_key.m_tile.base() << 4) | node_key.m_td;
this->m_value = (node_key.m_tile.base() << 4) | node_key.m_td;
}
inline int32_t CalcHash() const
{
return m_value;
return this->m_value;
}
inline TileIndex GetTile() const
{
return (TileIndex)(m_value >> 4);
return (TileIndex)(this->m_value >> 4);
}
inline Trackdir GetTrackdir() const
{
return (Trackdir)(m_value & 0x0F);
return (Trackdir)(this->m_value & 0x0F);
}
inline bool operator==(const CYapfRailSegmentKey &other) const
{
return m_value == other.m_value;
return this->m_value == other.m_value;
}
void Dump(DumpTarget &dmp) const
{
dmp.WriteTile("tile", GetTile());
dmp.WriteEnumT("td", GetTrackdir());
dmp.WriteTile("tile", this->GetTile());
dmp.WriteEnumT("td", this->GetTrackdir());
}
};
@ -90,33 +90,33 @@ struct CYapfRailSegment
inline const Key &GetKey() const
{
return m_key;
return this->m_key;
}
inline TileIndex GetTile() const
{
return m_key.GetTile();
return this->m_key.GetTile();
}
inline CYapfRailSegment *GetHashNext()
{
return m_hash_next;
return this->m_hash_next;
}
inline void SetHashNext(CYapfRailSegment *next)
{
m_hash_next = next;
this->m_hash_next = next;
}
void Dump(DumpTarget &dmp) const
{
dmp.WriteStructT("m_key", &m_key);
dmp.WriteTile("m_last_tile", m_last_tile);
dmp.WriteEnumT("m_last_td", m_last_td);
dmp.WriteValue("m_cost", m_cost);
dmp.WriteTile("m_last_signal_tile", m_last_signal_tile);
dmp.WriteEnumT("m_last_signal_td", m_last_signal_td);
dmp.WriteEnumT("m_end_segment_reason", m_end_segment_reason);
dmp.WriteStructT("m_key", &this->m_key);
dmp.WriteTile("m_last_tile", this->m_last_tile);
dmp.WriteEnumT("m_last_td", this->m_last_td);
dmp.WriteValue("m_cost", this->m_cost);
dmp.WriteTile("m_last_signal_tile", this->m_last_signal_tile);
dmp.WriteEnumT("m_last_signal_td", this->m_last_signal_td);
dmp.WriteEnumT("m_end_segment_reason", this->m_end_segment_reason);
}
};
@ -143,12 +143,12 @@ struct CYapfRailNodeT
inline void Set(CYapfRailNodeT *parent, TileIndex tile, Trackdir td, bool is_choice)
{
base::Set(parent, tile, td, is_choice);
m_segment = nullptr;
this->base::Set(parent, tile, td, is_choice);
this->m_segment = nullptr;
if (parent == nullptr) {
m_num_signals_passed = 0;
flags_u.m_inherited_flags = 0;
m_last_red_signal_type = SIGTYPE_BLOCK;
this->m_num_signals_passed = 0;
this->flags_u.m_inherited_flags = 0;
this->m_last_red_signal_type = SIGTYPE_BLOCK;
/* We use PBS as initial signal type because if we are in
* a PBS section and need to route, i.e. we're at a safe
* waiting point of a station, we need to account for the
@ -159,43 +159,43 @@ struct CYapfRailNodeT
* then avoiding that train with help of the reservation
* costs is not a bad thing, actually it would probably
* be a good thing to do. */
m_last_signal_type = SIGTYPE_PBS;
this->m_last_signal_type = SIGTYPE_PBS;
} else {
m_num_signals_passed = parent->m_num_signals_passed;
flags_u.m_inherited_flags = parent->flags_u.m_inherited_flags;
m_last_red_signal_type = parent->m_last_red_signal_type;
m_last_signal_type = parent->m_last_signal_type;
this->m_num_signals_passed = parent->m_num_signals_passed;
this->flags_u.m_inherited_flags = parent->flags_u.m_inherited_flags;
this->m_last_red_signal_type = parent->m_last_red_signal_type;
this->m_last_signal_type = parent->m_last_signal_type;
}
flags_u.flags_s.m_choice_seen |= is_choice;
this->flags_u.flags_s.m_choice_seen |= is_choice;
}
inline TileIndex GetLastTile() const
{
assert(m_segment != nullptr);
return m_segment->m_last_tile;
assert(this->m_segment != nullptr);
return this->m_segment->m_last_tile;
}
inline Trackdir GetLastTrackdir() const
{
assert(m_segment != nullptr);
return m_segment->m_last_td;
assert(this->m_segment != nullptr);
return this->m_segment->m_last_td;
}
inline void SetLastTileTrackdir(TileIndex tile, Trackdir td)
{
assert(m_segment != nullptr);
m_segment->m_last_tile = tile;
m_segment->m_last_td = td;
assert(this->m_segment != nullptr);
this->m_segment->m_last_tile = tile;
this->m_segment->m_last_td = td;
}
template <class Tbase, class Tfunc, class Tpf>
bool IterateTiles(const Train *v, Tpf &yapf, Tbase &obj, bool (Tfunc::*func)(TileIndex, Trackdir)) const
{
typename Tbase::TrackFollower ft(v, yapf.GetCompatibleRailTypes());
TileIndex cur = base::GetTile();
Trackdir cur_td = base::GetTrackdir();
TileIndex cur = this->base::GetTile();
Trackdir cur_td = this->base::GetTrackdir();
while (cur != GetLastTile() || cur_td != GetLastTrackdir()) {
while (cur != this->GetLastTile() || cur_td != this->GetLastTrackdir()) {
if (!((obj.*func)(cur, cur_td))) return false;
if (!ft.Follow(cur, cur_td)) break;
@ -209,13 +209,13 @@ struct CYapfRailNodeT
void Dump(DumpTarget &dmp) const
{
base::Dump(dmp);
dmp.WriteStructT("m_segment", m_segment);
dmp.WriteValue("m_num_signals_passed", m_num_signals_passed);
dmp.WriteValue("m_targed_seen", flags_u.flags_s.m_targed_seen ? "Yes" : "No");
dmp.WriteValue("m_choice_seen", flags_u.flags_s.m_choice_seen ? "Yes" : "No");
dmp.WriteValue("m_last_signal_was_red", flags_u.flags_s.m_last_signal_was_red ? "Yes" : "No");
dmp.WriteEnumT("m_last_red_signal_type", m_last_red_signal_type);
this->base::Dump(dmp);
dmp.WriteStructT("m_segment", this->m_segment);
dmp.WriteValue("m_num_signals_passed", this->m_num_signals_passed);
dmp.WriteValue("m_targed_seen", this->flags_u.flags_s.m_targed_seen ? "Yes" : "No");
dmp.WriteValue("m_choice_seen", this->flags_u.flags_s.m_choice_seen ? "Yes" : "No");
dmp.WriteValue("m_last_signal_was_red", this->flags_u.flags_s.m_last_signal_was_red ? "Yes" : "No");
dmp.WriteEnumT("m_last_red_signal_type", this->m_last_red_signal_type);
}
};

6
src/pathfinder/yapf/yapf_node_road.hpp
View File

@ -25,9 +25,9 @@ struct CYapfRoadNodeT : CYapfNodeT<Tkey_, CYapfRoadNodeT<Tkey_> > {
void Set(CYapfRoadNodeT *parent, TileIndex tile, Trackdir td, bool is_choice)
{
base::Set(parent, tile, td, is_choice);
m_segment_last_tile = tile;
m_segment_last_td = td;
this->base::Set(parent, tile, td, is_choice);
this->m_segment_last_tile = tile;
this->m_segment_last_td = td;
}
};

6
src/pathfinder/yapf/yapf_node_ship.hpp
View File

@ -25,9 +25,9 @@ struct CYapfShipNodeT : CYapfNodeT<Tkey_, CYapfShipNodeT<Tkey_> > {
void Set(CYapfShipNodeT *parent, TileIndex tile, Trackdir td, bool is_choice)
{
base::Set(parent, tile, td, is_choice);
m_segment_last_tile = tile;
m_segment_last_td = td;
this->base::Set(parent, tile, td, is_choice);
this->m_segment_last_tile = tile;
this->m_segment_last_td = td;
}
};

58
src/pathfinder/yapf/yapf_rail.cpp
View File

@ -60,8 +60,8 @@ private:
bool FindSafePositionProc(TileIndex tile, Trackdir td)
{
if (IsSafeWaitingPosition(Yapf().GetVehicle(), tile, td, true, !TrackFollower::Allow90degTurns())) {
m_res_dest = tile;
m_res_dest_td = td;
this->m_res_dest = tile;
this->m_res_dest_td = td;
return false; // Stop iterating segment
}
return true;
@ -78,7 +78,7 @@ private:
SetRailStationReservation(tile, true);
MarkTileDirtyByTile(tile);
tile = TileAdd(tile, diff);
} while (IsCompatibleTrainStationTile(tile, start) && tile != m_origin_tile);
} while (IsCompatibleTrainStationTile(tile, start) && tile != this->m_origin_tile);
TriggerStationRandomisation(nullptr, start, SRT_PATH_RESERVATION);
@ -92,26 +92,26 @@ private:
if (IsRailStationTile(tile)) {
if (!ReserveRailStationPlatform(tile, TrackdirToExitdir(rev_td))) {
/* Platform could not be reserved, undo. */
m_res_fail_tile = tile;
m_res_fail_td = td;
this->m_res_fail_tile = tile;
this->m_res_fail_td = td;
}
} else {
if (!TryReserveRailTrack(tile, TrackdirToTrack(td))) {
/* Tile couldn't be reserved, undo. */
m_res_fail_tile = tile;
m_res_fail_td = td;
this->m_res_fail_tile = tile;
this->m_res_fail_td = td;
return false;
}
/* Green path signal opposing the path? Turn to red. */
if (HasPbsSignalOnTrackdir(tile, rev_td) && GetSignalStateByTrackdir(tile, rev_td) == SIGNAL_STATE_GREEN) {
m_signals_set_to_red.emplace_back(tile, rev_td);
this->m_signals_set_to_red.emplace_back(tile, rev_td);
SetSignalStateByTrackdir(tile, rev_td, SIGNAL_STATE_RED);
MarkTileDirtyByTile(tile);
}
}
return tile != m_res_dest || td != m_res_dest_td;
return tile != this->m_res_dest || td != this->m_res_dest_td;
}
/** Unreserve a single track/platform. Stops when the previous failer is reached. */
@ -120,23 +120,23 @@ private:
if (IsRailStationTile(tile)) {
TileIndex start = tile;
TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(td)));
while ((tile != m_res_fail_tile || td != m_res_fail_td) && IsCompatibleTrainStationTile(tile, start)) {
while ((tile != this->m_res_fail_tile || td != this->m_res_fail_td) && IsCompatibleTrainStationTile(tile, start)) {
SetRailStationReservation(tile, false);
tile = TileAdd(tile, diff);
}
} else if (tile != m_res_fail_tile || td != m_res_fail_td) {
} else if (tile != this->m_res_fail_tile || td != this->m_res_fail_td) {
UnreserveRailTrack(tile, TrackdirToTrack(td));
}
return (tile != m_res_dest || td != m_res_dest_td) && (tile != m_res_fail_tile || td != m_res_fail_td);
return (tile != this->m_res_dest || td != this->m_res_dest_td) && (tile != this->m_res_fail_tile || td != this->m_res_fail_td);
}
public:
/** Set the target to where the reservation should be extended. */
inline void SetReservationTarget(Node *node, TileIndex tile, Trackdir td)
{
m_res_node = node;
m_res_dest = tile;
m_res_dest_td = td;
this->m_res_node = node;
this->m_res_dest = tile;
this->m_res_dest_td = td;
}
/** Check the node for a possible reservation target. */
@ -148,40 +148,40 @@ public:
if (node->m_parent->m_num_signals_passed >= 2) return;
if (!node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack<Types>::FindSafePositionProc)) {
m_res_node = node;
this->m_res_node = node;
}
}
/** Try to reserve the path till the reservation target. */
bool TryReservePath(PBSTileInfo *target, TileIndex origin)
{
m_res_fail_tile = INVALID_TILE;
m_origin_tile = origin;
this->m_res_fail_tile = INVALID_TILE;
this->m_origin_tile = origin;
if (target != nullptr) {
target->tile = m_res_dest;
target->trackdir = m_res_dest_td;
target->tile = this->m_res_dest;
target->trackdir = this->m_res_dest_td;
target->okay = false;
}
/* Don't bother if the target is reserved. */
if (!IsWaitingPositionFree(Yapf().GetVehicle(), m_res_dest, m_res_dest_td)) return false;
if (!IsWaitingPositionFree(Yapf().GetVehicle(), this->m_res_dest, this->m_res_dest_td)) return false;
m_signals_set_to_red.clear();
for (Node *node = m_res_node; node->m_parent != nullptr; node = node->m_parent) {
this->m_signals_set_to_red.clear();
for (Node *node = this->m_res_node; node->m_parent != nullptr; node = node->m_parent) {
node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack<Types>::ReserveSingleTrack);
if (m_res_fail_tile != INVALID_TILE) {
if (this->m_res_fail_tile != INVALID_TILE) {
/* Reservation failed, undo. */
Node *fail_node = m_res_node;
TileIndex stop_tile = m_res_fail_tile;
Node *fail_node = this->m_res_node;
TileIndex stop_tile = this->m_res_fail_tile;
do {
/* If this is the node that failed, stop at the failed tile. */
m_res_fail_tile = fail_node == node ? stop_tile : INVALID_TILE;
this->m_res_fail_tile = fail_node == node ? stop_tile : INVALID_TILE;
fail_node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack<Types>::UnreserveSingleTrack);
} while (fail_node != node && (fail_node = fail_node->m_parent) != nullptr);
/* Re-instate green path signals we turned to red. */
for (auto [sig_tile, td] : m_signals_set_to_red) {
for (auto [sig_tile, td] : this->m_signals_set_to_red) {
SetSignalStateByTrackdir(sig_tile, td, SIGNAL_STATE_GREEN);
}
@ -191,7 +191,7 @@ public:
if (target != nullptr) target->okay = true;
if (Yapf().CanUseGlobalCache(*m_res_node)) {
if (Yapf().CanUseGlobalCache(*this->m_res_node)) {
YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
}

52
src/pathfinder/yapf/yapf_road.cpp
View File

@ -103,7 +103,7 @@ protected:
public:
inline void SetMaxCost(int max_cost)
{
m_max_cost = max_cost;
this->m_max_cost = max_cost;
}
/**
@ -130,7 +130,7 @@ public:
/* Finish if we already exceeded the maximum path cost (i.e. when
* searching for the nearest depot). */
if (m_max_cost > 0 && (parent_cost + segment_cost) > m_max_cost) {
if (this->m_max_cost > 0 && (parent_cost + segment_cost) > this->m_max_cost) {
return false;
}
@ -241,27 +241,27 @@ public:
void SetDestination(const RoadVehicle *v)
{
if (v->current_order.IsType(OT_GOTO_STATION)) {
m_dest_station = v->current_order.GetDestination();
m_station_type = v->IsBus() ? STATION_BUS : STATION_TRUCK;
m_destTile = CalcClosestStationTile(m_dest_station, v->tile, m_station_type);
m_non_artic = !v->HasArticulatedPart();
m_destTrackdirs = INVALID_TRACKDIR_BIT;
this->m_dest_station = v->current_order.GetDestination();
this->m_station_type = v->IsBus() ? STATION_BUS : STATION_TRUCK;
this->m_destTile = CalcClosestStationTile(this->m_dest_station, v->tile, this->m_station_type);
this->m_non_artic = !v->HasArticulatedPart();
this->m_destTrackdirs = INVALID_TRACKDIR_BIT;
} else if (v->current_order.IsType(OT_GOTO_WAYPOINT)) {
m_dest_station = v->current_order.GetDestination();
m_station_type = STATION_ROADWAYPOINT;
m_destTile = CalcClosestStationTile(m_dest_station, v->tile, m_station_type);
m_non_artic = !v->HasArticulatedPart();
m_destTrackdirs = INVALID_TRACKDIR_BIT;
this->m_dest_station = v->current_order.GetDestination();
this->m_station_type = STATION_ROADWAYPOINT;
this->m_destTile = CalcClosestStationTile(this->m_dest_station, v->tile, this->m_station_type);
this->m_non_artic = !v->HasArticulatedPart();
this->m_destTrackdirs = INVALID_TRACKDIR_BIT;
} else {
m_dest_station = INVALID_STATION;
m_destTile = v->dest_tile;
m_destTrackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(v->dest_tile, TRANSPORT_ROAD, GetRoadTramType(v->roadtype)));
this->m_dest_station = INVALID_STATION;
this->m_destTile = v->dest_tile;
this->m_destTrackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(v->dest_tile, TRANSPORT_ROAD, GetRoadTramType(v->roadtype)));
}
}
const Station *GetDestinationStation() const
{
return m_dest_station != INVALID_STATION ? Station::GetIfValid(m_dest_station) : nullptr;
return this->m_dest_station != INVALID_STATION ? Station::GetIfValid(this->m_dest_station) : nullptr;
}
protected:
@ -275,19 +275,19 @@ public:
/** Called by YAPF to detect if node ends in the desired destination */
inline bool PfDetectDestination(Node &n)
{
return PfDetectDestinationTile(n.m_segment_last_tile, n.m_segment_last_td);
return this->PfDetectDestinationTile(n.m_segment_last_tile, n.m_segment_last_td);
}
inline bool PfDetectDestinationTile(TileIndex tile, Trackdir trackdir)
{
if (m_dest_station != INVALID_STATION) {
if (this->m_dest_station != INVALID_STATION) {
return IsTileType(tile, MP_STATION) &&
GetStationIndex(tile) == m_dest_station &&
(m_station_type == GetStationType(tile)) &&
(m_non_artic || IsDriveThroughStopTile(tile));
GetStationIndex(tile) == this->m_dest_station &&
(this->m_station_type == GetStationType(tile)) &&
(this->m_non_artic || IsDriveThroughStopTile(tile));
}
return tile == m_destTile && HasTrackdir(m_destTrackdirs, trackdir);
return tile == this->m_destTile && HasTrackdir(this->m_destTrackdirs, trackdir);
}
/**
@ -298,7 +298,7 @@ public:
{
static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};
if (PfDetectDestination(n)) {
if (this->PfDetectDestination(n)) {
n.m_estimate = n.m_cost;
return true;
}
@ -307,8 +307,8 @@ public:
DiagDirection exitdir = TrackdirToExitdir(n.m_segment_last_td);
int x1 = 2 * TileX(tile) + dg_dir_to_x_offs[(int)exitdir];
int y1 = 2 * TileY(tile) + dg_dir_to_y_offs[(int)exitdir];
int x2 = 2 * TileX(m_destTile);
int y2 = 2 * TileY(m_destTile);
int x2 = 2 * TileX(this->m_destTile);
int y2 = 2 * TileY(this->m_destTile);
int dx = abs(x1 - x2);
int dy = abs(y1 - y2);
int dmin = std::min(dx, dy);
@ -443,7 +443,7 @@ public:
return 0;
}
if (!SetOriginFromVehiclePos(v)) return UINT_MAX;
if (!this->SetOriginFromVehiclePos(v)) return UINT_MAX;
/* get available trackdirs on the destination tile */
Yapf().SetDestination(v);

48
src/pathfinder/yapf/yapf_ship.cpp
View File

@ -46,21 +46,21 @@ public:
void SetDestination(const Ship *v)
{
if (v->current_order.IsType(OT_GOTO_STATION)) {
m_destStation = v->current_order.GetDestination();
m_destTile = CalcClosestStationTile(m_destStation, v->tile, STATION_DOCK);
m_destTrackdirs = INVALID_TRACKDIR_BIT;
this->m_destStation = v->current_order.GetDestination();
this->m_destTile = CalcClosestStationTile(this->m_destStation, v->tile, STATION_DOCK);
this->m_destTrackdirs = INVALID_TRACKDIR_BIT;
} else {
m_destStation = INVALID_STATION;
m_destTile = v->dest_tile;
m_destTrackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(v->dest_tile, TRANSPORT_WATER, 0));
this->m_destStation = INVALID_STATION;
this->m_destTile = v->dest_tile;
this->m_destTrackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(v->dest_tile, TRANSPORT_WATER, 0));
}
}
void SetIntermediateDestination(const WaterRegionPatchDesc &water_region_patch)
{
m_has_intermediate_dest = true;
m_intermediate_dest_tile = GetWaterRegionCenterTile(water_region_patch);
m_intermediate_dest_region_patch = water_region_patch;
this->m_has_intermediate_dest = true;
this->m_intermediate_dest_tile = GetWaterRegionCenterTile(water_region_patch);
this->m_intermediate_dest_region_patch = water_region_patch;
}
protected:
@ -74,20 +74,20 @@ public:
/** Called by YAPF to detect if node ends in the desired destination. */
inline bool PfDetectDestination(Node &n)
{
return PfDetectDestinationTile(n.m_segment_last_tile, n.m_segment_last_td);
return this->PfDetectDestinationTile(n.m_segment_last_tile, n.m_segment_last_td);
}
inline bool PfDetectDestinationTile(TileIndex tile, Trackdir trackdir)
{
if (m_has_intermediate_dest) {
if (this->m_has_intermediate_dest) {
/* GetWaterRegionInfo is much faster than GetWaterRegionPatchInfo so we try that first. */
if (GetWaterRegionInfo(tile) != m_intermediate_dest_region_patch) return false;
return GetWaterRegionPatchInfo(tile) == m_intermediate_dest_region_patch;
if (GetWaterRegionInfo(tile) != this->m_intermediate_dest_region_patch) return false;
return GetWaterRegionPatchInfo(tile) == this->m_intermediate_dest_region_patch;
}
if (m_destStation != INVALID_STATION) return IsDockingTile(tile) && IsShipDestinationTile(tile, m_destStation);
if (this->m_destStation != INVALID_STATION) return IsDockingTile(tile) && IsShipDestinationTile(tile, this->m_destStation);
return tile == m_destTile && ((m_destTrackdirs & TrackdirToTrackdirBits(trackdir)) != TRACKDIR_BIT_NONE);
return tile == this->m_destTile && ((this->m_destTrackdirs & TrackdirToTrackdirBits(trackdir)) != TRACKDIR_BIT_NONE);
}
/**
@ -96,11 +96,11 @@ public:
*/
inline bool PfCalcEstimate(Node &n)
{
const TileIndex destination_tile = m_has_intermediate_dest ? m_intermediate_dest_tile : m_destTile;
const TileIndex destination_tile = this->m_has_intermediate_dest ? this->m_intermediate_dest_tile : this->m_destTile;
static const int dg_dir_to_x_offs[] = { -1, 0, 1, 0 };
static const int dg_dir_to_y_offs[] = { 0, 1, 0, -1 };
if (PfDetectDestination(n)) {
if (this->PfDetectDestination(n)) {
n.m_estimate = n.m_cost;
return true;
}
@ -151,9 +151,9 @@ public:
{
TrackFollower F(Yapf().GetVehicle());
if (F.Follow(old_node.m_key.m_tile, old_node.m_key.m_td)) {
if (m_water_region_corridor.empty()
|| std::find(m_water_region_corridor.begin(), m_water_region_corridor.end(),
GetWaterRegionInfo(F.m_new_tile)) != m_water_region_corridor.end()) {
if (this->m_water_region_corridor.empty()
|| std::find(this->m_water_region_corridor.begin(), this->m_water_region_corridor.end(),
GetWaterRegionInfo(F.m_new_tile)) != this->m_water_region_corridor.end()) {
Yapf().AddMultipleNodes(&old_node, F);
}
}
@ -162,8 +162,8 @@ public:
/** Restricts the search by creating corridor or water regions through which the ship is allowed to travel. */
inline void RestrictSearch(const std::vector<WaterRegionPatchDesc> &path)
{
m_water_region_corridor.clear();
for (const WaterRegionPatchDesc &path_entry : path) m_water_region_corridor.push_back(path_entry);
this->m_water_region_corridor.clear();
for (const WaterRegionPatchDesc &path_entry : path) this->m_water_region_corridor.push_back(path_entry);
}
/** Return debug report character to identify the transportation type. */
@ -373,7 +373,7 @@ public:
/* Base tile cost depending on distance. */
int c = IsDiagonalTrackdir(n.GetTrackdir()) ? YAPF_TILE_LENGTH : YAPF_TILE_CORNER_LENGTH;
/* Additional penalty for curves. */
c += CurveCost(n.m_parent->GetTrackdir(), n.GetTrackdir());
c += this->CurveCost(n.m_parent->GetTrackdir(), n.GetTrackdir());
if (IsDockingTile(n.GetTile())) {
/* Check docking tile for occupancy. */
@ -420,7 +420,7 @@ struct CYapfShip_TypesT
struct CYapfShip : CYapfT<CYapfShip_TypesT<CYapfShip, CFollowTrackWater, CShipNodeListExitDir > >
{
explicit CYapfShip(int max_nodes) { m_max_search_nodes = max_nodes; }
explicit CYapfShip(int max_nodes) { this->m_max_search_nodes = max_nodes; }
};
/** Ship controller helper - path finder invoker. */

52
src/pathfinder/yapf/yapf_ship_regions.cpp
View File

@ -26,11 +26,11 @@ struct CYapfRegionPatchNodeKey {
inline void Set(const WaterRegionPatchDesc &water_region_patch)
{
m_water_region_patch = water_region_patch;
this->m_water_region_patch = water_region_patch;
}
inline int CalcHash() const { return CalculateWaterRegionPatchHash(m_water_region_patch); }
inline bool operator==(const CYapfRegionPatchNodeKey &other) const { return CalcHash() == other.CalcHash(); }
inline int CalcHash() const { return CalculateWaterRegionPatchHash(this->m_water_region_patch); }
inline bool operator==(const CYapfRegionPatchNodeKey &other) const { return this->CalcHash() == other.CalcHash(); }
};
inline uint ManhattanDistance(const CYapfRegionPatchNodeKey &a, const CYapfRegionPatchNodeKey &b)
@ -52,23 +52,23 @@ struct CYapfRegionNodeT {
inline void Set(Node *parent, const WaterRegionPatchDesc &water_region_patch)
{
m_key.Set(water_region_patch);
m_hash_next = nullptr;
m_parent = parent;
m_cost = 0;
m_estimate = 0;
this->m_key.Set(water_region_patch);
this->m_hash_next = nullptr;
this->m_parent = parent;
this->m_cost = 0;
this->m_estimate = 0;
}
inline void Set(Node *parent, const Key &key)
{
Set(parent, key.m_water_region_patch);
this->Set(parent, key.m_water_region_patch);
}
DiagDirection GetDiagDirFromParent() const
{
if (!m_parent) return INVALID_DIAGDIR;
const int dx = m_key.m_water_region_patch.x - m_parent->m_key.m_water_region_patch.x;
const int dy = m_key.m_water_region_patch.y - m_parent->m_key.m_water_region_patch.y;
if (!this->m_parent) return INVALID_DIAGDIR;
const int dx = this->m_key.m_water_region_patch.x - this->m_parent->m_key.m_water_region_patch.x;
const int dy = this->m_key.m_water_region_patch.y - this->m_parent->m_key.m_water_region_patch.y;
if (dx > 0 && dy == 0) return DIAGDIR_SW;
if (dx < 0 && dy == 0) return DIAGDIR_NE;
if (dx == 0 && dy > 0) return DIAGDIR_SE;
@ -76,12 +76,12 @@ struct CYapfRegionNodeT {
return INVALID_DIAGDIR;
}
inline Node *GetHashNext() { return m_hash_next; }
inline void SetHashNext(Node *pNext) { m_hash_next = pNext; }
inline const Tkey_ &GetKey() const { return m_key; }
inline int GetCost() { return m_cost; }
inline int GetCostEstimate() { return m_estimate; }
inline bool operator<(const Node &other) const { return m_estimate < other.m_estimate; }
inline Node *GetHashNext() { return this->m_hash_next; }
inline void SetHashNext(Node *pNext) { this->m_hash_next = pNext; }
inline const Tkey_ &GetKey() const { return this->m_key; }
inline int GetCost() { return this->m_cost; }
inline int GetCostEstimate() { return this->m_estimate; }
inline bool operator<(const Node &other) const { return this->m_estimate < other.m_estimate; }
};
/** YAPF origin for water regions. */
@ -103,17 +103,17 @@ public:
void AddOrigin(const WaterRegionPatchDesc &water_region_patch)
{
if (water_region_patch.label == INVALID_WATER_REGION_PATCH) return;
if (!HasOrigin(water_region_patch)) m_origin_keys.push_back(CYapfRegionPatchNodeKey{ water_region_patch });
if (!HasOrigin(water_region_patch)) this->m_origin_keys.push_back(CYapfRegionPatchNodeKey{ water_region_patch });
}
bool HasOrigin(const WaterRegionPatchDesc &water_region_patch)
{
return std::find(m_origin_keys.begin(), m_origin_keys.end(), CYapfRegionPatchNodeKey{ water_region_patch }) != m_origin_keys.end();
return std::find(this->m_origin_keys.begin(), this->m_origin_keys.end(), CYapfRegionPatchNodeKey{ water_region_patch }) != this->m_origin_keys.end();
}
void PfSetStartupNodes()
{
for (const CYapfRegionPatchNodeKey &origin_key : m_origin_keys) {
for (const CYapfRegionPatchNodeKey &origin_key : this->m_origin_keys) {
Node &node = Yapf().CreateNewNode();
node.Set(nullptr, origin_key);
Yapf().AddStartupNode(node);
@ -136,7 +136,7 @@ protected:
public:
void SetDestination(const WaterRegionPatchDesc &water_region_patch)
{
m_dest.Set(water_region_patch);
this->m_dest.Set(water_region_patch);
}
protected:
@ -145,17 +145,17 @@ protected:
public:
inline bool PfDetectDestination(Node &n) const
{
return n.m_key == m_dest;
return n.m_key == this->m_dest;
}
inline bool PfCalcEstimate(Node &n)
{
if (PfDetectDestination(n)) {
if (this->PfDetectDestination(n)) {
n.m_estimate = n.m_cost;
return true;
}
n.m_estimate = n.m_cost + ManhattanDistance(n.m_key, m_dest);
n.m_estimate = n.m_cost + ManhattanDistance(n.m_key, this->m_dest);
return true;
}
@ -297,7 +297,7 @@ typedef CNodeList_HashTableT<CYapfRegionNodeT<CYapfRegionPatchNodeKey>, 12, 12>
struct CYapfRegionWater : CYapfT<CYapfRegion_TypesT<CYapfRegionWater, CRegionNodeListWater>>
{
explicit CYapfRegionWater(int max_nodes) { m_max_search_nodes = max_nodes; }
explicit CYapfRegionWater(int max_nodes) { this->m_max_search_nodes = max_nodes; }
};
/**