/** Called when YAPF needs to place origin nodes into open list */
void PfSetStartupNodes()
{
bool is_choice = (KillFirstBit(m_orgTrackdirs) != TRACKDIR_BIT_NONE);
for (TrackdirBits tdb = m_orgTrackdirs; tdb != TRACKDIR_BIT_NONE; tdb = KillFirstBit(tdb)) {
Trackdir td = (Trackdir)FindFirstBit2x64(tdb);
Node &n1 = Yapf().CreateNewNode();
n1.Set(NULL, m_orgTile, td, is_choice);
Yapf().AddStartupNode(n1);
}
}
Trackdir YapfRoadVehicleChooseTrack(const RoadVehicle *v, TileIndex tile, DiagDirection enterdir, TrackdirBits trackdirs, bool &path_found)
{
/* default is YAPF type 2 */
typedef Trackdir (*PfnChooseRoadTrack)(const RoadVehicle*, TileIndex, DiagDirection, bool &path_found);
PfnChooseRoadTrack pfnChooseRoadTrack = &CYapfRoad2::stChooseRoadTrack; // default: ExitDir, allow 90-deg
/* check if non-default YAPF type should be used */
if (_settings_game.pf.yapf.disable_node_optimization) {
pfnChooseRoadTrack = &CYapfRoad1::stChooseRoadTrack; // Trackdir, allow 90-deg
}
Trackdir td_ret = pfnChooseRoadTrack(v, tile, enterdir, path_found);
return (td_ret != INVALID_TRACKDIR) ? td_ret : (Trackdir)FindFirstBit2x64(trackdirs);
}
static Trackdir ChooseShipTrack(const Ship *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool &path_found)
{
/* handle special case - when next tile is destination tile */
if (tile == v->dest_tile) {
/* convert tracks to trackdirs */
TrackdirBits trackdirs = (TrackdirBits)(tracks | ((int)tracks << 8));
/* limit to trackdirs reachable from enterdir */
trackdirs &= DiagdirReachesTrackdirs(enterdir);
/* use vehicle's current direction if that's possible, otherwise use first usable one. */
Trackdir veh_dir = v->GetVehicleTrackdir();
return ((trackdirs & TrackdirToTrackdirBits(veh_dir)) != 0) ? veh_dir : (Trackdir)FindFirstBit2x64(trackdirs);
}
/* move back to the old tile/trackdir (where ship is coming from) */
TileIndex src_tile = TILE_ADD(tile, TileOffsByDiagDir(ReverseDiagDir(enterdir)));
Trackdir trackdir = v->GetVehicleTrackdir();
assert(IsValidTrackdir(trackdir));
/* convert origin trackdir to TrackdirBits */
TrackdirBits trackdirs = TrackdirToTrackdirBits(trackdir);
/* get available trackdirs on the destination tile */
TrackdirBits dest_trackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(v->dest_tile, TRANSPORT_WATER, 0));
/* create pathfinder instance */
Tpf pf;
/* set origin and destination nodes */
pf.SetOrigin(src_tile, trackdirs);
pf.SetDestination(v->dest_tile, dest_trackdirs);
/* find best path */
path_found = pf.FindPath(v);
Trackdir next_trackdir = INVALID_TRACKDIR; // this would mean "path not found"
Node *pNode = pf.GetBestNode();
if (pNode != NULL) {
/* walk through the path back to the origin */
Node *pPrevNode = NULL;
while (pNode->m_parent != NULL) {
pPrevNode = pNode;
pNode = pNode->m_parent;
}
/* return trackdir from the best next node (direct child of origin) */
Node& best_next_node = *pPrevNode;
assert(best_next_node.GetTile() == tile);
next_trackdir = best_next_node.GetTrackdir();
}
return next_trackdir;
}
/**
* Called by YAPF to calculate the cost from the origin to the given node.
* Calculates only the cost of given node, adds it to the parent node cost
* and stores the result into Node::m_cost member
*/
inline bool PfCalcCost(Node& n, const TrackFollower *tf)
{
int segment_cost = 0;
uint tiles = 0;
/* start at n.m_key.m_tile / n.m_key.m_td and walk to the end of segment */
TileIndex tile = n.m_key.m_tile;
Trackdir trackdir = n.m_key.m_td;
for (;;) {
/* base tile cost depending on distance between edges */
segment_cost += Yapf().OneTileCost(tile, trackdir);
const RoadVehicle *v = Yapf().GetVehicle();
/* we have reached the vehicle's destination - segment should end here to avoid target skipping */
if (Yapf().PfDetectDestinationTile(tile, trackdir)) break;
/* stop if we have just entered the depot */
if (IsRoadDepotTile(tile) && trackdir == DiagDirToDiagTrackdir(ReverseDiagDir(GetRoadDepotDirection(tile)))) {
/* next time we will reverse and leave the depot */
break;
}
/* if there are no reachable trackdirs on new tile, we have end of road */
TrackFollower F(Yapf().GetVehicle());
if (!F.Follow(tile, trackdir)) break;
/* if there are more trackdirs available & reachable, we are at the end of segment */
if (KillFirstBit(F.m_new_td_bits) != TRACKDIR_BIT_NONE) break;
Trackdir new_td = (Trackdir)FindFirstBit2x64(F.m_new_td_bits);
/* stop if RV is on simple loop with no junctions */
if (F.m_new_tile == n.m_key.m_tile && new_td == n.m_key.m_td) return false;
/* if we skipped some tunnel tiles, add their cost */
segment_cost += F.m_tiles_skipped * YAPF_TILE_LENGTH;
tiles += F.m_tiles_skipped + 1;
/* add hilly terrain penalty */
segment_cost += Yapf().SlopeCost(tile, F.m_new_tile, trackdir);
/* add min/max speed penalties */
int min_speed = 0;
int max_veh_speed = v->GetDisplayMaxSpeed();
int max_speed = F.GetSpeedLimit(&min_speed);
if (max_speed < max_veh_speed) segment_cost += 1 * (max_veh_speed - max_speed);
if (min_speed > max_veh_speed) segment_cost += 10 * (min_speed - max_veh_speed);
/* move to the next tile */
tile = F.m_new_tile;
trackdir = new_td;
if (tiles > MAX_MAP_SIZE) break;
}
/* save end of segment back to the node */
n.m_segment_last_tile = tile;
n.m_segment_last_td = trackdir;
/* save also tile cost */
int parent_cost = (n.m_parent != NULL) ? n.m_parent->m_cost : 0;
n.m_cost = parent_cost + segment_cost;
return true;
}
/**
* Called by YAPF to calculate the cost from the origin to the given node.
* Calculates only the cost of given node, adds it to the parent node cost
* and stores the result into Node::m_cost member
*/
inline bool PfCalcCost(Node &n, const TrackFollower *tf)
{
assert(!n.flags_u.flags_s.m_targed_seen);
assert(tf->m_new_tile == n.m_key.m_tile);
assert((TrackdirToTrackdirBits(n.m_key.m_td) & tf->m_new_td_bits) != TRACKDIR_BIT_NONE);
CPerfStart perf_cost(Yapf().m_perf_cost);
/* Does the node have some parent node? */
bool has_parent = (n.m_parent != NULL);
/* Do we already have a cached segment? */
CachedData &segment = *n.m_segment;
bool is_cached_segment = (segment.m_cost >= 0);
int parent_cost = has_parent ? n.m_parent->m_cost : 0;
/* Each node cost contains 2 or 3 main components:
* 1. Transition cost - cost of the move from previous node (tile):
* - curve cost (or zero for straight move)
* 2. Tile cost:
* - base tile cost
* - YAPF_TILE_LENGTH for diagonal tiles
* - YAPF_TILE_CORNER_LENGTH for non-diagonal tiles
* - tile penalties
* - tile slope penalty (upward slopes)
* - red signal penalty
* - level crossing penalty
* - speed-limit penalty (bridges)
* - station platform penalty
* - penalty for reversing in the depot
* - etc.
* 3. Extra cost (applies to the last node only)
* - last red signal penalty
* - penalty for too long or too short platform on the destination station
*/
int transition_cost = 0;
int extra_cost = 0;
/* Segment: one or more tiles connected by contiguous tracks of the same type.
* Each segment cost includes 'Tile cost' for all its tiles (including the first
* and last), and the 'Transition cost' between its tiles. The first transition
* cost of segment entry (move from the 'parent' node) is not included!
*/
int segment_entry_cost = 0;
int segment_cost = 0;
const Train *v = Yapf().GetVehicle();
/* start at n.m_key.m_tile / n.m_key.m_td and walk to the end of segment */
TILE cur(n.m_key.m_tile, n.m_key.m_td);
/* the previous tile will be needed for transition cost calculations */
TILE prev = !has_parent ? TILE() : TILE(n.m_parent->GetLastTile(), n.m_parent->GetLastTrackdir());
EndSegmentReasonBits end_segment_reason = ESRB_NONE;
TrackFollower tf_local(v, Yapf().GetCompatibleRailTypes(), &Yapf().m_perf_ts_cost);
if (!has_parent) {
/* We will jump to the middle of the cost calculator assuming that segment cache is not used. */
assert(!is_cached_segment);
/* Skip the first transition cost calculation. */
goto no_entry_cost;
}
for (;;) {
/* Transition cost (cost of the move from previous tile) */
transition_cost = Yapf().CurveCost(prev.td, cur.td);
transition_cost += Yapf().SwitchCost(prev.tile, cur.tile, TrackdirToExitdir(prev.td));
/* First transition cost counts against segment entry cost, other transitions
* inside segment will come to segment cost (and will be cached) */
if (segment_cost == 0) {
/* We just entered the loop. First transition cost goes to segment entry cost)*/
segment_entry_cost = transition_cost;
transition_cost = 0;
/* It is the right time now to look if we can reuse the cached segment cost. */
if (is_cached_segment) {
/* Yes, we already know the segment cost. */
segment_cost = segment.m_cost;
/* We know also the reason why the segment ends. */
end_segment_reason = segment.m_end_segment_reason;
/* We will need also some information about the last signal (if it was red). */
if (segment.m_last_signal_tile != INVALID_TILE) {
assert(HasSignalOnTrackdir(segment.m_last_signal_tile, segment.m_last_signal_td));
SignalState sig_state = GetSignalStateByTrackdir(segment.m_last_signal_tile, segment.m_last_signal_td);
bool is_red = (sig_state == SIGNAL_STATE_RED);
n.flags_u.flags_s.m_last_signal_was_red = is_red;
if (is_red) {
n.m_last_red_signal_type = GetSignalType(segment.m_last_signal_tile, TrackdirToTrack(segment.m_last_signal_td));
}
}
/* No further calculation needed. */
cur = TILE(n.GetLastTile(), n.GetLastTrackdir());
break;
}
} else {
/* Other than first transition cost count as the regular segment cost. */
segment_cost += transition_cost;
}
no_entry_cost: // jump here at the beginning if the node has no parent (it is the first node)
/* All other tile costs will be calculated here. */
segment_cost += Yapf().OneTileCost(cur.tile, cur.td);
/* If we skipped some tunnel/bridge/station tiles, add their base cost */
segment_cost += YAPF_TILE_LENGTH * tf->m_tiles_skipped;
/* Slope cost. */
segment_cost += Yapf().SlopeCost(cur.tile, cur.td);
/* Signal cost (routine can modify segment data). */
segment_cost += Yapf().SignalCost(n, cur.tile, cur.td);
/* Reserved tiles. */
segment_cost += Yapf().ReservationCost(n, cur.tile, cur.td, tf->m_tiles_skipped);
end_segment_reason = segment.m_end_segment_reason;
/* Tests for 'potential target' reasons to close the segment. */
if (cur.tile == prev.tile) {
/* Penalty for reversing in a depot. */
assert(IsRailDepot(cur.tile));
segment_cost += Yapf().PfGetSettings().rail_depot_reverse_penalty;
/* We will end in this pass (depot is possible target) */
end_segment_reason |= ESRB_DEPOT;
} else if (cur.tile_type == MP_STATION && IsRailWaypoint(cur.tile)) {
if (v->current_order.IsType(OT_GOTO_WAYPOINT) &&
GetStationIndex(cur.tile) == v->current_order.GetDestination() &&
!Waypoint::Get(v->current_order.GetDestination())->IsSingleTile()) {
/* This waypoint is our destination; maybe this isn't an unreserved
* one, so check that and if so see that as the last signal being
* red. This way waypoints near stations should work better. */
CFollowTrackRail ft(v);
TileIndex t = cur.tile;
Trackdir td = cur.td;
while (ft.Follow(t, td)) {
assert(t != ft.m_new_tile);
t = ft.m_new_tile;
if (KillFirstBit(ft.m_new_td_bits) != TRACKDIR_BIT_NONE) {
/* We encountered a junction; it's going to be too complex to
* handle this perfectly, so just bail out. There is no simple
* free path, so try the other possibilities. */
td = INVALID_TRACKDIR;
break;
}
td = RemoveFirstTrackdir(&ft.m_new_td_bits);
/* If this is a safe waiting position we're done searching for it */
if (IsSafeWaitingPosition(v, t, td, true, _settings_game.pf.forbid_90_deg)) break;
}
/* In the case this platform is (possibly) occupied we add penalty so the
* other platforms of this waypoint are evaluated as well, i.e. we assume
* that there is a red signal in the waypoint when it's occupied. */
if (td == INVALID_TRACKDIR ||
!IsSafeWaitingPosition(v, t, td, true, _settings_game.pf.forbid_90_deg) ||
!IsWaitingPositionFree(v, t, td, _settings_game.pf.forbid_90_deg)) {
extra_cost += Yapf().PfGetSettings().rail_lastred_penalty;
}
}
/* Waypoint is also a good reason to finish. */
end_segment_reason |= ESRB_WAYPOINT;
} else if (tf->m_is_station) {
/* Station penalties. */
uint platform_length = tf->m_tiles_skipped + 1;
/* We don't know yet if the station is our target or not. Act like
* if it is pass-through station (not our destination). */
segment_cost += Yapf().PfGetSettings().rail_station_penalty * platform_length;
/* We will end in this pass (station is possible target) */
end_segment_reason |= ESRB_STATION;
} else if (TrackFollower::DoTrackMasking() && cur.tile_type == MP_RAILWAY) {
/* Searching for a safe tile? */
if (HasSignalOnTrackdir(cur.tile, cur.td) && !IsPbsSignal(GetSignalType(cur.tile, TrackdirToTrack(cur.td)))) {
end_segment_reason |= ESRB_SAFE_TILE;
}
}
/* Apply min/max speed penalties only when inside the look-ahead radius. Otherwise
* it would cause desync in MP. */
if (n.m_num_signals_passed < m_sig_look_ahead_costs.Size())
{
int min_speed = 0;
int max_speed = tf->GetSpeedLimit(&min_speed);
int max_veh_speed = v->GetDisplayMaxSpeed();
if (max_speed < max_veh_speed) {
extra_cost += YAPF_TILE_LENGTH * (max_veh_speed - max_speed) * (4 + tf->m_tiles_skipped) / max_veh_speed;
}
if (min_speed > max_veh_speed) {
extra_cost += YAPF_TILE_LENGTH * (min_speed - max_veh_speed);
}
}
/* Finish if we already exceeded the maximum path cost (i.e. when
* searching for the nearest depot). */
if (m_max_cost > 0 && (parent_cost + segment_entry_cost + segment_cost) > m_max_cost) {
end_segment_reason |= ESRB_PATH_TOO_LONG;
}
/* Move to the next tile/trackdir. */
tf = &tf_local;
tf_local.Init(v, Yapf().GetCompatibleRailTypes(), &Yapf().m_perf_ts_cost);
if (!tf_local.Follow(cur.tile, cur.td)) {
assert(tf_local.m_err != TrackFollower::EC_NONE);
/* Can't move to the next tile (EOL?). */
if (tf_local.m_err == TrackFollower::EC_RAIL_TYPE) {
end_segment_reason |= ESRB_RAIL_TYPE;
} else {
end_segment_reason |= ESRB_DEAD_END;
}
if (TrackFollower::DoTrackMasking() && !HasOnewaySignalBlockingTrackdir(cur.tile, cur.td)) {
end_segment_reason |= ESRB_SAFE_TILE;
}
break;
}
/* Check if the next tile is not a choice. */
if (KillFirstBit(tf_local.m_new_td_bits) != TRACKDIR_BIT_NONE) {
/* More than one segment will follow. Close this one. */
end_segment_reason |= ESRB_CHOICE_FOLLOWS;
break;
}
/* Gather the next tile/trackdir/tile_type/rail_type. */
TILE next(tf_local.m_new_tile, (Trackdir)FindFirstBit2x64(tf_local.m_new_td_bits));
if (TrackFollower::DoTrackMasking() && IsTileType(next.tile, MP_RAILWAY)) {
if (HasSignalOnTrackdir(next.tile, next.td) && IsPbsSignal(GetSignalType(next.tile, TrackdirToTrack(next.td)))) {
/* Possible safe tile. */
end_segment_reason |= ESRB_SAFE_TILE;
} else if (HasSignalOnTrackdir(next.tile, ReverseTrackdir(next.td)) && GetSignalType(next.tile, TrackdirToTrack(next.td)) == SIGTYPE_PBS_ONEWAY) {
/* Possible safe tile, but not so good as it's the back of a signal... */
end_segment_reason |= ESRB_SAFE_TILE | ESRB_DEAD_END;
extra_cost += Yapf().PfGetSettings().rail_lastred_exit_penalty;
}
}
/* Check the next tile for the rail type. */
if (next.rail_type != cur.rail_type) {
/* Segment must consist from the same rail_type tiles. */
end_segment_reason |= ESRB_RAIL_TYPE;
break;
}
/* Avoid infinite looping. */
if (next.tile == n.m_key.m_tile && next.td == n.m_key.m_td) {
end_segment_reason |= ESRB_INFINITE_LOOP;
break;
}
if (segment_cost > s_max_segment_cost) {
/* Potentially in the infinite loop (or only very long segment?). We should
* not force it to finish prematurely unless we are on a regular tile. */
if (IsTileType(tf->m_new_tile, MP_RAILWAY)) {
end_segment_reason |= ESRB_SEGMENT_TOO_LONG;
break;
}
}
/* Any other reason bit set? */
if (end_segment_reason != ESRB_NONE) {
break;
}
/* For the next loop set new prev and cur tile info. */
prev = cur;
cur = next;
} // for (;;)
bool target_seen = false;
if ((end_segment_reason & ESRB_POSSIBLE_TARGET) != ESRB_NONE) {
/* Depot, station or waypoint. */
if (Yapf().PfDetectDestination(cur.tile, cur.td)) {
/* Destination found. */
target_seen = true;
}
}
/* Update the segment if needed. */
if (!is_cached_segment) {
/* Write back the segment information so it can be reused the next time. */
segment.m_cost = segment_cost;
segment.m_end_segment_reason = end_segment_reason & ESRB_CACHED_MASK;
/* Save end of segment back to the node. */
n.SetLastTileTrackdir(cur.tile, cur.td);
}
/* Do we have an excuse why not to continue pathfinding in this direction? */
if (!target_seen && (end_segment_reason & ESRB_ABORT_PF_MASK) != ESRB_NONE) {
/* Reason to not continue. Stop this PF branch. */
return false;
}
/* Special costs for the case we have reached our target. */
if (target_seen) {
n.flags_u.flags_s.m_targed_seen = true;
/* Last-red and last-red-exit penalties. */
if (n.flags_u.flags_s.m_last_signal_was_red) {
if (n.m_last_red_signal_type == SIGTYPE_EXIT) {
/* last signal was red pre-signal-exit */
extra_cost += Yapf().PfGetSettings().rail_lastred_exit_penalty;
} else if (!IsPbsSignal(n.m_last_red_signal_type)) {
/* Last signal was red, but not exit or path signal. */
extra_cost += Yapf().PfGetSettings().rail_lastred_penalty;
}
}
/* Station platform-length penalty. */
if ((end_segment_reason & ESRB_STATION) != ESRB_NONE) {
const BaseStation *st = BaseStation::GetByTile(n.GetLastTile());
assert(st != NULL);
uint platform_length = st->GetPlatformLength(n.GetLastTile(), ReverseDiagDir(TrackdirToExitdir(n.GetLastTrackdir())));
/* Reduce the extra cost caused by passing-station penalty (each station receives it in the segment cost). */
extra_cost -= Yapf().PfGetSettings().rail_station_penalty * platform_length;
/* Add penalty for the inappropriate platform length. */
extra_cost += PlatformLengthPenalty(platform_length);
}
}
/* total node cost */
n.m_cost = parent_cost + segment_entry_cost + segment_cost + extra_cost;
return true;
}