pbs.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "stdafx.h"
#include "viewport_func.h"
#include "vehicle_func.h"
#include "newgrf_station.h"
#include "pathfinder/follow_track.hpp"
 
#include "safeguards.h"
 
TrackBits GetReservedTrackbits(TileIndex t)
{
  switch (GetTileType(t)) {
    case MP_RAILWAY:
      if (IsRailDepot(t)) return GetDepotReservationTrackBits(t);
      if (IsPlainRail(t)) return GetRailReservationTrackBits(t);
      break;
 
    case MP_ROAD:
      if (IsLevelCrossing(t)) return GetCrossingReservationTrackBits(t);
      break;
 
    case MP_STATION:
      if (HasStationRail(t)) return GetStationReservationTrackBits(t);
      break;
 
    case MP_TUNNELBRIDGE:
      if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) return GetTunnelBridgeReservationTrackBits(t);
      break;
 
    default:
      break;
  }
  return TRACK_BIT_NONE;
}
TrackBits GetReservedTrackbits(TileIndex t) {…}
 
void SetRailStationPlatformReservation(TileIndex start, DiagDirection dir, bool b)
{
  TileIndex     tile = start;
  TileIndexDiff diff = TileOffsByDiagDir(dir);
 
  assert(IsRailStationTile(start));
  assert(GetRailStationAxis(start) == DiagDirToAxis(dir));
 
  do {
    SetRailStationReservation(tile, b);
    MarkTileDirtyByTile(tile);
    tile = TileAdd(tile, diff);
  } while (IsCompatibleTrainStationTile(tile, start));
}
void SetRailStationPlatformReservation(TileIndex start, DiagDirection dir, bool b) {…}
 
bool TryReserveRailTrack(TileIndex tile, Track t, bool trigger_stations)
{
  assert(HasTrack(TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)), t));
 
  if (_settings_client.gui.show_track_reservation) {
    /* show the reserved rail if needed */
    if (IsBridgeTile(tile)) {
      MarkBridgeDirty(tile);
    } else {
      MarkTileDirtyByTile(tile);
    }
  }
 
  switch (GetTileType(tile)) {
    case MP_RAILWAY:
      if (IsPlainRail(tile)) return TryReserveTrack(tile, t);
      if (IsRailDepot(tile)) {
        if (!HasDepotReservation(tile)) {
          SetDepotReservation(tile, true);
          MarkTileDirtyByTile(tile); // some GRFs change their appearance when tile is reserved
          return true;
        }
      }
      break;
 
    case MP_ROAD:
      if (IsLevelCrossing(tile) && !HasCrossingReservation(tile)) {
        SetCrossingReservation(tile, true);
        UpdateLevelCrossing(tile, false);
        return true;
      }
      break;
 
    case MP_STATION:
      if (HasStationRail(tile) && !HasStationReservation(tile)) {
        SetRailStationReservation(tile, true);
        if (trigger_stations) {
          auto *st = BaseStation::GetByTile(tile);
          TriggerStationRandomisation(st, tile, StationRandomTrigger::PathReservation);
          TriggerStationAnimation(st, tile, StationAnimationTrigger::PathReservation);
        }
        MarkTileDirtyByTile(tile); // some GRFs need redraw after reserving track
        return true;
      }
      break;
 
    case MP_TUNNELBRIDGE:
      if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL && !GetTunnelBridgeReservationTrackBits(tile)) {
        SetTunnelBridgeReservation(tile, true);
        return true;
      }
      break;
 
    default:
      break;
  }
  return false;
}
bool TryReserveRailTrack(TileIndex tile, Track t, bool trigger_stations) {…}
 
