OpenTTD Source: src/pathfinder/yapf/yapf_destrail.hpp Source File

OpenTTD Source 1.11.0-RC1

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
13 class CYapfDestinationRailBase {
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>
36 class CYapfDestinationAnyDepotRailT : public CYapfDestinationRailBase {
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>
73 class CYapfDestinationAnySafeTileRailT : public CYapfDestinationRailBase {
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>
111 class CYapfDestinationTileOrStationRailT : public CYapfDestinationRailBase {
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;
152 m_destTrackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(v->dest_tile, TRANSPORT_RAIL, 0));
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 = std::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 */
CYapfDestinationAnySafeTileRailT::Yapf
Tpf & Yapf()
to access inherited path finder
Definition: yapf_destrail.hpp:81
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
CYapfDestinationTileOrStationRailT::PfCalcEstimate
bool PfCalcEstimate(Node &n)
Called by YAPF to calculate cost estimate.
Definition: yapf_destrail.hpp:180
CYapfDestinationTileOrStationRailT
Definition: yapf_destrail.hpp:111
Order::IsType
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:61
TrackdirBits
TrackdirBits
Enumeration of bitmasks for the TrackDirs.
Definition: track_type.h:101
TRANSPORT_RAIL
@ TRANSPORT_RAIL
Transport by train.
Definition: transport_type.h:27
Order::GetDestination
DestinationID GetDestination() const
Gets the destination of this order.
Definition: order_base.h:94
GetRailStationTrack
static Track GetRailStationTrack(TileIndex t)
Get the rail track of a rail station tile.
Definition: station_map.h:349
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
CYapfDestinationTileOrStationRailT::Node
Types::NodeList::Titem Node
this will be our node type
Definition: yapf_destrail.hpp:114
SpecializedStation< Waypoint, true >::Get
static Waypoint * Get(size_t index)
Gets station with given index.
Definition: base_station_base.h:219
TileY
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
CYapfDestinationAnySafeTileRailT::Key
Node::Key Key
key to hash tables
Definition: yapf_destrail.hpp:77
CYapfDestinationTileOrStationRailT::Tpf
Types::Tpf Tpf
the pathfinder class (derived from THIS class)
Definition: yapf_destrail.hpp:113
INVALID_TRACKDIR_BIT
@ INVALID_TRACKDIR_BIT
Flag for an invalid trackdirbit value.
Definition: track_type.h:117
TileX
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
GetTileTrackStatus
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:589
CYapfDestinationAnyDepotRailT::Key
Node::Key Key
key to hash tables
Definition: yapf_destrail.hpp:40
Order::GetType
OrderType GetType() const
Get the type of order of this order.
Definition: order_base.h:67
GetRailTypeInfo
static const RailtypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Definition: rail.h:304
Vehicle::dest_tile
TileIndex dest_tile
Heading for this tile.
Definition: vehicle_base.h:247
IsWaitingPositionFree
bool IsWaitingPositionFree(const Train *v, TileIndex tile, Trackdir trackdir, bool forbid_90deg)
Check if a safe position is free.
Definition: pbs.cpp:427
RailType
RailType
Enumeration for all possible railtypes.
Definition: rail_type.h:27
Waypoint::IsSingleTile
bool IsSingleTile() const
Is this a single tile waypoint?
Definition: waypoint_base.h:53
CYapfDestinationAnyDepotRailT::PfDetectDestination
bool PfDetectDestination(TileIndex tile, Trackdir td)
Called by YAPF to detect if node ends in the desired destination.
Definition: yapf_destrail.hpp:55
YAPF_TILE_LENGTH
static const int YAPF_TILE_LENGTH
Length (penalty) of one tile with YAPF.
Definition: pathfinder_type.h:28
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:240
TrackdirToExitdir
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
Vehicle::current_order
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:327
CYapfDestinationAnyDepotRailT::Yapf
Tpf & Yapf()
to access inherited path finder
Definition: yapf_destrail.hpp:43
CYapfDestinationRailBase
Definition: yapf_destrail.hpp:13
HasStationTileRail
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
IsRailDepotTile
static bool IsRailDepotTile(TileIndex t)
Is this tile rail tile and a rail depot?
Definition: rail_map.h:105
Train
'Train' is either a loco or a wagon.
Definition: train.h:85
CYapfDestinationAnyDepotRailT::Tpf
Types::Tpf Tpf
the pathfinder class (derived from THIS class)
Definition: yapf_destrail.hpp:38
IsSafeWaitingPosition
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
CYapfDestinationAnyDepotRailT::PfCalcEstimate
bool PfCalcEstimate(Node &n)
Called by YAPF to calculate cost estimate.
Definition: yapf_destrail.hpp:65
CYapfDestinationTileOrStationRailT::Key
Node::Key Key
key to hash tables
Definition: yapf_destrail.hpp:115
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition: direction_type.h:77
CYapfDestinationAnySafeTileRailT::PfDetectDestination
bool PfDetectDestination(Node &n)
Called by YAPF to detect if node ends in the desired destination.
Definition: yapf_destrail.hpp:87
CYapfDestinationAnySafeTileRailT::Node
Types::NodeList::Titem Node
this will be our node type
Definition: yapf_destrail.hpp:76
CYapfDestinationTileOrStationRailT::PfDetectDestination
bool PfDetectDestination(TileIndex tile, Trackdir td)
Called by YAPF to detect if node ends in the desired destination.
Definition: yapf_destrail.hpp:165
CalcClosestStationTile
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...
Definition: pathfinder_func.h:25
CYapfDestinationAnyDepotRailT
Definition: yapf_destrail.hpp:36
CYapfDestinationAnyDepotRailT::Node
Types::NodeList::Titem Node
this will be our node type
Definition: yapf_destrail.hpp:39
CYapfDestinationTileOrStationRailT::Yapf
Tpf & Yapf()
to access inherited path finder
Definition: yapf_destrail.hpp:123
CYapfDestinationAnySafeTileRailT::PfDetectDestination
bool PfDetectDestination(TileIndex tile, Trackdir td)
Called by YAPF to detect if node ends in the desired destination.
Definition: yapf_destrail.hpp:93
GetStationIndex
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:28
CYapfDestinationTileOrStationRailT::PfDetectDestination
bool PfDetectDestination(Node &n)
Called by YAPF to detect if node ends in the desired destination.
Definition: yapf_destrail.hpp:159
TrackStatusToTrackdirBits
static TrackdirBits TrackStatusToTrackdirBits(TrackStatus ts)
Returns the present-trackdir-information of a TrackStatus.
Definition: track_func.h:360
CYapfDestinationAnySafeTileRailT::PfCalcEstimate
bool PfCalcEstimate(Node &n)
Called by YAPF to calculate cost estimate.
Definition: yapf_destrail.hpp:103
abs
static T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition: math_func.hpp:21
RailtypeInfo::compatible_railtypes
RailTypes compatible_railtypes
bitmask to the OTHER railtypes on which an engine of THIS railtype can physically travel
Definition: rail.h:188
YAPF_TILE_CORNER_LENGTH
static const int YAPF_TILE_CORNER_LENGTH
Length (penalty) of a corner with YAPF.
Definition: pathfinder_type.h:31
CYapfDestinationAnySafeTileRailT
Definition: yapf_destrail.hpp:73
CYapfDestinationAnyDepotRailT::PfDetectDestination
bool PfDetectDestination(Node &n)
Called by YAPF to detect if node ends in the desired destination.
Definition: yapf_destrail.hpp:49
Trackdir
Trackdir
Enumeration for tracks and directions.
Definition: track_type.h:70
HasTrackdir
static bool HasTrackdir(TrackdirBits trackdirs, Trackdir trackdir)
Checks whether a TrackdirBits has a given Trackdir.
Definition: track_func.h:348
RailTypes
RailTypes
The different railtypes we support, but then a bitmask of them.
Definition: rail_type.h:46
CYapfDestinationAnySafeTileRailT::Tpf
Types::Tpf Tpf
the pathfinder class (derived from THIS class)
Definition: yapf_destrail.hpp:75
TrackdirToTrack
static Track TrackdirToTrack(Trackdir trackdir)
Returns the Track that a given Trackdir represents.
Definition: track_func.h:270
CYapfDestinationAnySafeTileRailT::TrackFollower
Types::TrackFollower TrackFollower
TrackFollower. Need to typedef for gcc 2.95.
Definition: yapf_destrail.hpp:78