src/pathfinder/railpos.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file pathfinder/railpos.h Railway path position type. */
   9
  10 #ifndef PATHFINDER_RAILPOS_H
  11 #define PATHFINDER_RAILPOS_H
  12
  13 #include "pos.h"
  14 #include "../rail_type.h"
  15 #include "../track_func.h"
  16 #include "../map/rail.h"
  17
  18 struct RailPathPos : PathPos<PathVTile> {
  19         typedef PathPos<PathVTile> Base;
  20
  21         /** Create an empty RailPathPos */
  22         RailPathPos() : Base() { }
  23
  24         /** Create a PathPos for a given tile and trackdir */
  25         RailPathPos (TileIndex t, Trackdir d) : Base (t, d) { }
  26
  27         /** Create a PathPos in a wormhole */
  28         RailPathPos (TileIndex t, Trackdir d, TileIndex w) : Base (t, d, w) { }
  29
  30         /** Get the rail type for this position. */
  31         RailType get_railtype() const
  32         {
  33                 assert (is_valid());
  34                 return !in_wormhole() ? GetRailType (tile, TrackdirToTrack(td)) :
  35                         IsRailwayTile(wormhole) ? GetBridgeRailType(wormhole) : GetRailType(wormhole);
  36         }
  37
  38         /** Check if there are signals at a position */
  39         bool has_signals() const
  40         {
  41                 if (in_wormhole()) {
  42                         return false;
  43                 } else if (IsRailwayTile(tile)) {
  44                         return HasSignalOnTrack (tile, TrackdirToTrack(td));
  45                 } else if (maptile_is_rail_tunnel(tile)) {
  46                         return maptile_has_tunnel_signals (tile);
  47                 } else {
  48                         return false;
  49                 }
  50         }
  51
  52         /** Get the type of signals at a position */
  53         SignalType get_signal_type() const
  54         {
  55                 assert(has_signals());
  56                 return IsRailwayTile(tile) ?
  57                         GetSignalType (tile, TrackdirToTrack(td)) :
  58                         maptile_get_tunnel_signal_type(tile);
  59         }
  60
  61         /** Check if there is a signal along/against a position */
  62         bool has_signal_along (bool along = true) const
  63         {
  64                 if (in_wormhole()) {
  65                         return false;
  66                 } else if (IsRailwayTile(tile)) {
  67                         return HasSignalOnTrackdir (tile, along ? td : ReverseTrackdir(td));
  68                 } else if (maptile_is_rail_tunnel(tile)) {
  69                         bool inwards = TrackdirToExitdir(td) == GetTunnelBridgeDirection(tile);
  70                         return maptile_has_tunnel_signal (tile, along == inwards);
  71                 } else {
  72                         return false;
  73                 }
  74         }
  75
  76         /** Check if there is a signal against a position */
  77         bool has_signal_against() const { return has_signal_along(false); }
  78
  79         /** Check if there is a one-way signal against a position */
  80         bool has_blocking_signal() const
  81         {
  82                 if (in_wormhole()) {
  83                         return false;
  84                 } else if (IsRailwayTile (tile)) {
  85                         return HasSignalOnTrackdir (tile, ReverseTrackdir (td)) &&
  86                                 !HasSignalOnTrackdir (tile, td) && IsOnewaySignal (GetSignalType (tile, TrackdirToTrack (td)));
  87                 } else if (maptile_is_rail_tunnel (tile)) {
  88                         return maptile_has_tunnel_signal (tile, TrackdirToExitdir (td) != GetTunnelBridgeDirection (tile));
  89                 } else {
  90                         return false;
  91                 }
  92         }
  93
  94         /** Get the state of the signal along a position */
  95         SignalState get_signal_state() const
  96         {
  97                 assert(has_signal_along());
  98                 return IsRailwayTile(tile) ?
  99                         GetSignalStateByTrackdir (tile, td) :
 100                         maptile_get_tunnel_signal_state (tile, TrackdirToExitdir(td) == GetTunnelBridgeDirection(tile));
 101         }
 102
 103         /** Set the state of the signal along a position */
 104         void set_signal_state (SignalState state) const
 105         {
 106                 assert (has_signal_along());
 107                 if (IsRailwayTile (tile)) {
 108                         SetSignalStateByTrackdir (tile, td, state);
 109                 } else {
 110                         maptile_set_tunnel_signal_state (tile, TrackdirToExitdir (td) == GetTunnelBridgeDirection (tile), state);
 111                 }
 112         }
 113 };
 114
 115 #endif /* PATHFINDER_RAILPOS_H */