void UnreserveRailTrack(TileIndex tile, Track t)
{
  assert(HasTrack(TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)), t));
 
  if (_settings_client.gui.show_track_reservation) {
    if (IsBridgeTile(tile)) {
      MarkBridgeDirty(tile);
    } else {
      MarkTileDirtyByTile(tile);
    }
  }
 
  switch (GetTileType(tile)) {
    case MP_RAILWAY:
      if (IsRailDepot(tile)) {
        SetDepotReservation(tile, false);
        MarkTileDirtyByTile(tile);
        break;
      }
      if (IsPlainRail(tile)) UnreserveTrack(tile, t);
      break;
 
    case MP_ROAD:
      if (IsLevelCrossing(tile)) {
        SetCrossingReservation(tile, false);
        UpdateLevelCrossing(tile);
      }
      break;
 
    case MP_STATION:
      if (HasStationRail(tile)) {
        SetRailStationReservation(tile, false);
        MarkTileDirtyByTile(tile);
      }
      break;
 
    case MP_TUNNELBRIDGE:
      if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL) SetTunnelBridgeReservation(tile, false);
      break;
 
    default:
      break;
  }
}
void UnreserveRailTrack(TileIndex tile, Track t) {…}
 
 
static PBSTileInfo FollowReservation(Owner o, RailTypes rts, TileIndex tile, Trackdir trackdir, bool ignore_oneway = false)
{
  TileIndex start_tile = tile;
  Trackdir  start_trackdir = trackdir;
  bool      first_loop = true;
 
  /* Start track not reserved? This can happen if two trains
   * are on the same tile. The reservation on the next tile
   * is not ours in this case, so exit. */
  if (!HasReservedTracks(tile, TrackToTrackBits(TrackdirToTrack(trackdir)))) return PBSTileInfo(tile, trackdir, false);
 
  /* Do not disallow 90 deg turns as the setting might have changed between reserving and now. */
  CFollowTrackRail ft(o, rts);
  while (ft.Follow(tile, trackdir)) {
    TrackdirBits reserved = ft.new_td_bits & TrackBitsToTrackdirBits(GetReservedTrackbits(ft.new_tile));
 
    /* No reservation --> path end found */
    if (reserved == TRACKDIR_BIT_NONE) {
      if (ft.is_station) {
        /* Check skipped station tiles as well, maybe our reservation ends inside the station. */
        TileIndexDiff diff = TileOffsByDiagDir(ft.exitdir);
        while (ft.tiles_skipped-- > 0) {
          ft.new_tile -= diff;
          if (HasStationReservation(ft.new_tile)) {
            tile = ft.new_tile;
            trackdir = DiagDirToDiagTrackdir(ft.exitdir);
            break;
          }
        }
      }
      break;
    }
 
    /* Can't have more than one reserved trackdir */
    Trackdir new_trackdir = FindFirstTrackdir(reserved);
 
    /* One-way signal against us. The reservation can't be ours as it is not
     * a safe position from our direction and we can never pass the signal. */
    if (!ignore_oneway && HasOnewaySignalBlockingTrackdir(ft.new_tile, new_trackdir)) break;
 
    tile = ft.new_tile;
    trackdir = new_trackdir;
 
    if (first_loop) {
      /* Update the start tile after we followed the track the first
       * time. This is necessary because the track follower can skip
       * tiles (in stations for example) which means that we might
       * never visit our original starting tile again. */
      start_tile = tile;
      start_trackdir = trackdir;
      first_loop = false;
    } else {
      /* Loop encountered? */
      if (tile == start_tile && trackdir == start_trackdir) break;
    }
    /* Depot tile? Can't continue. */
    if (IsRailDepotTile(tile)) break;
    /* Non-pbs signal? Reservation can't continue. */
    if (IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, trackdir) && !IsPbsSignal(GetSignalType(tile, TrackdirToTrack(trackdir)))) break;
  }
 
  return PBSTileInfo(tile, trackdir, false);
}
static PBSTileInfo FollowReservation(Owner o, RailTypes rts, TileIndex tile, Trackdir trackdir, bool ignore_oneway = false) {…}
 
struct FindTrainOnTrackInfo {
  PBSTileInfo res; 
  Train *best;     
 
  FindTrainOnTrackInfo() : best(nullptr) {}
};
struct FindTrainOnTrackInfo {…};
 
static void CheckTrainsOnTrack(FindTrainOnTrackInfo &info, TileIndex tile)
{
  for (Vehicle *v : VehiclesOnTile(tile)) {
    if (v->type != VEH_TRAIN || v->vehstatus.Test(VehState::Crashed)) continue;
 
    Train *t = Train::From(v);
    if (t->track == TRACK_BIT_WORMHOLE || HasBit(static_cast<TrackBits>(t->track), TrackdirToTrack(info.res.trackdir))) {
      t = t->First();
 
      /* ALWAYS return the lowest ID (anti-desync!) */
      if (info.best == nullptr || t->index < info.best->index) info.best = t;
    }
  }
}
static void CheckTrainsOnTrack(FindTrainOnTrackInfo &info, TileIndex tile) {…}
 
