/**
* Update signals around segment in _tbuset
*
* @param flags info about segment
*/
static void UpdateSignalsAroundSegment(SigFlags flags)
{
TileIndex tile;
Trackdir trackdir;
while (_tbuset.Get(&tile, &trackdir)) {
assert(HasSignalOnTrackdir(tile, trackdir));
SignalType sig = GetSignalType(tile, TrackdirToTrack(trackdir));
SignalState newstate = SIGNAL_STATE_GREEN;
/* determine whether the new state is red */
if (flags & SF_TRAIN) {
/* train in the segment */
newstate = SIGNAL_STATE_RED;
} else {
/* is it a bidir combo? - then do not count its other signal direction as exit */
if (sig == SIGTYPE_COMBO && HasSignalOnTrackdir(tile, ReverseTrackdir(trackdir))) {
/* at least one more exit */
if ((flags & SF_EXIT2) &&
/* no green exit */
(!(flags & SF_GREEN) ||
/* only one green exit, and it is this one - so all other exits are red */
(!(flags & SF_GREEN2) && GetSignalStateByTrackdir(tile, ReverseTrackdir(trackdir)) == SIGNAL_STATE_GREEN))) {
newstate = SIGNAL_STATE_RED;
}
} else { // entry, at least one exit, no green exit
if (IsPresignalEntry(tile, TrackdirToTrack(trackdir)) && (flags & SF_EXIT) && !(flags & SF_GREEN)) newstate = SIGNAL_STATE_RED;
}
}
/* only when the state changes */
if (newstate != GetSignalStateByTrackdir(tile, trackdir)) {
if (IsPresignalExit(tile, TrackdirToTrack(trackdir))) {
/* for pre-signal exits, add block to the global set */
DiagDirection exitdir = TrackdirToExitdir(ReverseTrackdir(trackdir));
_globset.Add(tile, exitdir); // do not check for full global set, first update all signals
}
SetSignalStateByTrackdir(tile, trackdir, newstate);
MarkTileDirtyByTile(tile);
}
}
}
/**
* Lift the reservation of the tiles from @p start till @p end, excluding @p end itself.
*/
static void ClearPathReservation(const PathNode *start, const PathNode *end)
{
bool first_run = true;
for (; start != end; start = start->parent) {
if (IsRailStationTile(start->node.tile) && first_run) {
SetRailStationPlatformReservation(start->node.tile, TrackdirToExitdir(start->node.direction), false);
} else {
UnreserveRailTrack(start->node.tile, TrackdirToTrack(start->node.direction));
}
first_run = false;
}
}
/** Called by YAPF to detect if node ends in the desired destination */
FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td)
{
bool bDest;
if (m_dest_station_id != INVALID_STATION) {
bDest = HasStationTileRail(tile)
&& (GetStationIndex(tile) == m_dest_station_id)
&& (GetRailStationTrack(tile) == TrackdirToTrack(td));
} else {
bDest = (tile == m_destTile)
&& ((m_destTrackdirs & TrackdirToTrackdirBits(td)) != TRACKDIR_BIT_NONE);
}
return bDest;
}
/** The cost for reserved tiles, including skipped ones. */
inline int ReservationCost(Node& n, TileIndex tile, Trackdir trackdir, int skipped)
{
if (n.m_num_signals_passed >= m_sig_look_ahead_costs.Size() / 2) return 0;
if (!IsPbsSignal(n.m_last_signal_type)) return 0;
if (IsRailStationTile(tile) && IsAnyStationTileReserved(tile, trackdir, skipped)) {
return Yapf().PfGetSettings().rail_pbs_station_penalty * (skipped + 1);
} else if (TrackOverlapsTracks(GetReservedTrackbits(tile), TrackdirToTrack(trackdir))) {
int cost = Yapf().PfGetSettings().rail_pbs_cross_penalty;
if (!IsDiagonalTrackdir(trackdir)) cost = (cost * YAPF_TILE_CORNER_LENGTH) / YAPF_TILE_LENGTH;
return cost * (skipped + 1);
}
return 0;
}
/** Ship controller helper - path finder invoker */
Track YapfShipChooseTrack(const Ship *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks)
{
/* default is YAPF type 2 */
typedef Trackdir (*PfnChooseShipTrack)(const Ship*, TileIndex, DiagDirection, TrackBits);
PfnChooseShipTrack pfnChooseShipTrack = CYapfShip2::ChooseShipTrack; // default: ExitDir, allow 90-deg
/* check if non-default YAPF type needed */
if (_settings_game.pf.forbid_90_deg) {
pfnChooseShipTrack = &CYapfShip3::ChooseShipTrack; // Trackdir, forbid 90-deg
} else if (_settings_game.pf.yapf.disable_node_optimization) {
pfnChooseShipTrack = &CYapfShip1::ChooseShipTrack; // Trackdir, allow 90-deg
}
Trackdir td_ret = pfnChooseShipTrack(v, tile, enterdir, tracks);
return (td_ret != INVALID_TRACKDIR) ? TrackdirToTrack(td_ret) : INVALID_TRACK;
}
static uint NPFReservedTrackCost(AyStarNode *current)
{
TileIndex tile = current->tile;
TrackBits track = TrackToTrackBits(TrackdirToTrack(current->direction));
TrackBits res = GetReservedTrackbits(tile);
if (NPFGetFlag(current, NPF_FLAG_3RD_SIGNAL) || NPFGetFlag(current, NPF_FLAG_LAST_SIGNAL_BLOCK) || ((res & track) == TRACK_BIT_NONE && !TracksOverlap(res | track))) return 0;
if (IsTileType(tile, MP_TUNNELBRIDGE)) {
DiagDirection exitdir = TrackdirToExitdir(current->direction);
if (GetTunnelBridgeDirection(tile) == ReverseDiagDir(exitdir)) {
return _settings_game.pf.npf.npf_rail_pbs_cross_penalty * (GetTunnelBridgeLength(tile, GetOtherTunnelBridgeEnd(tile)) + 1);
}
}
return _settings_game.pf.npf.npf_rail_pbs_cross_penalty;
}
/**
* To be called when @p current contains the (shortest route to) the target node.
* Will fill the contents of the NPFFoundTargetData using
* AyStarNode[NPF_TRACKDIR_CHOICE]. If requested, path reservation
* is done here.
*/
static void NPFSaveTargetData(AyStar *as, OpenListNode *current)
{
NPFFoundTargetData *ftd = (NPFFoundTargetData*)as->user_path;
ftd->best_trackdir = (Trackdir)current->path.node.user_data[NPF_TRACKDIR_CHOICE];
ftd->best_path_dist = current->g;
ftd->best_bird_dist = 0;
ftd->node = current->path.node;
ftd->res_okay = false;
if (as->user_target != NULL && ((NPFFindStationOrTileData*)as->user_target)->reserve_path && as->user_data[NPF_TYPE] == TRANSPORT_RAIL) {
/* Path reservation is requested. */
const Train *v = Train::From(((NPFFindStationOrTileData *)as->user_target)->v);
const PathNode *target = FindSafePosition(¤t->path, v);
ftd->node = target->node;
/* If the target is a station skip to platform end. */
if (IsRailStationTile(target->node.tile)) {
DiagDirection dir = TrackdirToExitdir(target->node.direction);
uint len = Station::GetByTile(target->node.tile)->GetPlatformLength(target->node.tile, dir);
TileIndex end_tile = TILE_ADD(target->node.tile, (len - 1) * TileOffsByDiagDir(dir));
/* Update only end tile, trackdir of a station stays the same. */
ftd->node.tile = end_tile;
if (!IsWaitingPositionFree(v, end_tile, target->node.direction, _settings_game.pf.forbid_90_deg)) return;
SetRailStationPlatformReservation(target->node.tile, dir, true);
SetRailStationReservation(target->node.tile, false);
} else {
if (!IsWaitingPositionFree(v, target->node.tile, target->node.direction, _settings_game.pf.forbid_90_deg)) return;
}
for (const PathNode *cur = target; cur->parent != NULL; cur = cur->parent) {
if (!TryReserveRailTrack(cur->node.tile, TrackdirToTrack(cur->node.direction))) {
/* Reservation failed, undo. */
ClearPathReservation(target, cur);
return;
}
}
ftd->res_okay = true;
}
}
/* Determine the cost of this node, for railway tracks */
static int32 NPFRailPathCost(AyStar *as, AyStarNode *current, OpenListNode *parent)
{
TileIndex tile = current->tile;
Trackdir trackdir = current->direction;
int32 cost = 0;
/* HACK: We create a OpenListNode manually, so we can call EndNodeCheck */
OpenListNode new_node;
/* Determine base length */
switch (GetTileType(tile)) {
case MP_TUNNELBRIDGE:
cost = IsTunnel(tile) ? NPFTunnelCost(current) : NPFBridgeCost(current);
break;
case MP_RAILWAY:
cost = _trackdir_length[trackdir]; // Should be different for diagonal tracks
break;
case MP_ROAD: // Railway crossing
cost = NPF_TILE_LENGTH;
break;
case MP_STATION:
/* We give a station tile a penalty. Logically we would only want to give
* station tiles that are not our destination this penalty. This would
* discourage trains to drive through busy stations. But, we can just
* give any station tile a penalty, because every possible route will get
* this penalty exactly once, on its end tile (if it's a station) and it
* will therefore not make a difference. */
cost = NPF_TILE_LENGTH + _settings_game.pf.npf.npf_rail_station_penalty;
if (IsRailWaypoint(tile)) {
NPFFindStationOrTileData *fstd = (NPFFindStationOrTileData*)as->user_target;
if (fstd->v->current_order.IsType(OT_GOTO_WAYPOINT) && GetStationIndex(tile) == fstd->v->current_order.GetDestination()) {
/* 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. */
const Train *train = Train::From(fstd->v);
CFollowTrackRail ft(train);
TileIndex t = tile;
Trackdir td = trackdir;
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(train, t, td, true, _settings_game.pf.forbid_90_deg)) break;
}
if (td == INVALID_TRACKDIR ||
!IsSafeWaitingPosition(train, t, td, true, _settings_game.pf.forbid_90_deg) ||
!IsWaitingPositionFree(train, t, td, _settings_game.pf.forbid_90_deg)) {
cost += _settings_game.pf.npf.npf_rail_lastred_penalty;
}
}
}
break;
default:
break;
}
/* Determine extra costs */
/* Check for signals */
if (IsTileType(tile, MP_RAILWAY)) {
if (HasSignalOnTrackdir(tile, trackdir)) {
SignalType sigtype = GetSignalType(tile, TrackdirToTrack(trackdir));
/* Ordinary track with signals */
if (GetSignalStateByTrackdir(tile, trackdir) == SIGNAL_STATE_RED) {
/* Signal facing us is red */
if (!NPFGetFlag(current, NPF_FLAG_SEEN_SIGNAL)) {
/* Penalize the first signal we
* encounter, if it is red */
/* Is this a presignal exit or combo? */
if (!IsPbsSignal(sigtype)) {
if (sigtype == SIGTYPE_EXIT || sigtype == SIGTYPE_COMBO) {
/* Penalise exit and combo signals differently (heavier) */
cost += _settings_game.pf.npf.npf_rail_firstred_exit_penalty;
} else {
cost += _settings_game.pf.npf.npf_rail_firstred_penalty;
}
}
}
/* Record the state of this signal */
NPFSetFlag(current, NPF_FLAG_LAST_SIGNAL_RED, true);
} else {
/* Record the state of this signal */
NPFSetFlag(current, NPF_FLAG_LAST_SIGNAL_RED, false);
}
if (NPFGetFlag(current, NPF_FLAG_SEEN_SIGNAL)) {
if (NPFGetFlag(current, NPF_FLAG_2ND_SIGNAL)) {
NPFSetFlag(current, NPF_FLAG_3RD_SIGNAL, true);
} else {
NPFSetFlag(current, NPF_FLAG_2ND_SIGNAL, true);
}
} else {
NPFSetFlag(current, NPF_FLAG_SEEN_SIGNAL, true);
}
NPFSetFlag(current, NPF_FLAG_LAST_SIGNAL_BLOCK, !IsPbsSignal(sigtype));
}
if (HasPbsSignalOnTrackdir(tile, ReverseTrackdir(trackdir)) && !NPFGetFlag(current, NPF_FLAG_3RD_SIGNAL)) {
cost += _settings_game.pf.npf.npf_rail_pbs_signal_back_penalty;
}
}
/* Penalise the tile if it is a target tile and the last signal was
* red */
/* HACK: We create a new_node here so we can call EndNodeCheck. Ugly as hell
* of course... */
new_node.path.node = *current;
if (as->EndNodeCheck(as, &new_node) == AYSTAR_FOUND_END_NODE && NPFGetFlag(current, NPF_FLAG_LAST_SIGNAL_RED))
cost += _settings_game.pf.npf.npf_rail_lastred_penalty;
/* Check for slope */
cost += NPFSlopeCost(current);
/* Check for turns */
if (current->direction != NextTrackdir((Trackdir)parent->path.node.direction))
cost += _settings_game.pf.npf.npf_rail_curve_penalty;
/* TODO, with realistic acceleration, also the amount of straight track between
* curves should be taken into account, as this affects the speed limit. */
/* Check for reverse in depot */
if (IsRailDepotTile(tile) && as->EndNodeCheck(as, &new_node) != AYSTAR_FOUND_END_NODE) {
/* Penalise any depot tile that is not the last tile in the path. This
* _should_ penalise every occurence of reversing in a depot (and only
* that) */
cost += _settings_game.pf.npf.npf_rail_depot_reverse_penalty;
}
/* Check for occupied track */
cost += NPFReservedTrackCost(current);
NPFMarkTile(tile);
DEBUG(npf, 4, "Calculating G for: (%d, %d). Result: %d", TileX(current->tile), TileY(current->tile), cost);
return cost;
}
/**
* 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;
}
int SignalCost(Node& n, TileIndex tile, Trackdir trackdir)
{
int cost = 0;
/* if there is one-way signal in the opposite direction, then it is not our way */
CPerfStart perf_cost(Yapf().m_perf_other_cost);
if (IsTileType(tile, MP_RAILWAY)) {
bool has_signal_against = HasSignalOnTrackdir(tile, ReverseTrackdir(trackdir));
bool has_signal_along = HasSignalOnTrackdir(tile, trackdir);
if (has_signal_against && !has_signal_along && IsOnewaySignal(tile, TrackdirToTrack(trackdir))) {
/* one-way signal in opposite direction */
n.m_segment->m_end_segment_reason |= ESRB_DEAD_END;
} else {
if (has_signal_along) {
SignalState sig_state = GetSignalStateByTrackdir(tile, trackdir);
SignalType sig_type = GetSignalType(tile, TrackdirToTrack(trackdir));
n.m_last_signal_type = sig_type;
/* cache the look-ahead polynomial constant only if we didn't pass more signals than the look-ahead limit is */
int look_ahead_cost = (n.m_num_signals_passed < m_sig_look_ahead_costs.Size()) ? m_sig_look_ahead_costs.Data()[n.m_num_signals_passed] : 0;
if (sig_state != SIGNAL_STATE_RED) {
/* green signal */
n.flags_u.flags_s.m_last_signal_was_red = false;
/* negative look-ahead red-signal penalties would cause problems later, so use them as positive penalties for green signal */
if (look_ahead_cost < 0) {
/* add its negation to the cost */
cost -= look_ahead_cost;
}
} else {
/* we have a red signal in our direction
* was it first signal which is two-way? */
if (!IsPbsSignal(sig_type) && Yapf().TreatFirstRedTwoWaySignalAsEOL() && n.flags_u.flags_s.m_choice_seen && has_signal_against && n.m_num_signals_passed == 0) {
/* yes, the first signal is two-way red signal => DEAD END. Prune this branch... */
Yapf().PruneIntermediateNodeBranch();
n.m_segment->m_end_segment_reason |= ESRB_DEAD_END;
Yapf().m_stopped_on_first_two_way_signal = true;
return -1;
}
n.m_last_red_signal_type = sig_type;
n.flags_u.flags_s.m_last_signal_was_red = true;
/* look-ahead signal penalty */
if (!IsPbsSignal(sig_type) && look_ahead_cost > 0) {
/* add the look ahead penalty only if it is positive */
cost += look_ahead_cost;
}
/* special signal penalties */
if (n.m_num_signals_passed == 0) {
switch (sig_type) {
case SIGTYPE_COMBO:
case SIGTYPE_EXIT: cost += Yapf().PfGetSettings().rail_firstred_exit_penalty; break; // first signal is red pre-signal-exit
case SIGTYPE_NORMAL:
case SIGTYPE_ENTRY: cost += Yapf().PfGetSettings().rail_firstred_penalty; break;
default: break;
}
}
}
n.m_num_signals_passed++;
n.m_segment->m_last_signal_tile = tile;
n.m_segment->m_last_signal_td = trackdir;
}
if (has_signal_against && IsPbsSignal(GetSignalType(tile, TrackdirToTrack(trackdir)))) {
cost += n.m_num_signals_passed < Yapf().PfGetSettings().rail_look_ahead_max_signals ? Yapf().PfGetSettings().rail_pbs_signal_back_penalty : 0;
}
}
}
return cost;
}
