diff --git a/src/yapf/yapf_rail.cpp b/src/yapf/yapf_rail.cpp deleted file mode 100644 --- a/src/yapf/yapf_rail.cpp +++ /dev/null @@ -1,645 +0,0 @@ -/* $Id$ */ - -/* - * This file is part of OpenTTD. - * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2. - * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see . - */ - -/** @file yapf_rail.cpp The rail pathfinding. */ - -#include "../stdafx.h" - -#include "yapf.hpp" -#include "yapf_node_rail.hpp" -#include "yapf_costrail.hpp" -#include "yapf_destrail.hpp" -#include "../functions.h" - -#define DEBUG_YAPF_CACHE 0 - -#if DEBUG_YAPF_CACHE -template void DumpState(Tpf &pf1, Tpf &pf2) -{ - DumpTarget dmp1, dmp2; - pf1.DumpBase(dmp1); - pf2.DumpBase(dmp2); - FILE *f1 = fopen("yapf1.txt", "wt"); - FILE *f2 = fopen("yapf2.txt", "wt"); - fwrite(dmp1.m_out.Data(), 1, dmp1.m_out.Size(), f1); - fwrite(dmp2.m_out.Data(), 1, dmp2.m_out.Size(), f2); - fclose(f1); - fclose(f2); -} -#endif - -int _total_pf_time_us = 0; - -template -class CYapfReserveTrack -{ -public: - typedef typename Types::Tpf Tpf; ///< the pathfinder class (derived from THIS class) - typedef typename Types::TrackFollower TrackFollower; - typedef typename Types::NodeList::Titem Node; ///< this will be our node type - -protected: - /** to access inherited pathfinder */ - FORCEINLINE Tpf& Yapf() - { - return *static_cast(this); - } - -private: - TileIndex m_res_dest; ///< The reservation target tile - Trackdir m_res_dest_td; ///< The reservation target trackdir - Node *m_res_node; ///< The reservation target node - TileIndex m_res_fail_tile; ///< The tile where the reservation failed - Trackdir m_res_fail_td; ///< The trackdir where the reservation failed - - bool FindSafePositionProc(TileIndex tile, Trackdir td) - { - if (IsSafeWaitingPosition(Train::From(Yapf().GetVehicle()), tile, td, true, !TrackFollower::Allow90degTurns())) { - m_res_dest = tile; - m_res_dest_td = td; - return false; // Stop iterating segment - } - return true; - } - - /** Reserve a railway platform. Tile contains the failed tile on abort. */ - bool ReserveRailStationPlatform(TileIndex &tile, DiagDirection dir) - { - TileIndex start = tile; - TileIndexDiff diff = TileOffsByDiagDir(dir); - - do { - if (HasStationReservation(tile)) return false; - SetRailStationReservation(tile, true); - MarkTileDirtyByTile(tile); - tile = TILE_ADD(tile, diff); - } while (IsCompatibleTrainStationTile(tile, start)); - - return true; - } - - /** Try to reserve a single track/platform. */ - bool ReserveSingleTrack(TileIndex tile, Trackdir td) - { - if (IsRailStationTile(tile)) { - if (!ReserveRailStationPlatform(tile, TrackdirToExitdir(ReverseTrackdir(td)))) { - /* Platform could not be reserved, undo. */ - m_res_fail_tile = tile; - 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; - return false; - } - } - - return tile != m_res_dest || td != m_res_dest_td; - } - - /** Unreserve a single track/platform. Stops when the previous failer is reached. */ - bool UnreserveSingleTrack(TileIndex tile, Trackdir td) - { - 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)) { - SetRailStationReservation(tile, false); - tile = TILE_ADD(tile, diff); - } - } else if (tile != m_res_fail_tile || td != 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); - } - -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; - } - - /** Check the node for a possible reservation target. */ - inline void FindSafePositionOnNode(Node *node) - { - assert(node->m_parent != NULL); - - /* We will never pass more than two signals, no need to check for a safe tile. */ - if (node->m_parent->m_num_signals_passed >= 2) return; - - if (!node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack::FindSafePositionProc)) { - m_res_node = node; - } - } - - /** Try to reserve the path till the reservation target. */ - bool TryReservePath(PBSTileInfo *target) - { - m_res_fail_tile = INVALID_TILE; - - if (target != NULL) { - target->tile = m_res_dest; - target->trackdir = m_res_dest_td; - target->okay = false; - } - - /* Don't bother if the target is reserved. */ - if (!IsWaitingPositionFree(Train::From(Yapf().GetVehicle()), m_res_dest, m_res_dest_td)) return false; - - for (Node *node = m_res_node; node->m_parent != NULL; node = node->m_parent) { - node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack::ReserveSingleTrack); - if (m_res_fail_tile != INVALID_TILE) { - /* Reservation failed, undo. */ - Node *fail_node = m_res_node; - TileIndex stop_tile = 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; - fail_node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack::UnreserveSingleTrack); - } while (fail_node != node && (fail_node = fail_node->m_parent) != NULL); - - return false; - } - } - - if (target != NULL) target->okay = true; - - if (Yapf().CanUseGlobalCache(*m_res_node)) - YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK); - - return true; - } -}; - -template -class CYapfFollowAnyDepotRailT -{ -public: - typedef typename Types::Tpf Tpf; ///< the pathfinder class (derived from THIS class) - typedef typename Types::TrackFollower TrackFollower; - typedef typename Types::NodeList::Titem Node; ///< this will be our node type - typedef typename Node::Key Key; ///< key to hash tables - -protected: - /** to access inherited path finder */ - FORCEINLINE Tpf& Yapf() - { - return *static_cast(this); - } - -public: - /** Called by YAPF to move from the given node to the next tile. For each - * reachable trackdir on the new tile creates new node, initializes it - * and adds it to the open list by calling Yapf().AddNewNode(n) */ - inline void PfFollowNode(Node& old_node) - { - TrackFollower F(Yapf().GetVehicle()); - if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir())) { - Yapf().AddMultipleNodes(&old_node, F); - } - } - - /** return debug report character to identify the transportation type */ - FORCEINLINE char TransportTypeChar() const - { - return 't'; - } - - static bool stFindNearestDepotTwoWay(const Vehicle *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int max_distance, int reverse_penalty, TileIndex *depot_tile, bool *reversed) - { - Tpf pf1; - /* - * With caching enabled it simply cannot get a reliable result when you - * have limited the distance a train may travel. This means that the - * cached result does not match uncached result in all cases and that - * causes desyncs. So disable caching when finding for a depot that is - * nearby. This only happens with automatic servicing of vehicles, - * so it will only impact performance when you do not manually set - * depot orders and you do not disable automatic servicing. - */ - if (max_distance != 0) pf1.DisableCache(true); - bool result1 = pf1.FindNearestDepotTwoWay(v, t1, td1, t2, td2, max_distance, reverse_penalty, depot_tile, reversed); - -#if DEBUG_YAPF_CACHE - Tpf pf2; - TileIndex depot_tile2 = INVALID_TILE; - bool reversed2 = false; - pf2.DisableCache(true); - bool result2 = pf2.FindNearestDepotTwoWay(v, t1, td1, t2, td2, max_distance, reverse_penalty, &depot_tile2, &reversed2); - if (result1 != result2 || (result1 && (*depot_tile != depot_tile2 || *reversed != reversed2))) { - DEBUG(yapf, 0, "CACHE ERROR: FindNearestDepotTwoWay() = [%s, %s]", result1 ? "T" : "F", result2 ? "T" : "F"); - DumpState(pf1, pf2); - } -#endif - - return result1; - } - - FORCEINLINE bool FindNearestDepotTwoWay(const Vehicle *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int max_distance, int reverse_penalty, TileIndex *depot_tile, bool *reversed) - { - /* set origin and destination nodes */ - Yapf().SetOrigin(t1, td1, t2, td2, reverse_penalty, true); - Yapf().SetDestination(v); - Yapf().SetMaxCost(YAPF_TILE_LENGTH * max_distance); - - /* find the best path */ - bool bFound = Yapf().FindPath(v); - if (!bFound) return false; - - /* some path found - * get found depot tile */ - Node *n = Yapf().GetBestNode(); - *depot_tile = n->GetLastTile(); - - /* walk through the path back to the origin */ - Node *pNode = n; - while (pNode->m_parent != NULL) { - pNode = pNode->m_parent; - } - - /* if the origin node is our front vehicle tile/Trackdir then we didn't reverse - * but we can also look at the cost (== 0 -> not reversed, == reverse_penalty -> reversed) */ - *reversed = (pNode->m_cost != 0); - - return true; - } -}; - -template -class CYapfFollowAnySafeTileRailT : public CYapfReserveTrack -{ -public: - typedef typename Types::Tpf Tpf; ///< the pathfinder class (derived from THIS class) - typedef typename Types::TrackFollower TrackFollower; - typedef typename Types::NodeList::Titem Node; ///< this will be our node type - typedef typename Node::Key Key; ///< key to hash tables - -protected: - /** to access inherited path finder */ - FORCEINLINE Tpf& Yapf() - { - return *static_cast(this); - } - -public: - /** Called by YAPF to move from the given node to the next tile. For each - * reachable trackdir on the new tile creates new node, initializes it - * and adds it to the open list by calling Yapf().AddNewNode(n) */ - inline void PfFollowNode(Node& old_node) - { - TrackFollower F(Yapf().GetVehicle(), Yapf().GetCompatibleRailTypes()); - if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir()) && F.MaskReservedTracks()) { - Yapf().AddMultipleNodes(&old_node, F); - } - } - - /** Return debug report character to identify the transportation type */ - FORCEINLINE char TransportTypeChar() const - { - return 't'; - } - - static bool stFindNearestSafeTile(const Vehicle *v, TileIndex t1, Trackdir td, bool override_railtype) - { - /* Create pathfinder instance */ - Tpf pf1; -#if !DEBUG_YAPF_CACHE - bool result1 = pf1.FindNearestSafeTile(v, t1, td, override_railtype, false); - -#else - bool result2 = pf1.FindNearestSafeTile(v, t1, td, override_railtype, true); - Tpf pf2; - pf2.DisableCache(true); - bool result1 = pf2.FindNearestSafeTile(v, t1, td, override_railtype, false); - if (result1 != result2) { - DEBUG(yapf, 0, "CACHE ERROR: FindSafeTile() = [%s, %s]", result2 ? "T" : "F", result1 ? "T" : "F"); - DumpState(pf1, pf2); - } -#endif - - return result1; - } - - bool FindNearestSafeTile(const Vehicle *v, TileIndex t1, Trackdir td, bool override_railtype, bool dont_reserve) - { - /* Set origin and destination. */ - Yapf().SetOrigin(t1, td); - Yapf().SetDestination(v, override_railtype); - - bool bFound = Yapf().FindPath(v); - if (!bFound) return false; - - /* Found a destination, set as reservation target. */ - Node *pNode = Yapf().GetBestNode(); - this->SetReservationTarget(pNode, pNode->GetLastTile(), pNode->GetLastTrackdir()); - - /* Walk through the path back to the origin. */ - Node *pPrev = NULL; - while (pNode->m_parent != NULL) { - pPrev = pNode; - pNode = pNode->m_parent; - - this->FindSafePositionOnNode(pPrev); - } - - return dont_reserve || this->TryReservePath(NULL); - } -}; - -template -class CYapfFollowRailT : public CYapfReserveTrack -{ -public: - typedef typename Types::Tpf Tpf; ///< the pathfinder class (derived from THIS class) - typedef typename Types::TrackFollower TrackFollower; - typedef typename Types::NodeList::Titem Node; ///< this will be our node type - typedef typename Node::Key Key; ///< key to hash tables - -protected: - /** to access inherited path finder */ - FORCEINLINE Tpf& Yapf() - { - return *static_cast(this); - } - -public: - /** Called by YAPF to move from the given node to the next tile. For each - * reachable trackdir on the new tile creates new node, initializes it - * and adds it to the open list by calling Yapf().AddNewNode(n) */ - inline void PfFollowNode(Node& old_node) - { - TrackFollower F(Yapf().GetVehicle()); - if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir())) { - Yapf().AddMultipleNodes(&old_node, F); - } - } - - /** return debug report character to identify the transportation type */ - FORCEINLINE char TransportTypeChar() const - { - return 't'; - } - - static Trackdir stChooseRailTrack(const Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool *path_not_found, bool reserve_track, PBSTileInfo *target) - { - /* create pathfinder instance */ - Tpf pf1; -#if !DEBUG_YAPF_CACHE - Trackdir result1 = pf1.ChooseRailTrack(v, tile, enterdir, tracks, path_not_found, reserve_track, target); - -#else - Trackdir result1 = pf1.ChooseRailTrack(v, tile, enterdir, tracks, path_not_found, false, NULL); - Tpf pf2; - pf2.DisableCache(true); - Trackdir result2 = pf2.ChooseRailTrack(v, tile, enterdir, tracks, path_not_found, reserve_track, target); - if (result1 != result2) { - DEBUG(yapf, 0, "CACHE ERROR: ChooseRailTrack() = [%d, %d]", result1, result2); - DumpState(pf1, pf2); - } -#endif - - return result1; - } - - FORCEINLINE Trackdir ChooseRailTrack(const Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool *path_not_found, bool reserve_track, PBSTileInfo *target) - { - if (target != NULL) target->tile = INVALID_TILE; - - /* set origin and destination nodes */ - PBSTileInfo origin = FollowTrainReservation(Train::From(v)); - Yapf().SetOrigin(origin.tile, origin.trackdir, INVALID_TILE, INVALID_TRACKDIR, 1, true); - Yapf().SetDestination(v); - - /* find the best path */ - bool path_found = Yapf().FindPath(v); - if (path_not_found != NULL) { - /* tell controller that the path was only 'guessed' - * treat the path as found if stopped on the first two way signal(s) */ - *path_not_found = !(path_found || Yapf().m_stopped_on_first_two_way_signal); - } - - /* if path not found - return INVALID_TRACKDIR */ - Trackdir next_trackdir = INVALID_TRACKDIR; - Node *pNode = Yapf().GetBestNode(); - if (pNode != NULL) { - /* reserve till end of path */ - this->SetReservationTarget(pNode, pNode->GetLastTile(), pNode->GetLastTrackdir()); - - /* path was found or at least suggested - * walk through the path back to the origin */ - Node *pPrev = NULL; - while (pNode->m_parent != NULL) { - pPrev = pNode; - pNode = pNode->m_parent; - - this->FindSafePositionOnNode(pPrev); - } - /* return trackdir from the best origin node (one of start nodes) */ - Node& best_next_node = *pPrev; - next_trackdir = best_next_node.GetTrackdir(); - - if (reserve_track && path_found) this->TryReservePath(target); - } - return next_trackdir; - } - - static bool stCheckReverseTrain(const Vehicle *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int reverse_penalty) - { - Tpf pf1; - bool result1 = pf1.CheckReverseTrain(v, t1, td1, t2, td2, reverse_penalty); - -#if DEBUG_YAPF_CACHE - Tpf pf2; - pf2.DisableCache(true); - bool result2 = pf2.CheckReverseTrain(v, t1, td1, t2, td2, reverse_penalty); - if (result1 != result2) { - DEBUG(yapf, 0, "CACHE ERROR: CheckReverseTrain() = [%s, %s]", result1 ? "T" : "F", result2 ? "T" : "F"); - DumpState(pf1, pf2); - } -#endif - - return result1; - } - - FORCEINLINE bool CheckReverseTrain(const Vehicle *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int reverse_penalty) - { - /* create pathfinder instance - * set origin and destination nodes */ - Yapf().SetOrigin(t1, td1, t2, td2, reverse_penalty, false); - Yapf().SetDestination(v); - - /* find the best path */ - bool bFound = Yapf().FindPath(v); - - if (!bFound) return false; - - /* path was found - * walk through the path back to the origin */ - Node *pNode = Yapf().GetBestNode(); - while (pNode->m_parent != NULL) { - pNode = pNode->m_parent; - } - - /* check if it was reversed origin */ - Node& best_org_node = *pNode; - bool reversed = (best_org_node.m_cost != 0); - return reversed; - } -}; - -template class TdestinationT, template class TfollowT> -struct CYapfRail_TypesT -{ - typedef CYapfRail_TypesT Types; - - typedef Tpf_ Tpf; - typedef Ttrack_follower TrackFollower; - typedef Tnode_list NodeList; - typedef CYapfBaseT PfBase; - typedef TfollowT PfFollow; - typedef CYapfOriginTileTwoWayT PfOrigin; - typedef TdestinationT PfDestination; - typedef CYapfSegmentCostCacheGlobalT PfCache; - typedef CYapfCostRailT PfCost; -}; - -struct CYapfRail1 : CYapfT > {}; -struct CYapfRail2 : CYapfT > {}; - -struct CYapfAnyDepotRail1 : CYapfT > {}; -struct CYapfAnyDepotRail2 : CYapfT > {}; - -struct CYapfAnySafeTileRail1 : CYapfT > {}; -struct CYapfAnySafeTileRail2 : CYapfT > {}; - - -Trackdir YapfChooseRailTrack(const Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool *path_not_found, bool reserve_track, PBSTileInfo *target) -{ - /* default is YAPF type 2 */ - typedef Trackdir (*PfnChooseRailTrack)(const Vehicle*, TileIndex, DiagDirection, TrackBits, bool*, bool, PBSTileInfo*); - PfnChooseRailTrack pfnChooseRailTrack = &CYapfRail1::stChooseRailTrack; - - /* check if non-default YAPF type needed */ - if (_settings_game.pf.forbid_90_deg) { - pfnChooseRailTrack = &CYapfRail2::stChooseRailTrack; // Trackdir, forbid 90-deg - } - - Trackdir td_ret = pfnChooseRailTrack(v, tile, enterdir, tracks, path_not_found, reserve_track, target); - - return td_ret; -} - -bool YapfCheckReverseTrain(const Vehicle *vt) -{ - const Train *v = Train::From(vt); - const Train *last_veh = v->Last(); - - /* get trackdirs of both ends */ - Trackdir td = v->GetVehicleTrackdir(); - Trackdir td_rev = ReverseTrackdir(last_veh->GetVehicleTrackdir()); - - /* tiles where front and back are */ - TileIndex tile = v->tile; - TileIndex tile_rev = last_veh->tile; - - int reverse_penalty = 0; - - if (v->track == TRACK_BIT_WORMHOLE) { - /* front in tunnel / on bridge */ - DiagDirection dir_into_wormhole = GetTunnelBridgeDirection(tile); - - if (TrackdirToExitdir(td) == dir_into_wormhole) tile = GetOtherTunnelBridgeEnd(tile); - /* Now 'tile' is the tunnel entry/bridge ramp the train will reach when driving forward */ - - /* Current position of the train in the wormhole */ - TileIndex cur_tile = TileVirtXY(v->x_pos, v->y_pos); - - /* Add distance to drive in the wormhole as penalty for the forward path, i.e. bonus for the reverse path - * Note: Negative penalties are ok for the start tile. */ - reverse_penalty -= DistanceManhattan(cur_tile, tile) * YAPF_TILE_LENGTH; - } - - if (last_veh->track == TRACK_BIT_WORMHOLE) { - /* back in tunnel / on bridge */ - DiagDirection dir_into_wormhole = GetTunnelBridgeDirection(tile_rev); - - if (TrackdirToExitdir(td_rev) == dir_into_wormhole) tile_rev = GetOtherTunnelBridgeEnd(tile_rev); - /* Now 'tile_rev' is the tunnel entry/bridge ramp the train will reach when reversing */ - - /* Current position of the last wagon in the wormhole */ - TileIndex cur_tile = TileVirtXY(last_veh->x_pos, last_veh->y_pos); - - /* Add distance to drive in the wormhole as penalty for the revere path. */ - reverse_penalty += DistanceManhattan(cur_tile, tile_rev) * YAPF_TILE_LENGTH; - } - - typedef bool (*PfnCheckReverseTrain)(const Vehicle*, TileIndex, Trackdir, TileIndex, Trackdir, int); - PfnCheckReverseTrain pfnCheckReverseTrain = CYapfRail1::stCheckReverseTrain; - - /* check if non-default YAPF type needed */ - if (_settings_game.pf.forbid_90_deg) { - pfnCheckReverseTrain = &CYapfRail2::stCheckReverseTrain; // Trackdir, forbid 90-deg - } - - /* slightly hackish: If the pathfinders finds a path, the cost of the first node is tested to distinguish between forward- and reverse-path. */ - if (reverse_penalty == 0) reverse_penalty = 1; - - bool reverse = pfnCheckReverseTrain(v, tile, td, tile_rev, td_rev, reverse_penalty); - - return reverse; -} - -bool YapfFindNearestRailDepotTwoWay(const Vehicle *v, int max_distance, int reverse_penalty, TileIndex *depot_tile, bool *reversed) -{ - *depot_tile = INVALID_TILE; - *reversed = false; - - const Vehicle *last_veh = v->Last(); - - PBSTileInfo origin = FollowTrainReservation(Train::From(v)); - TileIndex last_tile = last_veh->tile; - Trackdir td_rev = ReverseTrackdir(last_veh->GetVehicleTrackdir()); - - typedef bool (*PfnFindNearestDepotTwoWay)(const Vehicle*, TileIndex, Trackdir, TileIndex, Trackdir, int, int, TileIndex*, bool*); - PfnFindNearestDepotTwoWay pfnFindNearestDepotTwoWay = &CYapfAnyDepotRail1::stFindNearestDepotTwoWay; - - /* check if non-default YAPF type needed */ - if (_settings_game.pf.forbid_90_deg) { - pfnFindNearestDepotTwoWay = &CYapfAnyDepotRail2::stFindNearestDepotTwoWay; // Trackdir, forbid 90-deg - } - - bool ret = pfnFindNearestDepotTwoWay(v, origin.tile, origin.trackdir, last_tile, td_rev, max_distance, reverse_penalty, depot_tile, reversed); - return ret; -} - -bool YapfRailFindNearestSafeTile(const Vehicle *v, TileIndex tile, Trackdir td, bool override_railtype) -{ - typedef bool (*PfnFindNearestSafeTile)(const Vehicle*, TileIndex, Trackdir, bool); - PfnFindNearestSafeTile pfnFindNearestSafeTile = CYapfAnySafeTileRail1::stFindNearestSafeTile; - - /* check if non-default YAPF type needed */ - if (_settings_game.pf.forbid_90_deg) { - pfnFindNearestSafeTile = &CYapfAnySafeTileRail2::stFindNearestSafeTile; - } - - return pfnFindNearestSafeTile(v, tile, td, override_railtype); -} - -/** if any track changes, this counter is incremented - that will invalidate segment cost cache */ -int CSegmentCostCacheBase::s_rail_change_counter = 0; - -void YapfNotifyTrackLayoutChange(TileIndex tile, Track track) -{ - CSegmentCostCacheBase::NotifyTrackLayoutChange(tile, track); -}