PBSTileInfo FollowTrainReservation(const Train *v, Vehicle **train_on_res)
{
  assert(v->type == VEH_TRAIN);
 
  TileIndex tile = v->tile;
  Trackdir  trackdir = v->GetVehicleTrackdir();
 
  if (IsRailDepotTile(tile) && !GetDepotReservationTrackBits(tile)) return PBSTileInfo(tile, trackdir, false);
 
  FindTrainOnTrackInfo ftoti;
  ftoti.res = FollowReservation(v->owner, GetRailTypeInfo(v->railtype)->compatible_railtypes, tile, trackdir);
  ftoti.res.okay = IsSafeWaitingPosition(v, ftoti.res.tile, ftoti.res.trackdir, true, _settings_game.pf.forbid_90_deg);
  if (train_on_res != nullptr) {
    CheckTrainsOnTrack(ftoti, ftoti.res.tile);
    if (ftoti.best != nullptr) *train_on_res = ftoti.best->First();
    if (*train_on_res == nullptr && IsRailStationTile(ftoti.res.tile)) {
      /* The target tile is a rail station. The track follower
       * has stopped on the last platform tile where we haven't
       * found a train. Also check all previous platform tiles
       * for a possible train. */
      TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(ftoti.res.trackdir)));
      for (TileIndex st_tile = ftoti.res.tile + diff; *train_on_res == nullptr && IsCompatibleTrainStationTile(st_tile, ftoti.res.tile); st_tile += diff) {
        CheckTrainsOnTrack(ftoti, st_tile);
        if (ftoti.best != nullptr) *train_on_res = ftoti.best->First();
      }
    }
    if (*train_on_res == nullptr && IsTileType(ftoti.res.tile, MP_TUNNELBRIDGE)) {
      /* The target tile is a bridge/tunnel, also check the other end tile. */
      CheckTrainsOnTrack(ftoti, GetOtherTunnelBridgeEnd(ftoti.res.tile));
      if (ftoti.best != nullptr) *train_on_res = ftoti.best->First();
    }
  }
  return ftoti.res;
}
PBSTileInfo FollowTrainReservation(const Train *v, Vehicle **train_on_res) {…}
 
Train *GetTrainForReservation(TileIndex tile, Track track)
{
  assert(HasReservedTracks(tile, TrackToTrackBits(track)));
  Trackdir  trackdir = TrackToTrackdir(track);
 
  RailTypes rts = GetRailTypeInfo(GetTileRailType(tile))->compatible_railtypes;
 
  /* Follow the path from tile to both ends, one of the end tiles should
   * have a train on it. We need FollowReservation to ignore one-way signals
   * here, as one of the two search directions will be the "wrong" way. */
  for (int i = 0; i < 2; ++i, trackdir = ReverseTrackdir(trackdir)) {
    /* If the tile has a one-way block signal in the current trackdir, skip the
     * search in this direction as the reservation can't come from this side.*/
    if (HasOnewaySignalBlockingTrackdir(tile, ReverseTrackdir(trackdir)) && !HasPbsSignalOnTrackdir(tile, trackdir)) continue;
 
    FindTrainOnTrackInfo ftoti;
    ftoti.res = FollowReservation(GetTileOwner(tile), rts, tile, trackdir, true);
 
    CheckTrainsOnTrack(ftoti, ftoti.res.tile);
    if (ftoti.best != nullptr) return ftoti.best;
 
    /* Special case for stations: check the whole platform for a vehicle. */
    if (IsRailStationTile(ftoti.res.tile)) {
      TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(ftoti.res.trackdir)));
      for (TileIndex st_tile = ftoti.res.tile + diff; IsCompatibleTrainStationTile(st_tile, ftoti.res.tile); st_tile += diff) {
        CheckTrainsOnTrack(ftoti, st_tile);
        if (ftoti.best != nullptr) return ftoti.best;
      }
    }
 
    /* Special case for bridges/tunnels: check the other end as well. */
    if (IsTileType(ftoti.res.tile, MP_TUNNELBRIDGE)) {
      CheckTrainsOnTrack(ftoti, GetOtherTunnelBridgeEnd(ftoti.res.tile));
      if (ftoti.best != nullptr) return ftoti.best;
    }
  }
 
  return nullptr;
}
Train *GetTrainForReservation(TileIndex tile, Track track) {…}
 
