yapf_rail.cpp

Go to the documentation of this file.
00001 /* $Id: yapf_rail.cpp 15619 2009-03-05 16:14:56Z michi_cc $ */
00002 
00005 #include "../stdafx.h"
00006 
00007 #include "yapf.hpp"
00008 #include "yapf_node_rail.hpp"
00009 #include "yapf_costrail.hpp"
00010 #include "yapf_destrail.hpp"
00011 #include "../vehicle_func.h"
00012 #include "../functions.h"
00013 
00014 #define DEBUG_YAPF_CACHE 0
00015 
00016 int _total_pf_time_us = 0;
00017 
00018 template <class Types>
00019 class CYapfReserveTrack
00020 {
00021 public:
00022   typedef typename Types::Tpf Tpf;                     
00023   typedef typename Types::TrackFollower TrackFollower;
00024   typedef typename Types::NodeList::Titem Node;        
00025 
00026 protected:
00028   FORCEINLINE Tpf& Yapf()
00029   {
00030     return *static_cast<Tpf*>(this);
00031   }
00032 
00033 private:
00034   TileIndex m_res_dest;         
00035   Trackdir  m_res_dest_td;      
00036   Node      *m_res_node;        
00037   TileIndex m_res_fail_tile;    
00038   Trackdir  m_res_fail_td;      
00039 
00040   bool FindSafePositionProc(TileIndex tile, Trackdir td)
00041   {
00042     if (IsSafeWaitingPosition(Yapf().GetVehicle(), tile, td, true, !TrackFollower::Allow90degTurns())) {
00043       m_res_dest = tile;
00044       m_res_dest_td = td;
00045       return false;   // Stop iterating segment
00046     }
00047     return true;
00048   }
00049 
00051   bool ReserveRailwayStationPlatform(TileIndex &tile, DiagDirection dir)
00052   {
00053     TileIndex     start = tile;
00054     TileIndexDiff diff = TileOffsByDiagDir(dir);
00055 
00056     do {
00057       if (GetRailwayStationReservation(tile)) return false;
00058       SetRailwayStationReservation(tile, true);
00059       MarkTileDirtyByTile(tile);
00060       tile = TILE_ADD(tile, diff);
00061     } while (IsCompatibleTrainStationTile(tile, start));
00062 
00063     return true;
00064   }
00065 
00067   bool ReserveSingleTrack(TileIndex tile, Trackdir td)
00068   {
00069     if (IsRailwayStationTile(tile)) {
00070       if (!ReserveRailwayStationPlatform(tile, TrackdirToExitdir(ReverseTrackdir(td)))) {
00071         /* Platform could not be reserved, undo. */
00072         m_res_fail_tile = tile;
00073         m_res_fail_td = td;
00074       }
00075     } else {
00076       if (!TryReserveRailTrack(tile, TrackdirToTrack(td))) {
00077         /* Tile couldn't be reserved, undo. */
00078         m_res_fail_tile = tile;
00079         m_res_fail_td = td;
00080         return false;
00081       }
00082     }
00083 
00084     return tile != m_res_dest || td != m_res_dest_td;
00085   }
00086 
00088   bool UnreserveSingleTrack(TileIndex tile, Trackdir td)
00089   {
00090     if (IsRailwayStationTile(tile)) {
00091       TileIndex     start = tile;
00092       TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(td)));
00093       while ((tile != m_res_fail_tile || td != m_res_fail_td) && IsCompatibleTrainStationTile(tile, start)) {
00094         SetRailwayStationReservation(tile, false);
00095         tile = TILE_ADD(tile, diff);
00096       }
00097     } else if (tile != m_res_fail_tile || td != m_res_fail_td) {
00098       UnreserveRailTrack(tile, TrackdirToTrack(td));
00099     }
00100     return (tile != m_res_dest || td != m_res_dest_td) && (tile != m_res_fail_tile || td != m_res_fail_td);
00101   }
00102 
00103 public:
00105   inline void SetReservationTarget(Node *node, TileIndex tile, Trackdir td)
00106   {
00107     m_res_node = node;
00108     m_res_dest = tile;
00109     m_res_dest_td = td;
00110   }
00111 
00113   inline void FindSafePositionOnNode(Node *node)
00114   {
00115     assert(node->m_parent != NULL);
00116 
00117     /* We will never pass more than two signals, no need to check for a safe tile. */
00118     if (node->m_parent->m_num_signals_passed >= 2) return;
00119 
00120     if (!node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack<Types>::FindSafePositionProc)) {
00121       m_res_node = node;
00122     }
00123   }
00124 
00126   bool TryReservePath(PBSTileInfo *target)
00127   {
00128     m_res_fail_tile = INVALID_TILE;
00129 
00130     if (target != NULL) {
00131       target->tile = m_res_dest;
00132       target->trackdir = m_res_dest_td;
00133       target->okay = false;
00134     }
00135 
00136     /* Don't bother if the target is reserved. */
00137     if (!IsWaitingPositionFree(Yapf().GetVehicle(), m_res_dest, m_res_dest_td)) return false;
00138 
00139     for (Node *node = m_res_node; node->m_parent != NULL; node = node->m_parent) {
00140       node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack<Types>::ReserveSingleTrack);
00141       if (m_res_fail_tile != INVALID_TILE) {
00142         /* Reservation failed, undo. */
00143         Node *fail_node = m_res_node;
00144         TileIndex stop_tile = m_res_fail_tile;
00145         do {
00146           /* If this is the node that failed, stop at the failed tile. */
00147           m_res_fail_tile = fail_node == node ? stop_tile : INVALID_TILE;
00148           fail_node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack<Types>::UnreserveSingleTrack);
00149         } while (fail_node != node && (fail_node = fail_node->m_parent) != NULL);
00150 
00151         return false;
00152       }
00153     }
00154 
00155     if (target != NULL) target->okay = true;
00156 
00157     if (Yapf().CanUseGlobalCache(*m_res_node))
00158       YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
00159 
00160     return true;
00161   }
00162 };
00163 
00164 template <class Types>
00165 class CYapfFollowAnyDepotRailT
00166 {
00167 public:
00168   typedef typename Types::Tpf Tpf;                     
00169   typedef typename Types::TrackFollower TrackFollower;
00170   typedef typename Types::NodeList::Titem Node;        
00171   typedef typename Node::Key Key;                      
00172 
00173 protected:
00175   FORCEINLINE Tpf& Yapf()
00176   {
00177     return *static_cast<Tpf*>(this);
00178   }
00179 
00180 public:
00184   inline void PfFollowNode(Node& old_node)
00185   {
00186     TrackFollower F(Yapf().GetVehicle());
00187     if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir())) {
00188       Yapf().AddMultipleNodes(&old_node, F);
00189     }
00190   }
00191 
00193   FORCEINLINE char TransportTypeChar() const
00194   {
00195     return 't';
00196   }
00197 
00198   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)
00199   {
00200     Tpf pf1;
00201     bool result1 = pf1.FindNearestDepotTwoWay(v, t1, td1, t2, td2, max_distance, reverse_penalty, depot_tile, reversed);
00202 
00203 #if DEBUG_YAPF_CACHE
00204     Tpf pf2;
00205     TileIndex depot_tile2 = INVALID_TILE;
00206     bool reversed2 = false;
00207     pf2.DisableCache(true);
00208     bool result2 = pf2.FindNearestDepotTwoWay(v, t1, td1, t2, td2, max_distance, reverse_penalty, &depot_tile2, &reversed2);
00209     if (result1 != result2 || (result1 && (*depot_tile != depot_tile2 || *reversed != reversed2))) {
00210       DEBUG(yapf, 0, "CACHE ERROR: FindNearestDepotTwoWay() = [%s, %s]", result1 ? "T" : "F", result2 ? "T" : "F");
00211     }
00212 #endif
00213 
00214     return result1;
00215   }
00216 
00217   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)
00218   {
00219     // set origin and destination nodes
00220     Yapf().SetOrigin(t1, td1, t2, td2, reverse_penalty, true);
00221     Yapf().SetDestination(v);
00222     Yapf().SetMaxCost(YAPF_TILE_LENGTH * max_distance);
00223 
00224     // find the best path
00225     bool bFound = Yapf().FindPath(v);
00226     if (!bFound) return false;
00227 
00228     // some path found
00229     // get found depot tile
00230     Node *n = Yapf().GetBestNode();
00231     *depot_tile = n->GetLastTile();
00232 
00233     // walk through the path back to the origin
00234     Node *pNode = n;
00235     while (pNode->m_parent != NULL) {
00236       pNode = pNode->m_parent;
00237     }
00238 
00239     // if the origin node is our front vehicle tile/Trackdir then we didn't reverse
00240     // but we can also look at the cost (== 0 -> not reversed, == reverse_penalty -> reversed)
00241     *reversed = (pNode->m_cost != 0);
00242 
00243     return true;
00244   }
00245 };
00246 
00247 template <class Types>
00248 class CYapfFollowAnySafeTileRailT : public CYapfReserveTrack<Types>
00249 {
00250 public:
00251   typedef typename Types::Tpf Tpf;                     
00252   typedef typename Types::TrackFollower TrackFollower;
00253   typedef typename Types::NodeList::Titem Node;        
00254   typedef typename Node::Key Key;                      
00255 
00256 protected:
00258   FORCEINLINE Tpf& Yapf()
00259   {
00260     return *static_cast<Tpf*>(this);
00261   }
00262 
00263 public:
00267   inline void PfFollowNode(Node& old_node)
00268   {
00269     TrackFollower F(Yapf().GetVehicle(), Yapf().GetCompatibleRailTypes());
00270     if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir()) && F.MaskReservedTracks()) {
00271       Yapf().AddMultipleNodes(&old_node, F);
00272     }
00273   }
00274 
00276   FORCEINLINE char TransportTypeChar() const
00277   {
00278     return 't';
00279   }
00280 
00281   static bool stFindNearestSafeTile(const Vehicle *v, TileIndex t1, Trackdir td, bool override_railtype)
00282   {
00283     /* Create pathfinder instance */
00284     Tpf pf1;
00285 #if !DEBUG_YAPF_CACHE
00286     bool result1 = pf1.FindNearestSafeTile(v, t1, td, override_railtype, false);
00287 
00288 #else
00289     bool result2 = pf1.FindNearestSafeTile(v, t1, td, override_railtype, true);
00290     Tpf pf2;
00291     pf2.DisableCache(true);
00292     bool result1 = pf2.FindNearestSafeTile(v, t1, td, override_railtype, false);
00293     if (result1 != result2) {
00294       DEBUG(yapf, 0, "CACHE ERROR: FindSafeTile() = [%s, %s]", result2 ? "T" : "F", result1 ? "T" : "F");
00295       DumpTarget dmp1, dmp2;
00296       pf1.DumpBase(dmp1);
00297       pf2.DumpBase(dmp2);
00298       FILE *f1 = fopen("C:\\yapf1.txt", "wt");
00299       FILE *f2 = fopen("C:\\yapf2.txt", "wt");
00300       fwrite(dmp1.m_out.Data(), 1, dmp1.m_out.Size(), f1);
00301       fwrite(dmp2.m_out.Data(), 1, dmp2.m_out.Size(), f2);
00302       fclose(f1);
00303       fclose(f2);
00304     }
00305 #endif
00306 
00307     return result1;
00308   }
00309 
00310   bool FindNearestSafeTile(const Vehicle *v, TileIndex t1, Trackdir td, bool override_railtype, bool dont_reserve)
00311   {
00312     /* Set origin and destination. */
00313     Yapf().SetOrigin(t1, td);
00314     Yapf().SetDestination(v, override_railtype);
00315 
00316     bool bFound = Yapf().FindPath(v);
00317     if (!bFound) return false;
00318 
00319     /* Found a destination, set as reservation target. */
00320     Node *pNode = Yapf().GetBestNode();
00321     this->SetReservationTarget(pNode, pNode->GetLastTile(), pNode->GetLastTrackdir());
00322 
00323     /* Walk through the path back to the origin. */
00324     Node *pPrev = NULL;
00325     while (pNode->m_parent != NULL) {
00326       pPrev = pNode;
00327       pNode = pNode->m_parent;
00328 
00329       this->FindSafePositionOnNode(pPrev);
00330     }
00331 
00332     return dont_reserve || this->TryReservePath(NULL);
00333   }
00334 };
00335 
00336 template <class Types>
00337 class CYapfFollowRailT : public CYapfReserveTrack<Types>
00338 {
00339 public:
00340   typedef typename Types::Tpf Tpf;                     
00341   typedef typename Types::TrackFollower TrackFollower;
00342   typedef typename Types::NodeList::Titem Node;        
00343   typedef typename Node::Key Key;                      
00344 
00345 protected:
00347   FORCEINLINE Tpf& Yapf()
00348   {
00349     return *static_cast<Tpf*>(this);
00350   }
00351 
00352 public:
00356   inline void PfFollowNode(Node& old_node)
00357   {
00358     TrackFollower F(Yapf().GetVehicle());
00359     if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir())) {
00360       Yapf().AddMultipleNodes(&old_node, F);
00361     }
00362   }
00363 
00365   FORCEINLINE char TransportTypeChar() const
00366   {
00367     return 't';
00368   }
00369 
00370   static Trackdir stChooseRailTrack(const Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool *path_not_found, bool reserve_track, PBSTileInfo *target)
00371   {
00372     // create pathfinder instance
00373     Tpf pf1;
00374 #if !DEBUG_YAPF_CACHE
00375     Trackdir result1 = pf1.ChooseRailTrack(v, tile, enterdir, tracks, path_not_found, reserve_track, target);
00376 
00377 #else
00378     Trackdir result1 = pf1.ChooseRailTrack(v, tile, enterdir, tracks, path_not_found, false, NULL);
00379     Tpf pf2;
00380     pf2.DisableCache(true);
00381     Trackdir result2 = pf2.ChooseRailTrack(v, tile, enterdir, tracks, path_not_found, reserve_track, target);
00382     if (result1 != result2) {
00383       DEBUG(yapf, 0, "CACHE ERROR: ChooseRailTrack() = [%d, %d]", result1, result2);
00384       DumpTarget dmp1, dmp2;
00385       pf1.DumpBase(dmp1);
00386       pf2.DumpBase(dmp2);
00387       FILE *f1 = fopen("C:\\yapf1.txt", "wt");
00388       FILE *f2 = fopen("C:\\yapf2.txt", "wt");
00389       fwrite(dmp1.m_out.Data(), 1, dmp1.m_out.Size(), f1);
00390       fwrite(dmp2.m_out.Data(), 1, dmp2.m_out.Size(), f2);
00391       fclose(f1);
00392       fclose(f2);
00393     }
00394 #endif
00395 
00396     return result1;
00397   }
00398 
00399   FORCEINLINE Trackdir ChooseRailTrack(const Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool *path_not_found, bool reserve_track, PBSTileInfo *target)
00400   {
00401     if (target != NULL) target->tile = INVALID_TILE;
00402 
00403     // set origin and destination nodes
00404     PBSTileInfo origin = FollowTrainReservation(v);
00405     Yapf().SetOrigin(origin.tile, origin.trackdir, INVALID_TILE, INVALID_TRACKDIR, 1, true);
00406     Yapf().SetDestination(v);
00407 
00408     // find the best path
00409     bool path_found = Yapf().FindPath(v);
00410     if (path_not_found != NULL) {
00411       // tell controller that the path was only 'guessed'
00412       // treat the path as found if stopped on the first two way signal(s)
00413       *path_not_found = !(path_found || Yapf().m_stopped_on_first_two_way_signal);
00414     }
00415 
00416     // if path not found - return INVALID_TRACKDIR
00417     Trackdir next_trackdir = INVALID_TRACKDIR;
00418     Node *pNode = Yapf().GetBestNode();
00419     if (pNode != NULL) {
00420       // reserve till end of path
00421       this->SetReservationTarget(pNode, pNode->GetLastTile(), pNode->GetLastTrackdir());
00422 
00423       // path was found or at least suggested
00424       // walk through the path back to the origin
00425       Node *pPrev = NULL;
00426       while (pNode->m_parent != NULL) {
00427         pPrev = pNode;
00428         pNode = pNode->m_parent;
00429 
00430         this->FindSafePositionOnNode(pPrev);
00431       }
00432       // return trackdir from the best origin node (one of start nodes)
00433       Node& best_next_node = *pPrev;
00434       next_trackdir = best_next_node.GetTrackdir();
00435 
00436       if (reserve_track && path_found) this->TryReservePath(target);
00437     }
00438     return next_trackdir;
00439   }
00440 
00441   static bool stCheckReverseTrain(const Vehicle *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int reverse_penalty)
00442   {
00443     Tpf pf1;
00444     bool result1 = pf1.CheckReverseTrain(v, t1, td1, t2, td2, reverse_penalty);
00445 
00446 #if DEBUG_YAPF_CACHE
00447     Tpf pf2;
00448     pf2.DisableCache(true);
00449     bool result2 = pf2.CheckReverseTrain(v, t1, td1, t2, td2, reverse_penalty);
00450     if (result1 != result2) {
00451       DEBUG(yapf, 0, "CACHE ERROR: CheckReverseTrain() = [%s, %s]", result1 ? "T" : "F", result2 ? "T" : "F");
00452     }
00453 #endif
00454 
00455     return result1;
00456   }
00457 
00458   FORCEINLINE bool CheckReverseTrain(const Vehicle *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int reverse_penalty)
00459   {
00460     // create pathfinder instance
00461     // set origin and destination nodes
00462     Yapf().SetOrigin(t1, td1, t2, td2, reverse_penalty, false);
00463     Yapf().SetDestination(v);
00464 
00465     // find the best path
00466     bool bFound = Yapf().FindPath(v);
00467 
00468     if (!bFound) return false;
00469 
00470     // path was found
00471     // walk through the path back to the origin
00472     Node *pNode = Yapf().GetBestNode();
00473     while (pNode->m_parent != NULL) {
00474       pNode = pNode->m_parent;
00475     }
00476 
00477     // check if it was reversed origin
00478     Node& best_org_node = *pNode;
00479     bool reversed = (best_org_node.m_cost != 0);
00480     return reversed;
00481   }
00482 };
00483 
00484 template <class Tpf_, class Ttrack_follower, class Tnode_list, template <class Types> class TdestinationT, template <class Types> class TfollowT>
00485 struct CYapfRail_TypesT
00486 {
00487   typedef CYapfRail_TypesT<Tpf_, Ttrack_follower, Tnode_list, TdestinationT, TfollowT>  Types;
00488 
00489   typedef Tpf_                                Tpf;
00490   typedef Ttrack_follower                     TrackFollower;
00491   typedef Tnode_list                          NodeList;
00492   typedef CYapfBaseT<Types>                   PfBase;
00493   typedef TfollowT<Types>                     PfFollow;
00494   typedef CYapfOriginTileTwoWayT<Types>       PfOrigin;
00495   typedef TdestinationT<Types>                PfDestination;
00496   typedef CYapfSegmentCostCacheGlobalT<Types> PfCache;
00497   typedef CYapfCostRailT<Types>               PfCost;
00498 };
00499 
00500 struct CYapfRail1         : CYapfT<CYapfRail_TypesT<CYapfRail1        , CFollowTrackRail    , CRailNodeListTrackDir, CYapfDestinationTileOrStationRailT, CYapfFollowRailT> > {};
00501 struct CYapfRail2         : CYapfT<CYapfRail_TypesT<CYapfRail2        , CFollowTrackRailNo90, CRailNodeListTrackDir, CYapfDestinationTileOrStationRailT, CYapfFollowRailT> > {};
00502 
00503 struct CYapfAnyDepotRail1 : CYapfT<CYapfRail_TypesT<CYapfAnyDepotRail1, CFollowTrackRail    , CRailNodeListTrackDir, CYapfDestinationAnyDepotRailT     , CYapfFollowAnyDepotRailT> > {};
00504 struct CYapfAnyDepotRail2 : CYapfT<CYapfRail_TypesT<CYapfAnyDepotRail2, CFollowTrackRailNo90, CRailNodeListTrackDir, CYapfDestinationAnyDepotRailT     , CYapfFollowAnyDepotRailT> > {};
00505 
00506 struct CYapfAnySafeTileRail1 : CYapfT<CYapfRail_TypesT<CYapfAnySafeTileRail1, CFollowTrackFreeRail    , CRailNodeListTrackDir, CYapfDestinationAnySafeTileRailT , CYapfFollowAnySafeTileRailT> > {};
00507 struct CYapfAnySafeTileRail2 : CYapfT<CYapfRail_TypesT<CYapfAnySafeTileRail2, CFollowTrackFreeRailNo90, CRailNodeListTrackDir, CYapfDestinationAnySafeTileRailT , CYapfFollowAnySafeTileRailT> > {};
00508 
00509 
00510 Trackdir YapfChooseRailTrack(const Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool *path_not_found, bool reserve_track, PBSTileInfo *target)
00511 {
00512   // default is YAPF type 2
00513   typedef Trackdir (*PfnChooseRailTrack)(const Vehicle*, TileIndex, DiagDirection, TrackBits, bool*, bool, PBSTileInfo*);
00514   PfnChooseRailTrack pfnChooseRailTrack = &CYapfRail1::stChooseRailTrack;
00515 
00516   // check if non-default YAPF type needed
00517   if (_settings_game.pf.forbid_90_deg) {
00518     pfnChooseRailTrack = &CYapfRail2::stChooseRailTrack; // Trackdir, forbid 90-deg
00519   }
00520 
00521   Trackdir td_ret = pfnChooseRailTrack(v, tile, enterdir, tracks, path_not_found, reserve_track, target);
00522 
00523   return td_ret;
00524 }
00525 
00526 bool YapfCheckReverseTrain(const Vehicle *v)
00527 {
00528   /* last wagon */
00529   const Vehicle *last_veh = GetLastVehicleInChain(v);
00530 
00531   // get trackdirs of both ends
00532   Trackdir td = GetVehicleTrackdir(v);
00533   Trackdir td_rev = ReverseTrackdir(GetVehicleTrackdir(last_veh));
00534 
00535   /* tiles where front and back are */
00536   TileIndex tile = v->tile;
00537   TileIndex tile_rev = last_veh->tile;
00538 
00539   int reverse_penalty = 0;
00540 
00541   if (v->u.rail.track == TRACK_BIT_WORMHOLE) {
00542     /* front in tunnel / on bridge */
00543     DiagDirection dir_into_wormhole = GetTunnelBridgeDirection(tile);
00544 
00545     if (TrackdirToExitdir(td) == dir_into_wormhole) tile = GetOtherTunnelBridgeEnd(tile);
00546     /* Now 'tile' is the tunnel entry/bridge ramp the train will reach when driving forward */
00547 
00548     /* Current position of the train in the wormhole */
00549     TileIndex cur_tile = TileVirtXY(v->x_pos, v->y_pos);
00550 
00551     /* Add distance to drive in the wormhole as penalty for the forward path, i.e. bonus for the reverse path
00552      * Note: Negative penalties are ok for the start tile. */
00553     reverse_penalty -= DistanceManhattan(cur_tile, tile) * YAPF_TILE_LENGTH;
00554   }
00555 
00556   if (last_veh->u.rail.track == TRACK_BIT_WORMHOLE) {
00557     /* back in tunnel / on bridge */
00558     DiagDirection dir_into_wormhole = GetTunnelBridgeDirection(tile_rev);
00559 
00560     if (TrackdirToExitdir(td_rev) == dir_into_wormhole) tile_rev = GetOtherTunnelBridgeEnd(tile_rev);
00561     /* Now 'tile_rev' is the tunnel entry/bridge ramp the train will reach when reversing */
00562 
00563     /* Current position of the last wagon in the wormhole */
00564     TileIndex cur_tile = TileVirtXY(last_veh->x_pos, last_veh->y_pos);
00565 
00566     /* Add distance to drive in the wormhole as penalty for the revere path. */
00567     reverse_penalty += DistanceManhattan(cur_tile, tile_rev) * YAPF_TILE_LENGTH;
00568   }
00569 
00570   typedef bool (*PfnCheckReverseTrain)(const Vehicle*, TileIndex, Trackdir, TileIndex, Trackdir, int);
00571   PfnCheckReverseTrain pfnCheckReverseTrain = CYapfRail1::stCheckReverseTrain;
00572 
00573   // check if non-default YAPF type needed
00574   if (_settings_game.pf.forbid_90_deg) {
00575     pfnCheckReverseTrain = &CYapfRail2::stCheckReverseTrain; // Trackdir, forbid 90-deg
00576   }
00577 
00578   /* slightly hackish: If the pathfinders finds a path, the cost of the first node is tested to distinguish between forward- and reverse-path. */
00579   if (reverse_penalty == 0) reverse_penalty = 1;
00580 
00581   bool reverse = pfnCheckReverseTrain(v, tile, td, tile_rev, td_rev, reverse_penalty);
00582 
00583   return reverse;
00584 }
00585 
00586 bool YapfFindNearestRailDepotTwoWay(const Vehicle *v, int max_distance, int reverse_penalty, TileIndex *depot_tile, bool *reversed)
00587 {
00588   *depot_tile = INVALID_TILE;
00589   *reversed = false;
00590 
00591   const Vehicle *last_veh = GetLastVehicleInChain(v);
00592 
00593   PBSTileInfo origin = FollowTrainReservation(v);
00594   TileIndex last_tile = last_veh->tile;
00595   Trackdir td_rev = ReverseTrackdir(GetVehicleTrackdir(last_veh));
00596 
00597   typedef bool (*PfnFindNearestDepotTwoWay)(const Vehicle*, TileIndex, Trackdir, TileIndex, Trackdir, int, int, TileIndex*, bool*);
00598   PfnFindNearestDepotTwoWay pfnFindNearestDepotTwoWay = &CYapfAnyDepotRail1::stFindNearestDepotTwoWay;
00599 
00600   // check if non-default YAPF type needed
00601   if (_settings_game.pf.forbid_90_deg) {
00602     pfnFindNearestDepotTwoWay = &CYapfAnyDepotRail2::stFindNearestDepotTwoWay; // Trackdir, forbid 90-deg
00603   }
00604 
00605   bool ret = pfnFindNearestDepotTwoWay(v, origin.tile, origin.trackdir, last_tile, td_rev, max_distance, reverse_penalty, depot_tile, reversed);
00606   return ret;
00607 }
00608 
00609 bool YapfRailFindNearestSafeTile(const Vehicle *v, TileIndex tile, Trackdir td, bool override_railtype)
00610 {
00611   typedef bool (*PfnFindNearestSafeTile)(const Vehicle*, TileIndex, Trackdir, bool);
00612   PfnFindNearestSafeTile pfnFindNearestSafeTile = CYapfAnySafeTileRail1::stFindNearestSafeTile;
00613 
00614   /* check if non-default YAPF type needed */
00615   if (_settings_game.pf.forbid_90_deg) {
00616     pfnFindNearestSafeTile = &CYapfAnySafeTileRail2::stFindNearestSafeTile;
00617   }
00618 
00619   return pfnFindNearestSafeTile(v, tile, td, override_railtype);
00620 }
00621 
00623 int CSegmentCostCacheBase::s_rail_change_counter = 0;
00624 
00625 void YapfNotifyTrackLayoutChange(TileIndex tile, Track track)
00626 {
00627   CSegmentCostCacheBase::NotifyTrackLayoutChange(tile, track);
00628 }

Generated on Mon Mar 9 23:33:53 2009 for openttd by  doxygen 1.5.6