OpenTTD
yapf_destrail.hpp
Go to the documentation of this file.
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 
10 #ifndef YAPF_DESTRAIL_HPP
11 #define YAPF_DESTRAIL_HPP
12 
14 protected:
15  RailTypes m_compatible_railtypes;
16 
17 public:
18  void SetDestination(const Train *v, bool override_rail_type = false)
19  {
20  m_compatible_railtypes = v->compatible_railtypes;
21  if (override_rail_type) m_compatible_railtypes |= GetRailTypeInfo(v->railtype)->compatible_railtypes;
22  }
23 
24  bool IsCompatibleRailType(RailType rt)
25  {
26  return HasBit(m_compatible_railtypes, rt);
27  }
28 
29  RailTypes GetCompatibleRailTypes() const
30  {
31  return m_compatible_railtypes;
32  }
33 };
34 
35 template <class Types>
37 public:
38  typedef typename Types::Tpf Tpf;
39  typedef typename Types::NodeList::Titem Node;
40  typedef typename Node::Key Key;
41 
43  Tpf& Yapf()
44  {
45  return *static_cast<Tpf *>(this);
46  }
47 
49  inline bool PfDetectDestination(Node &n)
50  {
51  return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
52  }
53 
55  inline bool PfDetectDestination(TileIndex tile, Trackdir td)
56  {
57  bool bDest = IsRailDepotTile(tile);
58  return bDest;
59  }
60 
65  inline bool PfCalcEstimate(Node &n)
66  {
67  n.m_estimate = n.m_cost;
68  return true;
69  }
70 };
71 
72 template <class Types>
74 public:
75  typedef typename Types::Tpf Tpf;
76  typedef typename Types::NodeList::Titem Node;
77  typedef typename Node::Key Key;
78  typedef typename Types::TrackFollower TrackFollower;
79 
81  Tpf& Yapf()
82  {
83  return *static_cast<Tpf *>(this);
84  }
85 
87  inline bool PfDetectDestination(Node &n)
88  {
89  return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
90  }
91 
93  inline bool PfDetectDestination(TileIndex tile, Trackdir td)
94  {
95  return IsSafeWaitingPosition(Yapf().GetVehicle(), tile, td, true, !TrackFollower::Allow90degTurns()) &&
96  IsWaitingPositionFree(Yapf().GetVehicle(), tile, td, !TrackFollower::Allow90degTurns());
97  }
98 
103  inline bool PfCalcEstimate(Node &n)
104  {
105  n.m_estimate = n.m_cost;
106  return true;
107  }
108 };
109 
110 template <class Types>
112 public:
113  typedef typename Types::Tpf Tpf;
114  typedef typename Types::NodeList::Titem Node;
115  typedef typename Node::Key Key;
116 
117 protected:
118  TileIndex m_destTile;
119  TrackdirBits m_destTrackdirs;
120  StationID m_dest_station_id;
121 
123  Tpf& Yapf()
124  {
125  return *static_cast<Tpf *>(this);
126  }
127 
128 public:
129  void SetDestination(const Train *v)
130  {
131  switch (v->current_order.GetType()) {
132  case OT_GOTO_WAYPOINT:
133  if (!Waypoint::Get(v->current_order.GetDestination())->IsSingleTile()) {
134  /* In case of 'complex' waypoints we need to do a look
135  * ahead. This look ahead messes a bit about, which
136  * means that it 'corrupts' the cache. To prevent this
137  * we disable caching when we're looking for a complex
138  * waypoint. */
139  Yapf().DisableCache(true);
140  }
141  FALLTHROUGH;
142 
143  case OT_GOTO_STATION:
144  m_destTile = CalcClosestStationTile(v->current_order.GetDestination(), v->tile, v->current_order.IsType(OT_GOTO_STATION) ? STATION_RAIL : STATION_WAYPOINT);
145  m_dest_station_id = v->current_order.GetDestination();
146  m_destTrackdirs = INVALID_TRACKDIR_BIT;
147  break;
148 
149  default:
150  m_destTile = v->dest_tile;
151  m_dest_station_id = INVALID_STATION;
153  break;
154  }
155  CYapfDestinationRailBase::SetDestination(v);
156  }
157 
159  inline bool PfDetectDestination(Node &n)
160  {
161  return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
162  }
163 
165  inline bool PfDetectDestination(TileIndex tile, Trackdir td)
166  {
167  if (m_dest_station_id != INVALID_STATION) {
168  return HasStationTileRail(tile)
169  && (GetStationIndex(tile) == m_dest_station_id)
170  && (GetRailStationTrack(tile) == TrackdirToTrack(td));
171  }
172 
173  return (tile == m_destTile) && HasTrackdir(m_destTrackdirs, td);
174  }
175 
180  inline bool PfCalcEstimate(Node &n)
181  {
182  static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
183  static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};
184  if (PfDetectDestination(n)) {
185  n.m_estimate = n.m_cost;
186  return true;
187  }
188 
189  TileIndex tile = n.GetLastTile();
190  DiagDirection exitdir = TrackdirToExitdir(n.GetLastTrackdir());
191  int x1 = 2 * TileX(tile) + dg_dir_to_x_offs[(int)exitdir];
192  int y1 = 2 * TileY(tile) + dg_dir_to_y_offs[(int)exitdir];
193  int x2 = 2 * TileX(m_destTile);
194  int y2 = 2 * TileY(m_destTile);
195  int dx = abs(x1 - x2);
196  int dy = abs(y1 - y2);
197  int dmin = min(dx, dy);
198  int dxy = abs(dx - dy);
199  int d = dmin * YAPF_TILE_CORNER_LENGTH + (dxy - 1) * (YAPF_TILE_LENGTH / 2);
200  n.m_estimate = n.m_cost + d;
201  assert(n.m_estimate >= n.m_parent->m_estimate);
202  return true;
203  }
204 };
205 
206 #endif /* YAPF_DESTRAIL_HPP */
bool PfDetectDestination(Node &n)
Called by YAPF to detect if node ends in the desired destination.
static const RailtypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Definition: rail.h:304
TrackdirBits
Enumeration of bitmasks for the TrackDirs.
Definition: track_type.h:101
Types::NodeList::Titem Node
this will be our node type
bool PfDetectDestination(TileIndex tile, Trackdir td)
Called by YAPF to detect if node ends in the desired destination.
static Track TrackdirToTrack(Trackdir trackdir)
Returns the Track that a given Trackdir represents.
Definition: track_func.h:270
Trackdir
Enumeration for tracks and directions.
Definition: track_type.h:70
bool PfDetectDestination(TileIndex tile, Trackdir td)
Called by YAPF to detect if node ends in the desired destination.
Node::Key Key
key to hash tables
TileIndex dest_tile
Heading for this tile.
Definition: vehicle_base.h:235
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
Tpf & Yapf()
to access inherited path finder
static Track GetRailStationTrack(TileIndex t)
Get the rail track of a rail station tile.
Definition: station_map.h:349
RailTypes compatible_railtypes
bitmask to the OTHER railtypes on which an engine of THIS railtype can physically travel ...
Definition: rail.h:188
static DiagDirection TrackdirToExitdir(Trackdir trackdir)
Maps a trackdir to the (4-way) direction the tile is exited when following that trackdir.
Definition: track_func.h:447
bool PfDetectDestination(Node &n)
Called by YAPF to detect if node ends in the desired destination.
Node::Key Key
key to hash tables
Types::Tpf Tpf
the pathfinder class (derived from THIS class)
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:61
static bool HasTrackdir(TrackdirBits trackdirs, Trackdir trackdir)
Checks whether a TrackdirBits has a given Trackdir.
Definition: track_func.h:348
bool IsSafeWaitingPosition(const Train *v, TileIndex tile, Trackdir trackdir, bool include_line_end, bool forbid_90deg)
Determine whether a certain track on a tile is a safe position to end a path.
Definition: pbs.cpp:381
static bool HasStationTileRail(TileIndex t)
Has this station tile a rail? In other words, is this station tile a rail station or rail waypoint...
Definition: station_map.h:146
Types::Tpf Tpf
the pathfinder class (derived from THIS class)
bool IsWaitingPositionFree(const Train *v, TileIndex tile, Trackdir trackdir, bool forbid_90deg)
Check if a safe position is free.
Definition: pbs.cpp:427
bool PfCalcEstimate(Node &n)
Called by YAPF to calculate cost estimate.
static const int YAPF_TILE_LENGTH
Length (penalty) of one tile with YAPF.
bool PfCalcEstimate(Node &n)
Called by YAPF to calculate cost estimate.
TileIndex tile
Current tile index.
Definition: vehicle_base.h:228
bool PfDetectDestination(TileIndex tile, Trackdir td)
Called by YAPF to detect if node ends in the desired destination.
Tpf & Yapf()
to access inherited path finder
static T min(const T a, const T b)
Returns the minimum of two values.
Definition: math_func.hpp:40
RailTypes
The different railtypes we support, but then a bitmask of them.
Definition: rail_type.h:46
Tpf & Yapf()
to access inherited path finder
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.
Definition: landscape.cpp:589
&#39;Train&#39; is either a loco or a wagon.
Definition: train.h:85
Transport by train.
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:28
Types::NodeList::Titem Node
this will be our node type
RailType
Enumeration for all possible railtypes.
Definition: rail_type.h:27
bool PfCalcEstimate(Node &n)
Called by YAPF to calculate cost estimate.
DestinationID GetDestination() const
Gets the destination of this order.
Definition: order_base.h:94
static bool IsRailDepotTile(TileIndex t)
Is this tile rail tile and a rail depot?
Definition: rail_map.h:105
Types::NodeList::Titem Node
this will be our node type
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
Types::Tpf Tpf
the pathfinder class (derived from THIS class)
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
static T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition: math_func.hpp:81
bool PfDetectDestination(Node &n)
Called by YAPF to detect if node ends in the desired destination.
Types::TrackFollower TrackFollower
TrackFollower. Need to typedef for gcc 2.95.
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
DiagDirection
Enumeration for diagonal directions.
OrderType GetType() const
Get the type of order of this order.
Definition: order_base.h:67
static const int YAPF_TILE_CORNER_LENGTH
Length (penalty) of a corner with YAPF.
static Waypoint * Get(size_t index)
Gets station with given index.
Flag for an invalid trackdirbit value.
Definition: track_type.h:117
static TrackdirBits TrackStatusToTrackdirBits(TrackStatus ts)
Returns the present-trackdir-information of a TrackStatus.
Definition: track_func.h:360
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:316
Node::Key Key
key to hash tables