bool IsSafeWaitingPosition(const Train *v, TileIndex tile, Trackdir trackdir, bool include_line_end, bool forbid_90deg)
{
  if (IsRailDepotTile(tile)) return true;
 
  if (IsTileType(tile, MP_RAILWAY)) {
    /* For non-pbs signals, stop on the signal tile. */
    if (HasSignalOnTrackdir(tile, trackdir) && !IsPbsSignal(GetSignalType(tile, TrackdirToTrack(trackdir)))) return true;
  }
 
  /* Check next tile. For performance reasons, we check for 90 degree turns ourself. */
  CFollowTrackRail ft(v, GetRailTypeInfo(v->railtype)->compatible_railtypes);
 
  /* End of track? */
  if (!ft.Follow(tile, trackdir)) {
    /* Last tile of a terminus station is a safe position. */
    if (include_line_end) return true;
  }
 
  /* Check for reachable tracks. */
  ft.new_td_bits &= DiagdirReachesTrackdirs(ft.exitdir);
  if (Rail90DegTurnDisallowed(GetTileRailType(ft.old_tile), GetTileRailType(ft.new_tile), forbid_90deg)) ft.new_td_bits &= ~TrackdirCrossesTrackdirs(trackdir);
  if (ft.new_td_bits == TRACKDIR_BIT_NONE) return include_line_end;
 
  if (ft.new_td_bits != TRACKDIR_BIT_NONE && KillFirstBit(ft.new_td_bits) == TRACKDIR_BIT_NONE) {
    Trackdir td = FindFirstTrackdir(ft.new_td_bits);
    /* PBS signal on next trackdir? Safe position. */
    if (HasPbsSignalOnTrackdir(ft.new_tile, td)) return true;
    /* One-way PBS signal against us? Safe if end-of-line is allowed. */
    if (IsTileType(ft.new_tile, MP_RAILWAY) && HasSignalOnTrackdir(ft.new_tile, ReverseTrackdir(td)) &&
        GetSignalType(ft.new_tile, TrackdirToTrack(td)) == SIGTYPE_PBS_ONEWAY) {
      return include_line_end;
    }
  }
 
  return false;
}
bool IsSafeWaitingPosition(const Train *v, TileIndex tile, Trackdir trackdir, bool include_line_end, bool forbid_90deg) {…}
 
bool IsWaitingPositionFree(const Train *v, TileIndex tile, Trackdir trackdir, bool forbid_90deg)
{
  Track     track = TrackdirToTrack(trackdir);
  TrackBits reserved = GetReservedTrackbits(tile);
 
  /* Tile reserved? Can never be a free waiting position. */
  if (TrackOverlapsTracks(reserved, track)) return false;
 
  /* Not reserved and depot or not a pbs signal -> free. */
  if (IsRailDepotTile(tile)) return true;
  if (IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, trackdir) && !IsPbsSignal(GetSignalType(tile, track))) return true;
 
  /* Check the next tile, if it's a PBS signal, it has to be free as well. */
  CFollowTrackRail ft(v, GetRailTypeInfo(v->railtype)->compatible_railtypes);
 
  if (!ft.Follow(tile, trackdir)) return true;
 
  /* Check for reachable tracks. */
  ft.new_td_bits &= DiagdirReachesTrackdirs(ft.exitdir);
  if (Rail90DegTurnDisallowed(GetTileRailType(ft.old_tile), GetTileRailType(ft.new_tile), forbid_90deg)) ft.new_td_bits &= ~TrackdirCrossesTrackdirs(trackdir);
 
  return !HasReservedTracks(ft.new_tile, TrackdirBitsToTrackBits(ft.new_td_bits));
}
bool IsWaitingPositionFree(const Train *v, TileIndex tile, Trackdir trackdir, bool forbid_90deg) {…}