OpenTTD Source  20241120-master-g6d3adc6169
pbs.cpp
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 #include "stdafx.h"
11 #include "viewport_func.h"
12 #include "vehicle_func.h"
13 #include "newgrf_station.h"
15 
16 #include "safeguards.h"
17 
25 {
26  switch (GetTileType(t)) {
27  case MP_RAILWAY:
28  if (IsRailDepot(t)) return GetDepotReservationTrackBits(t);
29  if (IsPlainRail(t)) return GetRailReservationTrackBits(t);
30  break;
31 
32  case MP_ROAD:
34  break;
35 
36  case MP_STATION:
38  break;
39 
40  case MP_TUNNELBRIDGE:
42  break;
43 
44  default:
45  break;
46  }
47  return TRACK_BIT_NONE;
48 }
49 
58 {
59  TileIndex tile = start;
60  TileIndexDiff diff = TileOffsByDiagDir(dir);
61 
62  assert(IsRailStationTile(start));
63  assert(GetRailStationAxis(start) == DiagDirToAxis(dir));
64 
65  do {
67  MarkTileDirtyByTile(tile);
68  tile = TileAdd(tile, diff);
69  } while (IsCompatibleTrainStationTile(tile, start));
70 }
71 
80 bool TryReserveRailTrack(TileIndex tile, Track t, bool trigger_stations)
81 {
83 
85  /* show the reserved rail if needed */
86  if (IsBridgeTile(tile)) {
87  MarkBridgeDirty(tile);
88  } else {
89  MarkTileDirtyByTile(tile);
90  }
91  }
92 
93  switch (GetTileType(tile)) {
94  case MP_RAILWAY:
95  if (IsPlainRail(tile)) return TryReserveTrack(tile, t);
96  if (IsRailDepot(tile)) {
97  if (!HasDepotReservation(tile)) {
98  SetDepotReservation(tile, true);
99  MarkTileDirtyByTile(tile); // some GRFs change their appearance when tile is reserved
100  return true;
101  }
102  }
103  break;
104 
105  case MP_ROAD:
106  if (IsLevelCrossing(tile) && !HasCrossingReservation(tile)) {
107  SetCrossingReservation(tile, true);
108  UpdateLevelCrossing(tile, false);
109  return true;
110  }
111  break;
112 
113  case MP_STATION:
114  if (HasStationRail(tile) && !HasStationReservation(tile)) {
115  SetRailStationReservation(tile, true);
116  if (trigger_stations && IsRailStation(tile)) TriggerStationRandomisation(nullptr, tile, SRT_PATH_RESERVATION);
117  MarkTileDirtyByTile(tile); // some GRFs need redraw after reserving track
118  return true;
119  }
120  break;
121 
122  case MP_TUNNELBRIDGE:
124  SetTunnelBridgeReservation(tile, true);
125  return true;
126  }
127  break;
128 
129  default:
130  break;
131  }
132  return false;
133 }
134 
141 {
143 
145  if (IsBridgeTile(tile)) {
146  MarkBridgeDirty(tile);
147  } else {
148  MarkTileDirtyByTile(tile);
149  }
150  }
151 
152  switch (GetTileType(tile)) {
153  case MP_RAILWAY:
154  if (IsRailDepot(tile)) {
155  SetDepotReservation(tile, false);
156  MarkTileDirtyByTile(tile);
157  break;
158  }
159  if (IsPlainRail(tile)) UnreserveTrack(tile, t);
160  break;
161 
162  case MP_ROAD:
163  if (IsLevelCrossing(tile)) {
164  SetCrossingReservation(tile, false);
165  UpdateLevelCrossing(tile);
166  }
167  break;
168 
169  case MP_STATION:
170  if (HasStationRail(tile)) {
171  SetRailStationReservation(tile, false);
172  MarkTileDirtyByTile(tile);
173  }
174  break;
175 
176  case MP_TUNNELBRIDGE:
178  break;
179 
180  default:
181  break;
182  }
183 }
184 
185 
187 static PBSTileInfo FollowReservation(Owner o, RailTypes rts, TileIndex tile, Trackdir trackdir, bool ignore_oneway = false)
188 {
189  TileIndex start_tile = tile;
190  Trackdir start_trackdir = trackdir;
191  bool first_loop = true;
192 
193  /* Start track not reserved? This can happen if two trains
194  * are on the same tile. The reservation on the next tile
195  * is not ours in this case, so exit. */
196  if (!HasReservedTracks(tile, TrackToTrackBits(TrackdirToTrack(trackdir)))) return PBSTileInfo(tile, trackdir, false);
197 
198  /* Do not disallow 90 deg turns as the setting might have changed between reserving and now. */
199  CFollowTrackRail ft(o, rts);
200  while (ft.Follow(tile, trackdir)) {
202 
203  /* No reservation --> path end found */
204  if (reserved == TRACKDIR_BIT_NONE) {
205  if (ft.is_station) {
206  /* Check skipped station tiles as well, maybe our reservation ends inside the station. */
208  while (ft.tiles_skipped-- > 0) {
209  ft.new_tile -= diff;
211  tile = ft.new_tile;
212  trackdir = DiagDirToDiagTrackdir(ft.exitdir);
213  break;
214  }
215  }
216  }
217  break;
218  }
219 
220  /* Can't have more than one reserved trackdir */
221  Trackdir new_trackdir = FindFirstTrackdir(reserved);
222 
223  /* One-way signal against us. The reservation can't be ours as it is not
224  * a safe position from our direction and we can never pass the signal. */
225  if (!ignore_oneway && HasOnewaySignalBlockingTrackdir(ft.new_tile, new_trackdir)) break;
226 
227  tile = ft.new_tile;
228  trackdir = new_trackdir;
229 
230  if (first_loop) {
231  /* Update the start tile after we followed the track the first
232  * time. This is necessary because the track follower can skip
233  * tiles (in stations for example) which means that we might
234  * never visit our original starting tile again. */
235  start_tile = tile;
236  start_trackdir = trackdir;
237  first_loop = false;
238  } else {
239  /* Loop encountered? */
240  if (tile == start_tile && trackdir == start_trackdir) break;
241  }
242  /* Depot tile? Can't continue. */
243  if (IsRailDepotTile(tile)) break;
244  /* Non-pbs signal? Reservation can't continue. */
245  if (IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, trackdir) && !IsPbsSignal(GetSignalType(tile, TrackdirToTrack(trackdir)))) break;
246  }
247 
248  return PBSTileInfo(tile, trackdir, false);
249 }
250 
257 
259  FindTrainOnTrackInfo() : best(nullptr) {}
260 };
261 
263 static Vehicle *FindTrainOnTrackEnum(Vehicle *v, void *data)
264 {
266 
267  if (v->type != VEH_TRAIN || (v->vehstatus & VS_CRASHED)) return nullptr;
268 
269  Train *t = Train::From(v);
270  if (t->track == TRACK_BIT_WORMHOLE || HasBit((TrackBits)t->track, TrackdirToTrack(info->res.trackdir))) {
271  t = t->First();
272 
273  /* ALWAYS return the lowest ID (anti-desync!) */
274  if (info->best == nullptr || t->index < info->best->index) info->best = t;
275  return t;
276  }
277 
278  return nullptr;
279 }
280 
289 {
290  assert(v->type == VEH_TRAIN);
291 
292  TileIndex tile = v->tile;
293  Trackdir trackdir = v->GetVehicleTrackdir();
294 
295  if (IsRailDepotTile(tile) && !GetDepotReservationTrackBits(tile)) return PBSTileInfo(tile, trackdir, false);
296 
297  FindTrainOnTrackInfo ftoti;
298  ftoti.res = FollowReservation(v->owner, GetRailTypeInfo(v->railtype)->compatible_railtypes, tile, trackdir);
300  if (train_on_res != nullptr) {
302  if (ftoti.best != nullptr) *train_on_res = ftoti.best->First();
303  if (*train_on_res == nullptr && IsRailStationTile(ftoti.res.tile)) {
304  /* The target tile is a rail station. The track follower
305  * has stopped on the last platform tile where we haven't
306  * found a train. Also check all previous platform tiles
307  * for a possible train. */
309  for (TileIndex st_tile = ftoti.res.tile + diff; *train_on_res == nullptr && IsCompatibleTrainStationTile(st_tile, ftoti.res.tile); st_tile += diff) {
310  FindVehicleOnPos(st_tile, &ftoti, FindTrainOnTrackEnum);
311  if (ftoti.best != nullptr) *train_on_res = ftoti.best->First();
312  }
313  }
314  if (*train_on_res == nullptr && IsTileType(ftoti.res.tile, MP_TUNNELBRIDGE)) {
315  /* The target tile is a bridge/tunnel, also check the other end tile. */
317  if (ftoti.best != nullptr) *train_on_res = ftoti.best->First();
318  }
319  }
320  return ftoti.res;
321 }
322 
331 {
332  assert(HasReservedTracks(tile, TrackToTrackBits(track)));
333  Trackdir trackdir = TrackToTrackdir(track);
334 
336 
337  /* Follow the path from tile to both ends, one of the end tiles should
338  * have a train on it. We need FollowReservation to ignore one-way signals
339  * here, as one of the two search directions will be the "wrong" way. */
340  for (int i = 0; i < 2; ++i, trackdir = ReverseTrackdir(trackdir)) {
341  /* If the tile has a one-way block signal in the current trackdir, skip the
342  * search in this direction as the reservation can't come from this side.*/
343  if (HasOnewaySignalBlockingTrackdir(tile, ReverseTrackdir(trackdir)) && !HasPbsSignalOnTrackdir(tile, trackdir)) continue;
344 
345  FindTrainOnTrackInfo ftoti;
346  ftoti.res = FollowReservation(GetTileOwner(tile), rts, tile, trackdir, true);
347 
349  if (ftoti.best != nullptr) return ftoti.best;
350 
351  /* Special case for stations: check the whole platform for a vehicle. */
352  if (IsRailStationTile(ftoti.res.tile)) {
354  for (TileIndex st_tile = ftoti.res.tile + diff; IsCompatibleTrainStationTile(st_tile, ftoti.res.tile); st_tile += diff) {
355  FindVehicleOnPos(st_tile, &ftoti, FindTrainOnTrackEnum);
356  if (ftoti.best != nullptr) return ftoti.best;
357  }
358  }
359 
360  /* Special case for bridges/tunnels: check the other end as well. */
361  if (IsTileType(ftoti.res.tile, MP_TUNNELBRIDGE)) {
363  if (ftoti.best != nullptr) return ftoti.best;
364  }
365  }
366 
367  return nullptr;
368 }
369 
380 bool IsSafeWaitingPosition(const Train *v, TileIndex tile, Trackdir trackdir, bool include_line_end, bool forbid_90deg)
381 {
382  if (IsRailDepotTile(tile)) return true;
383 
384  if (IsTileType(tile, MP_RAILWAY)) {
385  /* For non-pbs signals, stop on the signal tile. */
386  if (HasSignalOnTrackdir(tile, trackdir) && !IsPbsSignal(GetSignalType(tile, TrackdirToTrack(trackdir)))) return true;
387  }
388 
389  /* Check next tile. For performance reasons, we check for 90 degree turns ourself. */
391 
392  /* End of track? */
393  if (!ft.Follow(tile, trackdir)) {
394  /* Last tile of a terminus station is a safe position. */
395  if (include_line_end) return true;
396  }
397 
398  /* Check for reachable tracks. */
401  if (ft.new_td_bits == TRACKDIR_BIT_NONE) return include_line_end;
402 
405  /* PBS signal on next trackdir? Safe position. */
406  if (HasPbsSignalOnTrackdir(ft.new_tile, td)) return true;
407  /* One-way PBS signal against us? Safe if end-of-line is allowed. */
409  GetSignalType(ft.new_tile, TrackdirToTrack(td)) == SIGTYPE_PBS_ONEWAY) {
410  return include_line_end;
411  }
412  }
413 
414  return false;
415 }
416 
426 bool IsWaitingPositionFree(const Train *v, TileIndex tile, Trackdir trackdir, bool forbid_90deg)
427 {
428  Track track = TrackdirToTrack(trackdir);
429  TrackBits reserved = GetReservedTrackbits(tile);
430 
431  /* Tile reserved? Can never be a free waiting position. */
432  if (TrackOverlapsTracks(reserved, track)) return false;
433 
434  /* Not reserved and depot or not a pbs signal -> free. */
435  if (IsRailDepotTile(tile)) return true;
436  if (IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, trackdir) && !IsPbsSignal(GetSignalType(tile, track))) return true;
437 
438  /* Check the next tile, if it's a PBS signal, it has to be free as well. */
440 
441  if (!ft.Follow(tile, trackdir)) return true;
442 
443  /* Check for reachable tracks. */
446 
448 }
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T KillFirstBit(T value)
Clear the first bit in an integer.
bool IsBridgeTile(Tile t)
checks if there is a bridge on this tile
Definition: bridge_map.h:35
RailTypes compatible_railtypes
bitmask to the OTHER railtypes on which an engine of THIS railtype can physically travel
Definition: rail.h:191
Owner
Enum for all companies/owners.
Definition: company_type.h:18
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
DiagDirection
Enumeration for diagonal directions.
Template function for track followers.
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
Definition: viewport.cpp:2057
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:554
constexpr TileIndex TileAdd(TileIndex tile, TileIndexDiff offset)
Adds a given offset to a tile.
Definition: map_func.h:454
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition: map_func.h:567
int32_t TileIndexDiff
An offset value between two tiles.
Definition: map_type.h:23
void TriggerStationRandomisation(Station *st, TileIndex trigger_tile, StationRandomTrigger trigger, CargoID cargo_type)
Trigger station randomisation.
Header file for NewGRF stations.
@ SRT_PATH_RESERVATION
Trigger platform when train reserves path.
void SetRailStationPlatformReservation(TileIndex start, DiagDirection dir, bool b)
Set the reservation for a complete station platform.
Definition: pbs.cpp:57
TrackBits GetReservedTrackbits(TileIndex t)
Get the reserved trackbits for any tile, regardless of type.
Definition: pbs.cpp:24
static Vehicle * FindTrainOnTrackEnum(Vehicle *v, void *data)
Callback for Has/FindVehicleOnPos to find a train on a specific track.
Definition: pbs.cpp:263
PBSTileInfo FollowTrainReservation(const Train *v, Vehicle **train_on_res)
Follow a train reservation to the last tile.
Definition: pbs.cpp:288
bool TryReserveRailTrack(TileIndex tile, Track t, bool trigger_stations)
Try to reserve a specific track on a tile.
Definition: pbs.cpp:80
Train * GetTrainForReservation(TileIndex tile, Track track)
Find the train which has reserved a specific path.
Definition: pbs.cpp:330
bool IsWaitingPositionFree(const Train *v, TileIndex tile, Trackdir trackdir, bool forbid_90deg)
Check if a safe position is free.
Definition: pbs.cpp:426
static PBSTileInfo FollowReservation(Owner o, RailTypes rts, TileIndex tile, Trackdir trackdir, bool ignore_oneway=false)
Follow a reservation starting from a specific tile to the end.
Definition: pbs.cpp:187
void UnreserveRailTrack(TileIndex tile, Track t)
Lift the reservation of a specific track on a tile.
Definition: pbs.cpp:140
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:380
bool HasReservedTracks(TileIndex tile, TrackBits tracks)
Check whether some of tracks is reserved on a tile.
Definition: pbs.h:58
RailType GetTileRailType(Tile tile)
Return the rail type of tile, or INVALID_RAILTYPE if this is no rail tile.
Definition: rail.cpp:155
const RailTypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Definition: rail.h:307
bool Rail90DegTurnDisallowed(RailType rt1, RailType rt2, bool def=_settings_game.pf.forbid_90_deg)
Test if 90 degree turns are disallowed between two railtypes.
Definition: rail.h:357
bool HasOnewaySignalBlockingTrackdir(Tile tile, Trackdir td)
Is a one-way signal blocking the trackdir? A one-way signal on the trackdir against will block,...
Definition: rail_map.h:475
bool HasSignalOnTrackdir(Tile tile, Trackdir trackdir)
Checks for the presence of signals along the given trackdir on the given rail tile.
Definition: rail_map.h:426
static debug_inline bool IsRailDepotTile(Tile t)
Is this tile rail tile and a rail depot?
Definition: rail_map.h:105
bool HasPbsSignalOnTrackdir(Tile tile, Trackdir td)
Is a pbs signal present along the trackdir?
Definition: rail_map.h:463
static debug_inline bool IsRailDepot(Tile t)
Is this rail tile a rail depot?
Definition: rail_map.h:95
void UnreserveTrack(Tile tile, Track t)
Lift the reservation of a specific track on a tile.
Definition: rail_map.h:244
void SetDepotReservation(Tile t, bool b)
Set the reservation state of the depot.
Definition: rail_map.h:270
TrackBits GetDepotReservationTrackBits(Tile t)
Get the reserved track bits for a depot.
Definition: rail_map.h:282
static debug_inline bool IsPlainRail(Tile t)
Returns whether this is plain rails, with or without signals.
Definition: rail_map.h:49
TrackBits GetRailReservationTrackBits(Tile t)
Returns the reserved track bits of the tile.
Definition: rail_map.h:194
bool HasDepotReservation(Tile t)
Get the reservation state of the depot.
Definition: rail_map.h:258
bool TryReserveTrack(Tile tile, Track t)
Try to reserve a specific track on a tile.
Definition: rail_map.h:226
bool HasTrack(Tile tile, Track track)
Returns whether the given track is present on the given tile.
Definition: rail_map.h:160
RailTypes
Allow incrementing of Track variables.
Definition: rail_type.h:44
void UpdateLevelCrossing(TileIndex tile, bool sound=true, bool force_bar=false)
Update a level crossing to barred or open (crossing may include multiple adjacent tiles).
Definition: train_cmd.cpp:1773
bool HasCrossingReservation(Tile t)
Get the reservation state of the rail crossing.
Definition: road_map.h:380
TrackBits GetCrossingReservationTrackBits(Tile t)
Get the reserved track bits for a rail crossing.
Definition: road_map.h:405
void SetCrossingReservation(Tile t, bool b)
Set the reservation state of the rail crossing.
Definition: road_map.h:393
bool IsLevelCrossing(Tile t)
Return whether a tile is a level crossing.
Definition: road_map.h:85
A number of safeguards to prevent using unsafe methods.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:57
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:56
@ SIGTYPE_PBS_ONEWAY
no-entry signal
Definition: signal_type.h:29
bool IsCompatibleTrainStationTile(Tile test_tile, Tile station_tile)
Check if a tile is a valid continuation to a railstation tile.
Definition: station_map.h:544
bool IsRailStationTile(Tile t)
Is this tile a station tile and a rail station?
Definition: station_map.h:102
bool IsRailStation(Tile t)
Is this station tile a rail station?
Definition: station_map.h:92
void SetRailStationReservation(Tile t, bool b)
Set the reservation state of the rail station.
Definition: station_map.h:571
Axis GetRailStationAxis(Tile t)
Get the rail direction of a rail station.
Definition: station_map.h:503
bool HasStationRail(Tile t)
Has this station tile a rail? In other words, is this station tile a rail station or rail waypoint?
Definition: station_map.h:135
bool HasStationReservation(Tile t)
Get the reservation state of the rail station.
Definition: station_map.h:559
TrackBits GetStationReservationTrackBits(Tile t)
Get the reserved track bits for a waypoint.
Definition: station_map.h:583
Definition of base types and functions in a cross-platform compatible way.
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:51
Track follower helper template class (can serve pathfinders and vehicle controllers).
bool Follow(TileIndex old_tile, Trackdir old_td)
main follower routine.
int tiles_skipped
number of skipped tunnel or station tiles
DiagDirection exitdir
exit direction (leaving the old tile)
TrackdirBits new_td_bits
the new set of available trackdirs
TileIndex new_tile
the new tile (the vehicle has entered)
bool is_station
last turn passed station
TileIndex old_tile
the origin (vehicle moved from) before move
GUISettings gui
settings related to the GUI
Helper struct for finding the best matching vehicle on a specific track.
Definition: pbs.cpp:254
PBSTileInfo res
Information about the track.
Definition: pbs.cpp:255
FindTrainOnTrackInfo()
Init the best location to nullptr always!
Definition: pbs.cpp:259
Train * best
The currently "best" vehicle we have found.
Definition: pbs.cpp:256
bool show_track_reservation
highlight reserved tracks.
PathfinderSettings pf
settings for all pathfinders
This struct contains information about the end of a reserved path.
Definition: pbs.h:26
Trackdir trackdir
The reserved trackdir on the tile.
Definition: pbs.h:28
TileIndex tile
Tile the path ends, INVALID_TILE if no valid path was found.
Definition: pbs.h:27
bool okay
True if tile is a safe waiting position, false otherwise.
Definition: pbs.h:29
bool forbid_90_deg
forbid trains to make 90 deg turns
Tindex index
Index of this pool item.
Definition: pool_type.hpp:238
static T * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
T * First() const
Get the first vehicle in the chain.
'Train' is either a loco or a wagon.
Definition: train.h:89
Trackdir GetVehicleTrackdir() const override
Get the tracks of the train vehicle.
Definition: train_cmd.cpp:4220
Vehicle data structure.
Definition: vehicle_base.h:244
uint8_t vehstatus
Status.
Definition: vehicle_base.h:354
TileIndex tile
Current tile index.
Definition: vehicle_base.h:264
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:309
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition: tile_map.h:178
static debug_inline TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition: tile_map.h:96
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
@ MP_ROAD
A tile with road (or tram tracks)
Definition: tile_type.h:50
@ MP_STATION
A tile of a station.
Definition: tile_type.h:53
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
Definition: tile_type.h:57
@ MP_RAILWAY
A railway.
Definition: tile_type.h:49
Trackdir TrackToTrackdir(Track track)
Returns a Trackdir for the given Track.
Definition: track_func.h:279
Track TrackdirToTrack(Trackdir trackdir)
Returns the Track that a given Trackdir represents.
Definition: track_func.h:262
bool TrackOverlapsTracks(TrackBits tracks, Track track)
Check if a given track is contained within or overlaps some other tracks.
Definition: track_func.h:662
TrackBits TrackToTrackBits(Track track)
Maps a Track to the corresponding TrackBits value.
Definition: track_func.h:77
TrackdirBits TrackBitsToTrackdirBits(TrackBits bits)
Converts TrackBits to TrackdirBits while allowing both directions.
Definition: track_func.h:319
Trackdir ReverseTrackdir(Trackdir trackdir)
Maps a trackdir to the reverse trackdir.
Definition: track_func.h:247
Trackdir FindFirstTrackdir(TrackdirBits trackdirs)
Returns first Trackdir from TrackdirBits or INVALID_TRACKDIR.
Definition: track_func.h:211
TrackdirBits TrackdirCrossesTrackdirs(Trackdir trackdir)
Maps a trackdir to all trackdirs that make 90 deg turns with it.
Definition: track_func.h:606
TrackdirBits DiagdirReachesTrackdirs(DiagDirection diagdir)
Returns all trackdirs that can be reached when entering a tile from a given (diagonal) direction.
Definition: track_func.h:555
Trackdir DiagDirToDiagTrackdir(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal trackdir that runs in that direction.
Definition: track_func.h:537
TrackBits TrackStatusToTrackBits(TrackStatus ts)
Returns the present-track-information of a TrackStatus.
Definition: track_func.h:363
DiagDirection TrackdirToExitdir(Trackdir trackdir)
Maps a trackdir to the (4-way) direction the tile is exited when following that trackdir.
Definition: track_func.h:439
TrackBits TrackdirBitsToTrackBits(TrackdirBits bits)
Discards all directional information from a TrackdirBits value.
Definition: track_func.h:308
TrackBits
Allow incrementing of Track variables.
Definition: track_type.h:35
@ TRACK_BIT_WORMHOLE
Bitflag for a wormhole (used for tunnels)
Definition: track_type.h:52
@ TRACK_BIT_NONE
No track.
Definition: track_type.h:36
Trackdir
Enumeration for tracks and directions.
Definition: track_type.h:67
TrackdirBits
Allow incrementing of Trackdir variables.
Definition: track_type.h:98
@ TRACKDIR_BIT_NONE
No track build.
Definition: track_type.h:99
Track
These are used to specify a single track.
Definition: track_type.h:19
@ TRANSPORT_RAIL
Transport by train.
void MarkBridgeDirty(TileIndex begin, TileIndex end, DiagDirection direction, uint bridge_height)
Mark bridge tiles dirty.
TransportType GetTunnelBridgeTransportType(Tile t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
TrackBits GetTunnelBridgeReservationTrackBits(Tile t)
Get the reserved track bits for a rail tunnel/bridge.
TileIndex GetOtherTunnelBridgeEnd(Tile t)
Determines type of the wormhole and returns its other end.
void SetTunnelBridgeReservation(Tile t, bool b)
Set the reservation state of the rail tunnel/bridge.
void FindVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
Find a vehicle from a specific location.
Definition: vehicle.cpp:505
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:40
Functions related to vehicles.
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
Functions related to (drawing on) viewports.