12 #include "../../stdafx.h" 
   15 #include "../../roadstop_base.h" 
   17 #include "../../safeguards.h" 
   20 template <
class Types>
 
   24   typedef typename Types::Tpf 
Tpf; 
 
   26   typedef typename Types::NodeList::Titem 
Node; 
 
   27   typedef typename Node::Key 
Key;    
 
   33     return *
static_cast<Tpf *
>(
this);
 
   50       return Yapf().PfGetSettings().road_slope_penalty;
 
   66             cost += 
Yapf().PfGetSettings().road_crossing_penalty;
 
   74             cost += 
Yapf().PfGetSettings().road_stop_penalty;
 
   84             cost += 
Yapf().PfGetSettings().road_stop_bay_occupied_penalty * (!rs->
IsFreeBay(0) + !rs->
IsFreeBay(1)) / 2;
 
  107     int segment_cost = 0;
 
  114       segment_cost += 
Yapf().OneTileCost(tile, trackdir);
 
  118       if (
Yapf().PfDetectDestinationTile(tile, trackdir)) 
break;
 
  128       if (!F.Follow(tile, trackdir)) 
break;
 
  136       if (F.m_new_tile == n.m_key.m_tile && new_td == n.m_key.m_td) 
return false;
 
  140       tiles += F.m_tiles_skipped + 1;
 
  143       segment_cost += 
Yapf().SlopeCost(tile, F.m_new_tile, trackdir);
 
  148       int max_speed = F.GetSpeedLimit(&min_speed);
 
  149       if (max_speed < max_veh_speed) segment_cost += 1 * (max_veh_speed - max_speed);
 
  150       if (min_speed > max_veh_speed) segment_cost += 10 * (min_speed - max_veh_speed);
 
  159     n.m_segment_last_tile = tile;
 
  160     n.m_segment_last_td = trackdir;
 
  163     int parent_cost = (n.m_parent != NULL) ? n.m_parent->m_cost : 0;
 
  164     n.m_cost = parent_cost + segment_cost;
 
  170 template <
class Types>
 
  174   typedef typename Types::Tpf 
Tpf;                     
 
  175   typedef typename Types::TrackFollower TrackFollower;
 
  176   typedef typename Types::NodeList::Titem 
Node;        
 
  177   typedef typename Node::Key 
Key;                      
 
  182     return *
static_cast<Tpf *
>(
this);
 
  203     n.m_estimate = n.m_cost;
 
  209 template <
class Types>
 
  213   typedef typename Types::Tpf 
Tpf;                     
 
  214   typedef typename Types::TrackFollower TrackFollower;
 
  215   typedef typename Types::NodeList::Titem 
Node;        
 
  216   typedef typename Node::Key 
Key;                      
 
  221   StationID    m_dest_station;
 
  235       m_dest_station  = INVALID_STATION;
 
  245     return *
static_cast<Tpf *
>(
this);
 
  252     return PfDetectDestinationTile(n.m_segment_last_tile, n.m_segment_last_td);
 
  257     if (m_dest_station != INVALID_STATION) {
 
  273     static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
 
  274     static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};
 
  276       n.m_estimate = n.m_cost;
 
  282     int x1 = 2 * 
TileX(tile) + dg_dir_to_x_offs[(int)exitdir];
 
  283     int y1 = 2 * 
TileY(tile) + dg_dir_to_y_offs[(int)exitdir];
 
  284     int x2 = 2 * 
TileX(m_destTile);
 
  285     int y2 = 2 * 
TileY(m_destTile);
 
  286     int dx = 
abs(x1 - x2);
 
  287     int dy = 
abs(y1 - y2);
 
  288     int dmin = 
min(dx, dy);
 
  289     int dxy = 
abs(dx - dy);
 
  291     n.m_estimate = n.m_cost + d;
 
  292     assert(n.m_estimate >= n.m_parent->m_estimate);
 
  299 template <
class Types>
 
  303   typedef typename Types::Tpf 
Tpf;                     
 
  304   typedef typename Types::TrackFollower TrackFollower;
 
  305   typedef typename Types::NodeList::Titem 
Node;        
 
  306   typedef typename Node::Key 
Key;                      
 
  312     return *
static_cast<Tpf *
>(
this);
 
  324     TrackFollower F(
Yapf().GetVehicle());
 
  325     if (F.Follow(old_node.m_segment_last_tile, old_node.m_segment_last_td)) {
 
  326       Yapf().AddMultipleNodes(&old_node, F);
 
  339     return pf.ChooseRoadTrack(v, tile, enterdir, path_found);
 
  360     Yapf().SetOrigin(src_tile, src_trackdirs);
 
  361     Yapf().SetDestination(v);
 
  364     path_found = 
Yapf().FindPath(v);
 
  372       while (pNode->m_parent != NULL) {
 
  373         pNode = pNode->m_parent;
 
  376       Node &best_next_node = *pNode;
 
  377       assert(best_next_node.GetTile() == tile);
 
  378       next_trackdir = best_next_node.GetTrackdir();
 
  380     return next_trackdir;
 
  386     return pf.DistanceToTile(v, tile);
 
  392     if (dst_tile == v->
tile) {
 
  400     Yapf().SetDestination(v);
 
  403     uint dist = UINT_MAX;
 
  406     if (!
Yapf().FindPath(v)) 
return dist;
 
  412       dist = pNode->GetCostEstimate();
 
  436     return pf.FindNearestDepot(v, tile, td, max_distance);
 
  464 template <
class Tpf_, 
class Tnode_list, 
template <
class Types> 
class Tdestination>
 
  471   typedef Tnode_list                        NodeList;
 
  481 struct CYapfRoad1         : 
CYapfT<CYapfRoad_TypesT<CYapfRoad1        , CRoadNodeListTrackDir, CYapfDestinationTileRoadT    > > {};
 
  482 struct CYapfRoad2         : 
CYapfT<CYapfRoad_TypesT<CYapfRoad2        , CRoadNodeListExitDir , CYapfDestinationTileRoadT    > > {};
 
  484 struct CYapfRoadAnyDepot1 : 
CYapfT<CYapfRoad_TypesT<CYapfRoadAnyDepot1, CRoadNodeListTrackDir, CYapfDestinationAnyDepotRoadT> > {};
 
  485 struct CYapfRoadAnyDepot2 : 
CYapfT<CYapfRoad_TypesT<CYapfRoadAnyDepot2, CRoadNodeListExitDir , CYapfDestinationAnyDepotRoadT> > {};
 
  492   PfnChooseRoadTrack pfnChooseRoadTrack = &CYapfRoad2::stChooseRoadTrack; 
 
  496     pfnChooseRoadTrack = &CYapfRoad1::stChooseRoadTrack; 
 
  499   Trackdir td_ret = pfnChooseRoadTrack(v, tile, enterdir, path_found);
 
  513   PfnFindNearestDepot pfnFindNearestDepot = &CYapfRoadAnyDepot2::stFindNearestDepot;
 
  517     pfnFindNearestDepot = &CYapfRoadAnyDepot1::stFindNearestDepot; 
 
  520   return pfnFindNearestDepot(v, tile, trackdir, max_distance);