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;
127 TrackFollower F(
Yapf().GetVehicle());
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;
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;
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};
275 if (PfDetectDestination(n)) {
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;
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);
368 Node *pNode =
Yapf().GetBestNode();
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) {
397 if (!SetOriginFromVehiclePos(v))
return UINT_MAX;
400 Yapf().SetDestination(v);
403 uint dist = UINT_MAX;
406 if (!
Yapf().FindPath(v))
return dist;
408 Node *pNode =
Yapf().GetBestNode();
412 dist = pNode->GetCostEstimate();
436 return pf.FindNearestDepot(v, tile, td, max_distance);
459 Node *n =
Yapf().GetBestNode();
464 template <
class Tpf_,
class Tnode_list,
template <
class Types>
class Tdestination>
471 typedef Tnode_list NodeList;
476 typedef Tdestination<Types> PfDestination;
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);
static TileType GetTileType(TileIndex tile)
Get the tiletype of a given tile.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
bool SetOriginFromVehiclePos(const RoadVehicle *v)
Return true if the valid origin (tile/trackdir) was set from the current vehicle position.
YAPF origin provider base class - used when origin is one tile / multiple trackdirs.
Node::Key Key
key to hash tables
Node::Key Key
key to hash tables
bool PfCalcEstimate(Node &n)
Called by YAPF to calculate cost estimate.
static RoadStopType GetRoadStopType(TileIndex t)
Get the road stop type of this tile.
int GetLength() const
Get the length of this drive through stop.
int OneTileCost(TileIndex tile, Trackdir trackdir)
return one tile cost
Flag for an invalid trackdirbit value.
A tile with road (or tram tracks)
int GetDisplayMaxSpeed() const
Gets the maximum speed in km-ish/h that can be sent into SetDParam for string processing.
int GetOccupied() const
Get the amount of occupied space in this drive through stop.
Tpf & Yapf()
to access inherited path finder
TileIndex dest_tile
Heading for this tile.
CYapfSegmentCostCacheNoneT - the formal only yapf cost cache provider that implements PfNodeCacheFetc...
bool PfCalcCost(Node &n, const TrackFollower *tf)
Called by YAPF to calculate the cost from the origin to the given node.
static uint TileX(TileIndex tile)
Get the X component of a tile.
PathfinderSettings pf
settings for all pathfinders
Types::NodeList::Titem Node
this will be our node type
Types::NodeList::Titem Node
this will be our node type
static DiagDirection GetRoadDepotDirection(TileIndex t)
Get the direction of the exit of a road depot.
FindDepotData FindNearestDepot(const RoadVehicle *v, TileIndex tile, Trackdir td, int max_distance)
Find the best depot for a road vehicle.
static TrackdirBits DiagdirReachesTrackdirs(DiagDirection diagdir)
Returns all trackdirs that can be reached when entering a tile from a given (diagonal) direction...
static bool IsLevelCrossing(TileIndex t)
Return whether a tile is a level crossing.
void PfFollowNode(Node &old_node)
Called by YAPF to move from the given node to the next tile.
static bool IsDriveThroughStopTile(TileIndex t)
Is tile t a drive through road stop station?
static DiagDirection TrackdirToExitdir(Trackdir trackdir)
Maps a trackdir to the (4-way) direction the tile is exited when following that trackdir.
Node::Key Key
key to hash tables
static const uint TILE_SIZE
Tile size in world coordinates.
FindDepotData YapfRoadVehicleFindNearestDepot(const RoadVehicle *v, int max_distance)
Used when user sends road vehicle to the nearest depot or if road vehicle needs servicing using YAPF...
Buses, trucks and trams belong to this class.
char TransportTypeChar() const
return debug report character to identify the transportation type
static TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a give tiletype.
CYapfBaseT - A-star type path finder base class.
bool disable_node_optimization
whether to use exit-dir instead of trackdir in node key
YAPFSettings yapf
pathfinder settings for the yet another pathfinder
Types::Tpf Tpf
the pathfinder class (derived from THIS class)
VehicleType
Available vehicle types.
static bool IsTruckStop(TileIndex t)
Is the station at t a truck stop?
static TrackdirBits TrackdirToTrackdirBits(Trackdir trackdir)
Maps a Trackdir to the corresponding TrackdirBits value.
bool IsType(OrderType type) const
Check whether this order is of the given type.
static DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
Trackdir GetVehicleTrackdir() const
Returns the Trackdir on which the vehicle is currently located.
Types::Tpf Tpf
pathfinder (derived from THIS class)
static const int YAPF_TILE_LENGTH
Length (penalty) of one tile with YAPF.
static bool IsRoadDepotTile(TileIndex t)
Return whether a tile is a road depot tile.
Trackdir
Enumeration for tracks and directions.
YAPF template that uses Ttypes template argument to determine all YAPF components (base classes) from...
bool PfDetectDestination(Node &n)
Called by YAPF to detect if node ends in the desired destination.
TileIndex tile
Current tile index.
bool HasArticulatedPart() const
Check if an engine has an articulated part.
static Trackdir DiagDirToDiagTrackdir(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal trackdir that runs in that direction.
Trackdir YapfRoadVehicleChooseTrack(const RoadVehicle *v, TileIndex tile, DiagDirection enterdir, TrackdirBits trackdirs, bool &path_found)
Finds the best path for given road vehicle using YAPF.
bool IsFreeBay(uint nr) const
Checks whether the given bay is free in this road stop.
DiagDirection
Enumeration for diagonal directions.
static T min(const T a, const T b)
Returns the minimum of two values.
Types::Tpf Tpf
the pathfinder class (derived from THIS class)
Track follower helper template class (can serve pathfinders and vehicle controllers).
static TileIndex CalcClosestStationTile(StationID station, TileIndex tile, StationType station_type)
Calculates the tile of given station that is closest to a given tile for this we assume the station i...
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Container for each entry point of a drive through road stop.
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Types::Tpf Tpf
the pathfinder class (derived from THIS class)
static T KillFirstBit(T value)
Clear the first bit in an integer.
bool IsBus() const
Check whether a roadvehicle is a bus.
Node tailored for road pathfinding.
Types::NodeList::Titem Node
this will be our node type
DestinationID GetDestination() const
Gets the destination of this order.
Tpf & Yapf()
to access inherited path finder
uint32 TileIndex
The index/ID of a Tile.
Helper container to find a depot.
Base includes/functions for YAPF.
static uint TileY(TileIndex tile)
Get the Y component of a tile.
bool PfDetectDestination(Node &n)
Called by YAPF to detect if node ends in the desired destination.
static T abs(const T a)
Returns the absolute value of (scalar) variable.
static bool IsDiagonalTrackdir(Trackdir trackdir)
Checks if a given Trackdir is diagonal.
static uint8 FindFirstBit2x64(const int value)
Finds the position of the first non-zero bit in an integer.
Transport by road vehicle.
const Entry * GetEntry(DiagDirection dir) const
Get the drive through road stop entry struct for the given direction.
TrackdirBits
Enumeration of bitmasks for the TrackDirs.
Types::NodeList::Titem Node
this will be our node type
A Stop for a Road Vehicle.
static bool IsDriveThroughRoadStopContinuation(TileIndex rs, TileIndex next)
Checks whether the 'next' tile is still part of the road same drive through stop 'rs' in the same dir...
Tpf & Yapf()
to access inherited path finder
static const uint MAX_MAP_SIZE
Maximal map size = 4096.
Node::Key Key
key to hash tables
Flag for an invalid trackdir.
Tpf & Yapf()
to access inherited path finder
static const int YAPF_TILE_CORNER_LENGTH
Length (penalty) of a corner with YAPF.
Types::TrackFollower TrackFollower
track follower helper
static bool IsBusStop(TileIndex t)
Is the station at t a bus stop?
static TrackdirBits TrackStatusToTrackdirBits(TrackStatus ts)
Returns the present-trackdir-information of a TrackStatus.
Order current_order
The current order (+ status, like: loading)
static RoadStop * GetByTile(TileIndex tile, RoadStopType type)
Find a roadstop at given tile.
bool PfCalcEstimate(Node &n)
Called by YAPF to calculate cost estimate.