00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "../../stdafx.h"
00013
00014 #include "yapf.hpp"
00015 #include "yapf_cache.h"
00016 #include "yapf_node_rail.hpp"
00017 #include "yapf_costrail.hpp"
00018 #include "yapf_destrail.hpp"
00019 #include "../../viewport_func.h"
00020 #include "../../newgrf_station.h"
00021
00022 #define DEBUG_YAPF_CACHE 0
00023
00024 #if DEBUG_YAPF_CACHE
00025 template <typename Tpf> void DumpState(Tpf &pf1, Tpf &pf2)
00026 {
00027 DumpTarget dmp1, dmp2;
00028 pf1.DumpBase(dmp1);
00029 pf2.DumpBase(dmp2);
00030 FILE *f1 = fopen("yapf1.txt", "wt");
00031 FILE *f2 = fopen("yapf2.txt", "wt");
00032 fwrite(dmp1.m_out.Data(), 1, dmp1.m_out.Size(), f1);
00033 fwrite(dmp2.m_out.Data(), 1, dmp2.m_out.Size(), f2);
00034 fclose(f1);
00035 fclose(f2);
00036 }
00037 #endif
00038
00039 int _total_pf_time_us = 0;
00040
00041 template <class Types>
00042 class CYapfReserveTrack
00043 {
00044 public:
00045 typedef typename Types::Tpf Tpf;
00046 typedef typename Types::TrackFollower TrackFollower;
00047 typedef typename Types::NodeList::Titem Node;
00048
00049 protected:
00051 inline Tpf& Yapf()
00052 {
00053 return *static_cast<Tpf*>(this);
00054 }
00055
00056 private:
00057 TileIndex m_res_dest;
00058 Trackdir m_res_dest_td;
00059 Node *m_res_node;
00060 TileIndex m_res_fail_tile;
00061 Trackdir m_res_fail_td;
00062 TileIndex m_origin_tile;
00063
00064 bool FindSafePositionProc(TileIndex tile, Trackdir td)
00065 {
00066 if (IsSafeWaitingPosition(Yapf().GetVehicle(), tile, td, true, !TrackFollower::Allow90degTurns())) {
00067 m_res_dest = tile;
00068 m_res_dest_td = td;
00069 return false;
00070 }
00071 return true;
00072 }
00073
00075 bool ReserveRailStationPlatform(TileIndex &tile, DiagDirection dir)
00076 {
00077 TileIndex start = tile;
00078 TileIndexDiff diff = TileOffsByDiagDir(dir);
00079
00080 do {
00081 if (HasStationReservation(tile)) return false;
00082 SetRailStationReservation(tile, true);
00083 MarkTileDirtyByTile(tile);
00084 tile = TILE_ADD(tile, diff);
00085 } while (IsCompatibleTrainStationTile(tile, start) && tile != m_origin_tile);
00086
00087 TriggerStationRandomisation(NULL, start, SRT_PATH_RESERVATION);
00088
00089 return true;
00090 }
00091
00093 bool ReserveSingleTrack(TileIndex tile, Trackdir td)
00094 {
00095 if (IsRailStationTile(tile)) {
00096 if (!ReserveRailStationPlatform(tile, TrackdirToExitdir(ReverseTrackdir(td)))) {
00097
00098 m_res_fail_tile = tile;
00099 m_res_fail_td = td;
00100 }
00101 } else {
00102 if (!TryReserveRailTrack(tile, TrackdirToTrack(td))) {
00103
00104 m_res_fail_tile = tile;
00105 m_res_fail_td = td;
00106 return false;
00107 }
00108 }
00109
00110 return tile != m_res_dest || td != m_res_dest_td;
00111 }
00112
00114 bool UnreserveSingleTrack(TileIndex tile, Trackdir td)
00115 {
00116 if (IsRailStationTile(tile)) {
00117 TileIndex start = tile;
00118 TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(td)));
00119 while ((tile != m_res_fail_tile || td != m_res_fail_td) && IsCompatibleTrainStationTile(tile, start)) {
00120 SetRailStationReservation(tile, false);
00121 tile = TILE_ADD(tile, diff);
00122 }
00123 } else if (tile != m_res_fail_tile || td != m_res_fail_td) {
00124 UnreserveRailTrack(tile, TrackdirToTrack(td));
00125 }
00126 return (tile != m_res_dest || td != m_res_dest_td) && (tile != m_res_fail_tile || td != m_res_fail_td);
00127 }
00128
00129 public:
00131 inline void SetReservationTarget(Node *node, TileIndex tile, Trackdir td)
00132 {
00133 m_res_node = node;
00134 m_res_dest = tile;
00135 m_res_dest_td = td;
00136 }
00137
00139 inline void FindSafePositionOnNode(Node *node)
00140 {
00141 assert(node->m_parent != NULL);
00142
00143
00144 if (node->m_parent->m_num_signals_passed >= 2) return;
00145
00146 if (!node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack<Types>::FindSafePositionProc)) {
00147 m_res_node = node;
00148 }
00149 }
00150
00152 bool TryReservePath(PBSTileInfo *target, TileIndex origin)
00153 {
00154 m_res_fail_tile = INVALID_TILE;
00155 m_origin_tile = origin;
00156
00157 if (target != NULL) {
00158 target->tile = m_res_dest;
00159 target->trackdir = m_res_dest_td;
00160 target->okay = false;
00161 }
00162
00163
00164 if (!IsWaitingPositionFree(Yapf().GetVehicle(), m_res_dest, m_res_dest_td)) return false;
00165
00166 for (Node *node = m_res_node; node->m_parent != NULL; node = node->m_parent) {
00167 node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack<Types>::ReserveSingleTrack);
00168 if (m_res_fail_tile != INVALID_TILE) {
00169
00170 Node *fail_node = m_res_node;
00171 TileIndex stop_tile = m_res_fail_tile;
00172 do {
00173
00174 m_res_fail_tile = fail_node == node ? stop_tile : INVALID_TILE;
00175 fail_node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack<Types>::UnreserveSingleTrack);
00176 } while (fail_node != node && (fail_node = fail_node->m_parent) != NULL);
00177
00178 return false;
00179 }
00180 }
00181
00182 if (target != NULL) target->okay = true;
00183
00184 if (Yapf().CanUseGlobalCache(*m_res_node)) {
00185 YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
00186 }
00187
00188 return true;
00189 }
00190 };
00191
00192 template <class Types>
00193 class CYapfFollowAnyDepotRailT
00194 {
00195 public:
00196 typedef typename Types::Tpf Tpf;
00197 typedef typename Types::TrackFollower TrackFollower;
00198 typedef typename Types::NodeList::Titem Node;
00199 typedef typename Node::Key Key;
00200
00201 protected:
00203 inline Tpf& Yapf()
00204 {
00205 return *static_cast<Tpf*>(this);
00206 }
00207
00208 public:
00214 inline void PfFollowNode(Node& old_node)
00215 {
00216 TrackFollower F(Yapf().GetVehicle());
00217 if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir())) {
00218 Yapf().AddMultipleNodes(&old_node, F);
00219 }
00220 }
00221
00223 inline char TransportTypeChar() const
00224 {
00225 return 't';
00226 }
00227
00228 static bool stFindNearestDepotTwoWay(const Train *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int max_penalty, int reverse_penalty, TileIndex *depot_tile, bool *reversed)
00229 {
00230 Tpf pf1;
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240 if (max_penalty != 0) pf1.DisableCache(true);
00241 bool result1 = pf1.FindNearestDepotTwoWay(v, t1, td1, t2, td2, max_penalty, reverse_penalty, depot_tile, reversed);
00242
00243 #if DEBUG_YAPF_CACHE
00244 Tpf pf2;
00245 TileIndex depot_tile2 = INVALID_TILE;
00246 bool reversed2 = false;
00247 pf2.DisableCache(true);
00248 bool result2 = pf2.FindNearestDepotTwoWay(v, t1, td1, t2, td2, max_penalty, reverse_penalty, &depot_tile2, &reversed2);
00249 if (result1 != result2 || (result1 && (*depot_tile != depot_tile2 || *reversed != reversed2))) {
00250 DEBUG(yapf, 0, "CACHE ERROR: FindNearestDepotTwoWay() = [%s, %s]", result1 ? "T" : "F", result2 ? "T" : "F");
00251 DumpState(pf1, pf2);
00252 }
00253 #endif
00254
00255 return result1;
00256 }
00257
00258 inline bool FindNearestDepotTwoWay(const Train *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int max_penalty, int reverse_penalty, TileIndex *depot_tile, bool *reversed)
00259 {
00260
00261 Yapf().SetOrigin(t1, td1, t2, td2, reverse_penalty, true);
00262 Yapf().SetDestination(v);
00263 Yapf().SetMaxCost(max_penalty);
00264
00265
00266 bool bFound = Yapf().FindPath(v);
00267 if (!bFound) return false;
00268
00269
00270
00271 Node *n = Yapf().GetBestNode();
00272 *depot_tile = n->GetLastTile();
00273
00274
00275 Node *pNode = n;
00276 while (pNode->m_parent != NULL) {
00277 pNode = pNode->m_parent;
00278 }
00279
00280
00281
00282 *reversed = (pNode->m_cost != 0);
00283
00284 return true;
00285 }
00286 };
00287
00288 template <class Types>
00289 class CYapfFollowAnySafeTileRailT : public CYapfReserveTrack<Types>
00290 {
00291 public:
00292 typedef typename Types::Tpf Tpf;
00293 typedef typename Types::TrackFollower TrackFollower;
00294 typedef typename Types::NodeList::Titem Node;
00295 typedef typename Node::Key Key;
00296
00297 protected:
00299 inline Tpf& Yapf()
00300 {
00301 return *static_cast<Tpf*>(this);
00302 }
00303
00304 public:
00310 inline void PfFollowNode(Node& old_node)
00311 {
00312 TrackFollower F(Yapf().GetVehicle(), Yapf().GetCompatibleRailTypes());
00313 if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir()) && F.MaskReservedTracks()) {
00314 Yapf().AddMultipleNodes(&old_node, F);
00315 }
00316 }
00317
00319 inline char TransportTypeChar() const
00320 {
00321 return 't';
00322 }
00323
00324 static bool stFindNearestSafeTile(const Train *v, TileIndex t1, Trackdir td, bool override_railtype)
00325 {
00326
00327 Tpf pf1;
00328 #if !DEBUG_YAPF_CACHE
00329 bool result1 = pf1.FindNearestSafeTile(v, t1, td, override_railtype, false);
00330
00331 #else
00332 bool result2 = pf1.FindNearestSafeTile(v, t1, td, override_railtype, true);
00333 Tpf pf2;
00334 pf2.DisableCache(true);
00335 bool result1 = pf2.FindNearestSafeTile(v, t1, td, override_railtype, false);
00336 if (result1 != result2) {
00337 DEBUG(yapf, 0, "CACHE ERROR: FindSafeTile() = [%s, %s]", result2 ? "T" : "F", result1 ? "T" : "F");
00338 DumpState(pf1, pf2);
00339 }
00340 #endif
00341
00342 return result1;
00343 }
00344
00345 bool FindNearestSafeTile(const Train *v, TileIndex t1, Trackdir td, bool override_railtype, bool dont_reserve)
00346 {
00347
00348 Yapf().SetOrigin(t1, td);
00349 Yapf().SetDestination(v, override_railtype);
00350
00351 bool bFound = Yapf().FindPath(v);
00352 if (!bFound) return false;
00353
00354
00355 Node *pNode = Yapf().GetBestNode();
00356 this->SetReservationTarget(pNode, pNode->GetLastTile(), pNode->GetLastTrackdir());
00357
00358
00359 Node *pPrev = NULL;
00360 while (pNode->m_parent != NULL) {
00361 pPrev = pNode;
00362 pNode = pNode->m_parent;
00363
00364 this->FindSafePositionOnNode(pPrev);
00365 }
00366
00367 return dont_reserve || this->TryReservePath(NULL, pNode->GetLastTile());
00368 }
00369 };
00370
00371 template <class Types>
00372 class CYapfFollowRailT : public CYapfReserveTrack<Types>
00373 {
00374 public:
00375 typedef typename Types::Tpf Tpf;
00376 typedef typename Types::TrackFollower TrackFollower;
00377 typedef typename Types::NodeList::Titem Node;
00378 typedef typename Node::Key Key;
00379
00380 protected:
00382 inline Tpf& Yapf()
00383 {
00384 return *static_cast<Tpf*>(this);
00385 }
00386
00387 public:
00393 inline void PfFollowNode(Node& old_node)
00394 {
00395 TrackFollower F(Yapf().GetVehicle());
00396 if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir())) {
00397 Yapf().AddMultipleNodes(&old_node, F);
00398 }
00399 }
00400
00402 inline char TransportTypeChar() const
00403 {
00404 return 't';
00405 }
00406
00407 static Trackdir stChooseRailTrack(const Train *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool &path_found, bool reserve_track, PBSTileInfo *target)
00408 {
00409
00410 Tpf pf1;
00411 #if !DEBUG_YAPF_CACHE
00412 Trackdir result1 = pf1.ChooseRailTrack(v, tile, enterdir, tracks, path_found, reserve_track, target);
00413
00414 #else
00415 Trackdir result1 = pf1.ChooseRailTrack(v, tile, enterdir, tracks, path_found, false, NULL);
00416 Tpf pf2;
00417 pf2.DisableCache(true);
00418 Trackdir result2 = pf2.ChooseRailTrack(v, tile, enterdir, tracks, path_found, reserve_track, target);
00419 if (result1 != result2) {
00420 DEBUG(yapf, 0, "CACHE ERROR: ChooseRailTrack() = [%d, %d]", result1, result2);
00421 DumpState(pf1, pf2);
00422 }
00423 #endif
00424
00425 return result1;
00426 }
00427
00428 inline Trackdir ChooseRailTrack(const Train *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool &path_found, bool reserve_track, PBSTileInfo *target)
00429 {
00430 if (target != NULL) target->tile = INVALID_TILE;
00431
00432
00433 PBSTileInfo origin = FollowTrainReservation(v);
00434 Yapf().SetOrigin(origin.tile, origin.trackdir, INVALID_TILE, INVALID_TRACKDIR, 1, true);
00435 Yapf().SetDestination(v);
00436
00437
00438 path_found = Yapf().FindPath(v);
00439
00440
00441 Trackdir next_trackdir = INVALID_TRACKDIR;
00442 Node *pNode = Yapf().GetBestNode();
00443 if (pNode != NULL) {
00444
00445 this->SetReservationTarget(pNode, pNode->GetLastTile(), pNode->GetLastTrackdir());
00446
00447
00448
00449 Node *pPrev = NULL;
00450 while (pNode->m_parent != NULL) {
00451 pPrev = pNode;
00452 pNode = pNode->m_parent;
00453
00454 this->FindSafePositionOnNode(pPrev);
00455 }
00456
00457 Node& best_next_node = *pPrev;
00458 next_trackdir = best_next_node.GetTrackdir();
00459
00460 if (reserve_track && path_found) this->TryReservePath(target, pNode->GetLastTile());
00461 }
00462
00463
00464 path_found |= Yapf().m_stopped_on_first_two_way_signal;
00465 return next_trackdir;
00466 }
00467
00468 static bool stCheckReverseTrain(const Train *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int reverse_penalty)
00469 {
00470 Tpf pf1;
00471 bool result1 = pf1.CheckReverseTrain(v, t1, td1, t2, td2, reverse_penalty);
00472
00473 #if DEBUG_YAPF_CACHE
00474 Tpf pf2;
00475 pf2.DisableCache(true);
00476 bool result2 = pf2.CheckReverseTrain(v, t1, td1, t2, td2, reverse_penalty);
00477 if (result1 != result2) {
00478 DEBUG(yapf, 0, "CACHE ERROR: CheckReverseTrain() = [%s, %s]", result1 ? "T" : "F", result2 ? "T" : "F");
00479 DumpState(pf1, pf2);
00480 }
00481 #endif
00482
00483 return result1;
00484 }
00485
00486 inline bool CheckReverseTrain(const Train *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int reverse_penalty)
00487 {
00488
00489
00490 Yapf().SetOrigin(t1, td1, t2, td2, reverse_penalty, false);
00491 Yapf().SetDestination(v);
00492
00493
00494 bool bFound = Yapf().FindPath(v);
00495
00496 if (!bFound) return false;
00497
00498
00499
00500 Node *pNode = Yapf().GetBestNode();
00501 while (pNode->m_parent != NULL) {
00502 pNode = pNode->m_parent;
00503 }
00504
00505
00506 Node& best_org_node = *pNode;
00507 bool reversed = (best_org_node.m_cost != 0);
00508 return reversed;
00509 }
00510 };
00511
00512 template <class Tpf_, class Ttrack_follower, class Tnode_list, template <class Types> class TdestinationT, template <class Types> class TfollowT>
00513 struct CYapfRail_TypesT
00514 {
00515 typedef CYapfRail_TypesT<Tpf_, Ttrack_follower, Tnode_list, TdestinationT, TfollowT> Types;
00516
00517 typedef Tpf_ Tpf;
00518 typedef Ttrack_follower TrackFollower;
00519 typedef Tnode_list NodeList;
00520 typedef Train VehicleType;
00521 typedef CYapfBaseT<Types> PfBase;
00522 typedef TfollowT<Types> PfFollow;
00523 typedef CYapfOriginTileTwoWayT<Types> PfOrigin;
00524 typedef TdestinationT<Types> PfDestination;
00525 typedef CYapfSegmentCostCacheGlobalT<Types> PfCache;
00526 typedef CYapfCostRailT<Types> PfCost;
00527 };
00528
00529 struct CYapfRail1 : CYapfT<CYapfRail_TypesT<CYapfRail1 , CFollowTrackRail , CRailNodeListTrackDir, CYapfDestinationTileOrStationRailT, CYapfFollowRailT> > {};
00530 struct CYapfRail2 : CYapfT<CYapfRail_TypesT<CYapfRail2 , CFollowTrackRailNo90, CRailNodeListTrackDir, CYapfDestinationTileOrStationRailT, CYapfFollowRailT> > {};
00531
00532 struct CYapfAnyDepotRail1 : CYapfT<CYapfRail_TypesT<CYapfAnyDepotRail1, CFollowTrackRail , CRailNodeListTrackDir, CYapfDestinationAnyDepotRailT , CYapfFollowAnyDepotRailT> > {};
00533 struct CYapfAnyDepotRail2 : CYapfT<CYapfRail_TypesT<CYapfAnyDepotRail2, CFollowTrackRailNo90, CRailNodeListTrackDir, CYapfDestinationAnyDepotRailT , CYapfFollowAnyDepotRailT> > {};
00534
00535 struct CYapfAnySafeTileRail1 : CYapfT<CYapfRail_TypesT<CYapfAnySafeTileRail1, CFollowTrackFreeRail , CRailNodeListTrackDir, CYapfDestinationAnySafeTileRailT , CYapfFollowAnySafeTileRailT> > {};
00536 struct CYapfAnySafeTileRail2 : CYapfT<CYapfRail_TypesT<CYapfAnySafeTileRail2, CFollowTrackFreeRailNo90, CRailNodeListTrackDir, CYapfDestinationAnySafeTileRailT , CYapfFollowAnySafeTileRailT> > {};
00537
00538
00539 Track YapfTrainChooseTrack(const Train *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool &path_found, bool reserve_track, PBSTileInfo *target)
00540 {
00541
00542 typedef Trackdir (*PfnChooseRailTrack)(const Train*, TileIndex, DiagDirection, TrackBits, bool&, bool, PBSTileInfo*);
00543 PfnChooseRailTrack pfnChooseRailTrack = &CYapfRail1::stChooseRailTrack;
00544
00545
00546 if (_settings_game.pf.forbid_90_deg) {
00547 pfnChooseRailTrack = &CYapfRail2::stChooseRailTrack;
00548 }
00549
00550 Trackdir td_ret = pfnChooseRailTrack(v, tile, enterdir, tracks, path_found, reserve_track, target);
00551 return (td_ret != INVALID_TRACKDIR) ? TrackdirToTrack(td_ret) : FindFirstTrack(tracks);
00552 }
00553
00554 bool YapfTrainCheckReverse(const Train *v)
00555 {
00556 const Train *last_veh = v->Last();
00557
00558
00559 Trackdir td = v->GetVehicleTrackdir();
00560 Trackdir td_rev = ReverseTrackdir(last_veh->GetVehicleTrackdir());
00561
00562
00563 TileIndex tile = v->tile;
00564 TileIndex tile_rev = last_veh->tile;
00565
00566 int reverse_penalty = 0;
00567
00568 if (v->track == TRACK_BIT_WORMHOLE) {
00569
00570 DiagDirection dir_into_wormhole = GetTunnelBridgeDirection(tile);
00571
00572 if (TrackdirToExitdir(td) == dir_into_wormhole) tile = GetOtherTunnelBridgeEnd(tile);
00573
00574
00575
00576 TileIndex cur_tile = TileVirtXY(v->x_pos, v->y_pos);
00577
00578
00579
00580 reverse_penalty -= DistanceManhattan(cur_tile, tile) * YAPF_TILE_LENGTH;
00581 }
00582
00583 if (last_veh->track == TRACK_BIT_WORMHOLE) {
00584
00585 DiagDirection dir_into_wormhole = GetTunnelBridgeDirection(tile_rev);
00586
00587 if (TrackdirToExitdir(td_rev) == dir_into_wormhole) tile_rev = GetOtherTunnelBridgeEnd(tile_rev);
00588
00589
00590
00591 TileIndex cur_tile = TileVirtXY(last_veh->x_pos, last_veh->y_pos);
00592
00593
00594 reverse_penalty += DistanceManhattan(cur_tile, tile_rev) * YAPF_TILE_LENGTH;
00595 }
00596
00597 typedef bool (*PfnCheckReverseTrain)(const Train*, TileIndex, Trackdir, TileIndex, Trackdir, int);
00598 PfnCheckReverseTrain pfnCheckReverseTrain = CYapfRail1::stCheckReverseTrain;
00599
00600
00601 if (_settings_game.pf.forbid_90_deg) {
00602 pfnCheckReverseTrain = &CYapfRail2::stCheckReverseTrain;
00603 }
00604
00605
00606 if (reverse_penalty == 0) reverse_penalty = 1;
00607
00608 bool reverse = pfnCheckReverseTrain(v, tile, td, tile_rev, td_rev, reverse_penalty);
00609
00610 return reverse;
00611 }
00612
00613 FindDepotData YapfTrainFindNearestDepot(const Train *v, int max_penalty)
00614 {
00615 FindDepotData fdd;
00616
00617 const Train *last_veh = v->Last();
00618
00619 PBSTileInfo origin = FollowTrainReservation(v);
00620 TileIndex last_tile = last_veh->tile;
00621 Trackdir td_rev = ReverseTrackdir(last_veh->GetVehicleTrackdir());
00622
00623 typedef bool (*PfnFindNearestDepotTwoWay)(const Train*, TileIndex, Trackdir, TileIndex, Trackdir, int, int, TileIndex*, bool*);
00624 PfnFindNearestDepotTwoWay pfnFindNearestDepotTwoWay = &CYapfAnyDepotRail1::stFindNearestDepotTwoWay;
00625
00626
00627 if (_settings_game.pf.forbid_90_deg) {
00628 pfnFindNearestDepotTwoWay = &CYapfAnyDepotRail2::stFindNearestDepotTwoWay;
00629 }
00630
00631 bool ret = pfnFindNearestDepotTwoWay(v, origin.tile, origin.trackdir, last_tile, td_rev, max_penalty, YAPF_INFINITE_PENALTY, &fdd.tile, &fdd.reverse);
00632 fdd.best_length = ret ? max_penalty / 2 : UINT_MAX;
00633 return fdd;
00634 }
00635
00636 bool YapfTrainFindNearestSafeTile(const Train *v, TileIndex tile, Trackdir td, bool override_railtype)
00637 {
00638 typedef bool (*PfnFindNearestSafeTile)(const Train*, TileIndex, Trackdir, bool);
00639 PfnFindNearestSafeTile pfnFindNearestSafeTile = CYapfAnySafeTileRail1::stFindNearestSafeTile;
00640
00641
00642 if (_settings_game.pf.forbid_90_deg) {
00643 pfnFindNearestSafeTile = &CYapfAnySafeTileRail2::stFindNearestSafeTile;
00644 }
00645
00646 return pfnFindNearestSafeTile(v, tile, td, override_railtype);
00647 }
00648
00650 int CSegmentCostCacheBase::s_rail_change_counter = 0;
00651
00652 void YapfNotifyTrackLayoutChange(TileIndex tile, Track track)
00653 {
00654 CSegmentCostCacheBase::NotifyTrackLayoutChange(tile, track);
00655 }