OpenTTD Source: src/pbs.cpp Source File

OpenTTD Source 15.0-RC2

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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
6 */
7
10#include "stdafx.h"
11#include "viewport_func.h"
12#include "vehicle_func.h"
13#include "newgrf_station.h"
14#include "pathfinder/follow_track.hpp"
15
16#include "safeguards.h"
17
24 TrackBits GetReservedTrackbits(TileIndex t)
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:
33 if (IsLevelCrossing(t)) return GetCrossingReservationTrackBits(t);
34 break;
35
36 case MP_STATION:
37 if (HasStationRail(t)) return GetStationReservationTrackBits(t);
38 break;
39
40 case MP_TUNNELBRIDGE:
41 if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) return GetTunnelBridgeReservationTrackBits(t);
42 break;
43
44 default:
45 break;
46 }
47 return TRACK_BIT_NONE;
48}
49
57 void SetRailStationPlatformReservation(TileIndex start, DiagDirection dir, bool b)
58{
59 TileIndex tile = start;
60 TileIndexDiff diff = TileOffsByDiagDir(dir);
61
62 assert(IsRailStationTile(start));
63 assert(GetRailStationAxis(start) == DiagDirToAxis(dir));
64
65 do {
66 SetRailStationReservation(tile, b);
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{
82 assert(HasTrack(TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)), t));
83
84 if (_settings_client.gui.show_track_reservation) {
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) {
117 auto *st = BaseStation::GetByTile(tile);
118 TriggerStationRandomisation(st, tile, StationRandomTrigger::PathReservation);
119 TriggerStationAnimation(st, tile, StationAnimationTrigger::PathReservation);
120 }
121 MarkTileDirtyByTile(tile); // some GRFs need redraw after reserving track
122 return true;
123 }
124 break;
125
126 case MP_TUNNELBRIDGE:
127 if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL && !GetTunnelBridgeReservationTrackBits(tile)) {
128 SetTunnelBridgeReservation(tile, true);
129 return true;
130 }
131 break;
132
133 default:
134 break;
135 }
136 return false;
137}
138
144 void UnreserveRailTrack(TileIndex tile, Track t)
145{
146 assert(HasTrack(TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)), t));
147
148 if (_settings_client.gui.show_track_reservation) {
149 if (IsBridgeTile(tile)) {
150 MarkBridgeDirty(tile);
151 } else {
152 MarkTileDirtyByTile(tile);
153 }
154 }
155
156 switch (GetTileType(tile)) {
157 case MP_RAILWAY:
158 if (IsRailDepot(tile)) {
159 SetDepotReservation(tile, false);
160 MarkTileDirtyByTile(tile);
161 break;
162 }
163 if (IsPlainRail(tile)) UnreserveTrack(tile, t);
164 break;
165
166 case MP_ROAD:
167 if (IsLevelCrossing(tile)) {
168 SetCrossingReservation(tile, false);
169 UpdateLevelCrossing(tile);
170 }
171 break;
172
173 case MP_STATION:
174 if (HasStationRail(tile)) {
175 SetRailStationReservation(tile, false);
176 MarkTileDirtyByTile(tile);
177 }
178 break;
179
180 case MP_TUNNELBRIDGE:
181 if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL) SetTunnelBridgeReservation(tile, false);
182 break;
183
184 default:
185 break;
186 }
187}
188
189
191 static PBSTileInfo FollowReservation(Owner o, RailTypes rts, TileIndex tile, Trackdir trackdir, bool ignore_oneway = false)
192{
193 TileIndex start_tile = tile;
194 Trackdir start_trackdir = trackdir;
195 bool first_loop = true;
196
197 /* Start track not reserved? This can happen if two trains
198 * are on the same tile. The reservation on the next tile
199 * is not ours in this case, so exit. */
200 if (!HasReservedTracks(tile, TrackToTrackBits(TrackdirToTrack(trackdir)))) return PBSTileInfo(tile, trackdir, false);
201
202 /* Do not disallow 90 deg turns as the setting might have changed between reserving and now. */
203 CFollowTrackRail ft(o, rts);
204 while (ft.Follow(tile, trackdir)) {
205 TrackdirBits reserved = ft.new_td_bits & TrackBitsToTrackdirBits(GetReservedTrackbits(ft.new_tile));
206
207 /* No reservation --> path end found */
208 if (reserved == TRACKDIR_BIT_NONE) {
209 if (ft.is_station) {
210 /* Check skipped station tiles as well, maybe our reservation ends inside the station. */
211 TileIndexDiff diff = TileOffsByDiagDir(ft.exitdir);
212 while (ft.tiles_skipped-- > 0) {
213 ft.new_tile -= diff;
214 if (HasStationReservation(ft.new_tile)) {
215 tile = ft.new_tile;
216 trackdir = DiagDirToDiagTrackdir(ft.exitdir);
217 break;
218 }
219 }
220 }
221 break;
222 }
223
224 /* Can't have more than one reserved trackdir */
225 Trackdir new_trackdir = FindFirstTrackdir(reserved);
226
227 /* One-way signal against us. The reservation can't be ours as it is not
228 * a safe position from our direction and we can never pass the signal. */
229 if (!ignore_oneway && HasOnewaySignalBlockingTrackdir(ft.new_tile, new_trackdir)) break;
230
231 tile = ft.new_tile;
232 trackdir = new_trackdir;
233
234 if (first_loop) {
235 /* Update the start tile after we followed the track the first
236 * time. This is necessary because the track follower can skip
237 * tiles (in stations for example) which means that we might
238 * never visit our original starting tile again. */
239 start_tile = tile;
240 start_trackdir = trackdir;
241 first_loop = false;
242 } else {
243 /* Loop encountered? */
244 if (tile == start_tile && trackdir == start_trackdir) break;
245 }
246 /* Depot tile? Can't continue. */
247 if (IsRailDepotTile(tile)) break;
248 /* Non-pbs signal? Reservation can't continue. */
249 if (IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, trackdir) && !IsPbsSignal(GetSignalType(tile, TrackdirToTrack(trackdir)))) break;
250 }
251
252 return PBSTileInfo(tile, trackdir, false);
253}
254
258 struct FindTrainOnTrackInfo {
259 PBSTileInfo res;
260 Train *best;
261
263 FindTrainOnTrackInfo() : best(nullptr) {}
264};
265
267 static void CheckTrainsOnTrack(FindTrainOnTrackInfo &info, TileIndex tile)
268{
269 for (Vehicle *v : VehiclesOnTile(tile)) {
270 if (v->type != VEH_TRAIN || v->vehstatus.Test(VehState::Crashed)) continue;
271
272 Train *t = Train::From(v);
273 if (t->track == TRACK_BIT_WORMHOLE || HasBit(static_cast<TrackBits>(t->track), TrackdirToTrack(info.res.trackdir))) {
274 t = t->First();
275
276 /* ALWAYS return the lowest ID (anti-desync!) */
277 if (info.best == nullptr || t->index < info.best->index) info.best = t;
278 }
279 }
280}
281
289 PBSTileInfo FollowTrainReservation(const Train *v, Vehicle **train_on_res)
290{
291 assert(v->type == VEH_TRAIN);
292
293 TileIndex tile = v->tile;
294 Trackdir trackdir = v->GetVehicleTrackdir();
295
296 if (IsRailDepotTile(tile) && !GetDepotReservationTrackBits(tile)) return PBSTileInfo(tile, trackdir, false);
297
298 FindTrainOnTrackInfo ftoti;
299 ftoti.res = FollowReservation(v->owner, GetAllCompatibleRailTypes(v->railtypes), tile, trackdir);
300 ftoti.res.okay = IsSafeWaitingPosition(v, ftoti.res.tile, ftoti.res.trackdir, true, _settings_game.pf.forbid_90_deg);
301 if (train_on_res != nullptr) {
302 CheckTrainsOnTrack(ftoti, ftoti.res.tile);
303 if (ftoti.best != nullptr) *train_on_res = ftoti.best->First();
304 if (*train_on_res == nullptr && IsRailStationTile(ftoti.res.tile)) {
305 /* The target tile is a rail station. The track follower
306 * has stopped on the last platform tile where we haven't
307 * found a train. Also check all previous platform tiles
308 * for a possible train. */
309 TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(ftoti.res.trackdir)));
310 for (TileIndex st_tile = ftoti.res.tile + diff; *train_on_res == nullptr && IsCompatibleTrainStationTile(st_tile, ftoti.res.tile); st_tile += diff) {
311 CheckTrainsOnTrack(ftoti, st_tile);
312 if (ftoti.best != nullptr) *train_on_res = ftoti.best->First();
313 }
314 }
315 if (*train_on_res == nullptr && IsTileType(ftoti.res.tile, MP_TUNNELBRIDGE)) {
316 /* The target tile is a bridge/tunnel, also check the other end tile. */
317 CheckTrainsOnTrack(ftoti, GetOtherTunnelBridgeEnd(ftoti.res.tile));
318 if (ftoti.best != nullptr) *train_on_res = ftoti.best->First();
319 }
320 }
321 return ftoti.res;
322}
323
331 Train *GetTrainForReservation(TileIndex tile, Track track)
332{
333 assert(HasReservedTracks(tile, TrackToTrackBits(track)));
334 Trackdir trackdir = TrackToTrackdir(track);
335
336 RailTypes rts = GetRailTypeInfo(GetTileRailType(tile))->compatible_railtypes;
337
338 /* Follow the path from tile to both ends, one of the end tiles should
339 * have a train on it. We need FollowReservation to ignore one-way signals
340 * here, as one of the two search directions will be the "wrong" way. */
341 for (int i = 0; i < 2; ++i, trackdir = ReverseTrackdir(trackdir)) {
342 /* If the tile has a one-way block signal in the current trackdir, skip the
343 * search in this direction as the reservation can't come from this side.*/
344 if (HasOnewaySignalBlockingTrackdir(tile, ReverseTrackdir(trackdir)) && !HasPbsSignalOnTrackdir(tile, trackdir)) continue;
345
346 FindTrainOnTrackInfo ftoti;
347 ftoti.res = FollowReservation(GetTileOwner(tile), rts, tile, trackdir, true);
348
349 CheckTrainsOnTrack(ftoti, ftoti.res.tile);
350 if (ftoti.best != nullptr) return ftoti.best;
351
352 /* Special case for stations: check the whole platform for a vehicle. */
353 if (IsRailStationTile(ftoti.res.tile)) {
354 TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(ftoti.res.trackdir)));
355 for (TileIndex st_tile = ftoti.res.tile + diff; IsCompatibleTrainStationTile(st_tile, ftoti.res.tile); st_tile += diff) {
356 CheckTrainsOnTrack(ftoti, st_tile);
357 if (ftoti.best != nullptr) return ftoti.best;
358 }
359 }
360
361 /* Special case for bridges/tunnels: check the other end as well. */
362 if (IsTileType(ftoti.res.tile, MP_TUNNELBRIDGE)) {
363 CheckTrainsOnTrack(ftoti, GetOtherTunnelBridgeEnd(ftoti.res.tile));
364 if (ftoti.best != nullptr) return ftoti.best;
365 }
366 }
367
368 return nullptr;
369}
370
381 bool IsSafeWaitingPosition(const Train *v, TileIndex tile, Trackdir trackdir, bool include_line_end, bool forbid_90deg)
382{
383 if (IsRailDepotTile(tile)) return true;
384
385 if (IsTileType(tile, MP_RAILWAY)) {
386 /* For non-pbs signals, stop on the signal tile. */
387 if (HasSignalOnTrackdir(tile, trackdir) && !IsPbsSignal(GetSignalType(tile, TrackdirToTrack(trackdir)))) return true;
388 }
389
390 /* Check next tile. For performance reasons, we check for 90 degree turns ourself. */
391 CFollowTrackRail ft(v, GetAllCompatibleRailTypes(v->railtypes));
392
393 /* End of track? */
394 if (!ft.Follow(tile, trackdir)) {
395 /* Last tile of a terminus station is a safe position. */
396 if (include_line_end) return true;
397 }
398
399 /* Check for reachable tracks. */
400 ft.new_td_bits &= DiagdirReachesTrackdirs(ft.exitdir);
401 if (Rail90DegTurnDisallowed(GetTileRailType(ft.old_tile), GetTileRailType(ft.new_tile), forbid_90deg)) ft.new_td_bits &= ~TrackdirCrossesTrackdirs(trackdir);
402 if (ft.new_td_bits == TRACKDIR_BIT_NONE) return include_line_end;
403
404 if (ft.new_td_bits != TRACKDIR_BIT_NONE && KillFirstBit(ft.new_td_bits) == TRACKDIR_BIT_NONE) {
405 Trackdir td = FindFirstTrackdir(ft.new_td_bits);
406 /* PBS signal on next trackdir? Safe position. */
407 if (HasPbsSignalOnTrackdir(ft.new_tile, td)) return true;
408 /* One-way PBS signal against us? Safe if end-of-line is allowed. */
409 if (IsTileType(ft.new_tile, MP_RAILWAY) && HasSignalOnTrackdir(ft.new_tile, ReverseTrackdir(td)) &&
410 GetSignalType(ft.new_tile, TrackdirToTrack(td)) == SIGTYPE_PBS_ONEWAY) {
411 return include_line_end;
412 }
413 }
414
415 return false;
416}
417
427 bool IsWaitingPositionFree(const Train *v, TileIndex tile, Trackdir trackdir, bool forbid_90deg)
428{
429 Track track = TrackdirToTrack(trackdir);
430 TrackBits reserved = GetReservedTrackbits(tile);
431
432 /* Tile reserved? Can never be a free waiting position. */
433 if (TrackOverlapsTracks(reserved, track)) return false;
434
435 /* Not reserved and depot or not a pbs signal -> free. */
436 if (IsRailDepotTile(tile)) return true;
437 if (IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, trackdir) && !IsPbsSignal(GetSignalType(tile, track))) return true;
438
439 /* Check the next tile, it has to be free as well. Do not filter for compatible railtypes
440 * to make sure we never accidentally join up reservations. */
441 CFollowTrackRail ft(v, RailTypes{});
442
443 if (!ft.Follow(tile, trackdir)) return true;
444
445 /* Check for reachable tracks. */
446 ft.new_td_bits &= DiagdirReachesTrackdirs(ft.exitdir);
447 if (Rail90DegTurnDisallowed(GetTileRailType(ft.old_tile), GetTileRailType(ft.new_tile), forbid_90deg)) ft.new_td_bits &= ~TrackdirCrossesTrackdirs(trackdir);
448
449 return !HasReservedTracks(ft.new_tile, TrackdirBitsToTrackBits(ft.new_td_bits));
450}
HasBit
constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition bitmath_func.hpp:103
KillFirstBit
constexpr T KillFirstBit(T value)
Clear the first bit in an integer.
Definition bitmath_func.hpp:226
IsBridgeTile
bool IsBridgeTile(Tile t)
checks if there is a bridge on this tile
Definition bridge_map.h:35
EnumBitSet< RailType, uint64_t >
RailTypeInfo::compatible_railtypes
RailTypes compatible_railtypes
bitmask to the OTHER railtypes on which an engine of THIS railtype can physically travel
Definition rail.h:180
VehiclesOnTile
Iterate over all vehicles on a tile.
Definition vehicle_func.h:53
DiagDirToAxis
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
Definition direction_func.h:214
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition direction_type.h:78
follow_track.hpp
Template function for track followers.
MarkTileDirtyByTile
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:2128
GetTileTrackStatus
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition landscape.cpp:559
TileAdd
constexpr TileIndex TileAdd(TileIndex tile, TileIndexDiff offset)
Adds a given offset to a tile.
Definition map_func.h:469
TileOffsByDiagDir
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition map_func.h:582
TileIndexDiff
int32_t TileIndexDiff
An offset value between two tiles.
Definition map_type.h:23
TriggerStationRandomisation
void TriggerStationRandomisation(BaseStation *st, TileIndex trigger_tile, StationRandomTrigger trigger, CargoType cargo_type)
Trigger station randomisation.
Definition newgrf_station.cpp:950
newgrf_station.h
Header file for NewGRF stations.
GetTrainForReservation
Train * GetTrainForReservation(TileIndex tile, Track track)
Find the train which has reserved a specific path.
Definition pbs.cpp:331
SetRailStationPlatformReservation
void SetRailStationPlatformReservation(TileIndex start, DiagDirection dir, bool b)
Set the reservation for a complete station platform.
Definition pbs.cpp:57
CheckTrainsOnTrack
static void CheckTrainsOnTrack(FindTrainOnTrackInfo &info, TileIndex tile)
Find the best matching vehicle on a tile.
Definition pbs.cpp:267
GetReservedTrackbits
TrackBits GetReservedTrackbits(TileIndex t)
Get the reserved trackbits for any tile, regardless of type.
Definition pbs.cpp:24
FollowTrainReservation
PBSTileInfo FollowTrainReservation(const Train *v, Vehicle **train_on_res)
Follow a train reservation to the last tile.
Definition pbs.cpp:289
TryReserveRailTrack
bool TryReserveRailTrack(TileIndex tile, Track t, bool trigger_stations)
Try to reserve a specific track on a tile.
Definition pbs.cpp:80
IsWaitingPositionFree
bool IsWaitingPositionFree(const Train *v, TileIndex tile, Trackdir trackdir, bool forbid_90deg)
Check if a safe position is free.
Definition pbs.cpp:427
FollowReservation
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:191
UnreserveRailTrack
void UnreserveRailTrack(TileIndex tile, Track t)
Lift the reservation of a specific track on a tile.
Definition pbs.cpp:144
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
HasReservedTracks
bool HasReservedTracks(TileIndex tile, TrackBits tracks)
Check whether some of tracks is reserved on a tile.
Definition pbs.h:58
GetTileRailType
RailType GetTileRailType(Tile tile)
Return the rail type of tile, or INVALID_RAILTYPE if this is no rail tile.
Definition rail.cpp:37
Rail90DegTurnDisallowed
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:410
GetRailTypeInfo
const RailTypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Definition rail.h:300
GetAllCompatibleRailTypes
RailTypes GetAllCompatibleRailTypes(RailTypes railtypes)
Returns all compatible railtypes for a set of railtypes.
Definition rail.h:312
HasOnewaySignalBlockingTrackdir
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:474
IsPlainRail
static bool IsPlainRail(Tile t)
Returns whether this is plain rails, with or without signals.
Definition rail_map.h:49
HasSignalOnTrackdir
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:425
IsRailDepot
static bool IsRailDepot(Tile t)
Is this rail tile a rail depot?
Definition rail_map.h:95
HasPbsSignalOnTrackdir
bool HasPbsSignalOnTrackdir(Tile tile, Trackdir td)
Is a pbs signal present along the trackdir?
Definition rail_map.h:462
UnreserveTrack
void UnreserveTrack(Tile tile, Track t)
Lift the reservation of a specific track on a tile.
Definition rail_map.h:243
SetDepotReservation
void SetDepotReservation(Tile t, bool b)
Set the reservation state of the depot.
Definition rail_map.h:269
GetDepotReservationTrackBits
TrackBits GetDepotReservationTrackBits(Tile t)
Get the reserved track bits for a depot.
Definition rail_map.h:281
GetRailReservationTrackBits
TrackBits GetRailReservationTrackBits(Tile t)
Returns the reserved track bits of the tile.
Definition rail_map.h:194
HasDepotReservation
bool HasDepotReservation(Tile t)
Get the reservation state of the depot.
Definition rail_map.h:257
TryReserveTrack
bool TryReserveTrack(Tile tile, Track t)
Try to reserve a specific track on a tile.
Definition rail_map.h:225
IsRailDepotTile
static bool IsRailDepotTile(Tile t)
Is this tile rail tile and a rail depot?
Definition rail_map.h:105
HasTrack
bool HasTrack(Tile tile, Track track)
Returns whether the given track is present on the given tile.
Definition rail_map.h:160
UpdateLevelCrossing
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:1788
HasCrossingReservation
bool HasCrossingReservation(Tile t)
Get the reservation state of the rail crossing.
Definition road_map.h:364
GetCrossingReservationTrackBits
TrackBits GetCrossingReservationTrackBits(Tile t)
Get the reserved track bits for a rail crossing.
Definition road_map.h:389
SetCrossingReservation
void SetCrossingReservation(Tile t, bool b)
Set the reservation state of the rail crossing.
Definition road_map.h:377
IsLevelCrossing
bool IsLevelCrossing(Tile t)
Return whether a tile is a level crossing.
Definition road_map.h:69
safeguards.h
A number of safeguards to prevent using unsafe methods.
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:61
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:60
SIGTYPE_PBS_ONEWAY
@ SIGTYPE_PBS_ONEWAY
no-entry signal
Definition signal_type.h:29
IsCompatibleTrainStationTile
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
IsRailStationTile
bool IsRailStationTile(Tile t)
Is this tile a station tile and a rail station?
Definition station_map.h:102
SetRailStationReservation
void SetRailStationReservation(Tile t, bool b)
Set the reservation state of the rail station.
Definition station_map.h:571
GetRailStationAxis
Axis GetRailStationAxis(Tile t)
Get the rail direction of a rail station.
Definition station_map.h:503
HasStationRail
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
HasStationReservation
bool HasStationReservation(Tile t)
Get the reservation state of the rail station.
Definition station_map.h:559
GetStationReservationTrackBits
TrackBits GetStationReservationTrackBits(Tile t)
Get the reserved track bits for a waypoint.
Definition station_map.h:583
StationRandomTrigger::PathReservation
@ PathReservation
Trigger platform when train reserves path.
StationAnimationTrigger::PathReservation
@ PathReservation
Trigger platform when train reserves path.
stdafx.h
Definition of base types and functions in a cross-platform compatible way.
BaseStation::GetByTile
static BaseStation * GetByTile(TileIndex tile)
Get the base station belonging to a specific tile.
Definition base_station_base.h:160
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition vehicle_type.h:51
CFollowTrackT
Track follower helper template class (can serve pathfinders and vehicle controllers).
Definition follow_track.hpp:28
CFollowTrackT::Follow
bool Follow(TileIndex old_tile, Trackdir old_td)
main follower routine.
Definition follow_track.hpp:120
CFollowTrackT::tiles_skipped
int tiles_skipped
number of skipped tunnel or station tiles
Definition follow_track.hpp:48
CFollowTrackT::exitdir
DiagDirection exitdir
exit direction (leaving the old tile)
Definition follow_track.hpp:44
CFollowTrackT::new_td_bits
TrackdirBits new_td_bits
the new set of available trackdirs
Definition follow_track.hpp:43
CFollowTrackT::new_tile
TileIndex new_tile
the new tile (the vehicle has entered)
Definition follow_track.hpp:42
CFollowTrackT::is_station
bool is_station
last turn passed station
Definition follow_track.hpp:47
CFollowTrackT::old_tile
TileIndex old_tile
the origin (vehicle moved from) before move
Definition follow_track.hpp:40
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition settings_type.h:650
FindTrainOnTrackInfo
Helper struct for finding the best matching vehicle on a specific track.
Definition pbs.cpp:258
FindTrainOnTrackInfo::res
PBSTileInfo res
Information about the track.
Definition pbs.cpp:259
FindTrainOnTrackInfo::FindTrainOnTrackInfo
FindTrainOnTrackInfo()
Init the best location to nullptr always!
Definition pbs.cpp:263
FindTrainOnTrackInfo::best
Train * best
The currently "best" vehicle we have found.
Definition pbs.cpp:260
GUISettings::show_track_reservation
bool show_track_reservation
highlight reserved tracks.
Definition settings_type.h:220
GameSettings::pf
PathfinderSettings pf
settings for all pathfinders
Definition settings_type.h:639
PBSTileInfo
This struct contains information about the end of a reserved path.
Definition pbs.h:26
PBSTileInfo::trackdir
Trackdir trackdir
The reserved trackdir on the tile.
Definition pbs.h:28
PBSTileInfo::tile
TileIndex tile
Tile the path ends, INVALID_TILE if no valid path was found.
Definition pbs.h:27
PBSTileInfo::okay
bool okay
True if tile is a safe waiting position, false otherwise.
Definition pbs.h:29
PathfinderSettings::forbid_90_deg
bool forbid_90_deg
forbid trains to make 90 deg turns
Definition settings_type.h:493
PoolID< uint8_t, struct CompanyIDTag, 0xF, 0xFF >
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition pool_type.hpp:286
SpecializedVehicle::From
static T * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition vehicle_base.h:1134
SpecializedVehicle::First
T * First() const
Get the first vehicle in the chain.
Definition vehicle_base.h:1031
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
Train
'Train' is either a loco or a wagon.
Definition train.h:91
Train::GetVehicleTrackdir
Trackdir GetVehicleTrackdir() const override
Get the tracks of the train vehicle.
Definition train_cmd.cpp:4221
Vehicle
Vehicle data structure.
Definition vehicle_base.h:205
Vehicle::tile
TileIndex tile
Current tile index.
Definition vehicle_base.h:225
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition vehicle_base.h:270
IsTileType
static bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
GetTileOwner
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition tile_map.h:178
GetTileType
static TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition tile_map.h:96
MP_ROAD
@ MP_ROAD
A tile with road (or tram tracks)
Definition tile_type.h:50
MP_STATION
@ MP_STATION
A tile of a station.
Definition tile_type.h:53
MP_TUNNELBRIDGE
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
Definition tile_type.h:57
MP_RAILWAY
@ MP_RAILWAY
A railway.
Definition tile_type.h:49
TrackToTrackdir
Trackdir TrackToTrackdir(Track track)
Returns a Trackdir for the given Track.
Definition track_func.h:279
TrackdirToTrack
Track TrackdirToTrack(Trackdir trackdir)
Returns the Track that a given Trackdir represents.
Definition track_func.h:262
TrackOverlapsTracks
bool TrackOverlapsTracks(TrackBits tracks, Track track)
Check if a given track is contained within or overlaps some other tracks.
Definition track_func.h:662
TrackToTrackBits
TrackBits TrackToTrackBits(Track track)
Maps a Track to the corresponding TrackBits value.
Definition track_func.h:77
TrackBitsToTrackdirBits
TrackdirBits TrackBitsToTrackdirBits(TrackBits bits)
Converts TrackBits to TrackdirBits while allowing both directions.
Definition track_func.h:319
ReverseTrackdir
Trackdir ReverseTrackdir(Trackdir trackdir)
Maps a trackdir to the reverse trackdir.
Definition track_func.h:247
FindFirstTrackdir
Trackdir FindFirstTrackdir(TrackdirBits trackdirs)
Returns first Trackdir from TrackdirBits or INVALID_TRACKDIR.
Definition track_func.h:211
DiagdirReachesTrackdirs
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
DiagDirToDiagTrackdir
Trackdir DiagDirToDiagTrackdir(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal trackdir that runs in that direction.
Definition track_func.h:537
TrackStatusToTrackBits
TrackBits TrackStatusToTrackBits(TrackStatus ts)
Returns the present-track-information of a TrackStatus.
Definition track_func.h:363
TrackdirToExitdir
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
TrackdirBitsToTrackBits
TrackBits TrackdirBitsToTrackBits(TrackdirBits bits)
Discards all directional information from a TrackdirBits value.
Definition track_func.h:308
TrackBits
TrackBits
Allow incrementing of Track variables.
Definition track_type.h:35
TRACK_BIT_WORMHOLE
@ TRACK_BIT_WORMHOLE
Bitflag for a wormhole (used for tunnels)
Definition track_type.h:52
TRACK_BIT_NONE
@ TRACK_BIT_NONE
No track.
Definition track_type.h:36
Trackdir
Trackdir
Enumeration for tracks and directions.
Definition track_type.h:66
TrackdirBits
TrackdirBits
Allow incrementing of Trackdir variables.
Definition track_type.h:97
TRACKDIR_BIT_NONE
@ TRACKDIR_BIT_NONE
No track build.
Definition track_type.h:98
Track
Track
These are used to specify a single track.
Definition track_type.h:19
TRANSPORT_RAIL
@ TRANSPORT_RAIL
Transport by train.
Definition transport_type.h:25
MarkBridgeDirty
void MarkBridgeDirty(TileIndex begin, TileIndex end, DiagDirection direction, uint bridge_height)
Mark bridge tiles dirty.
Definition tunnelbridge_cmd.cpp:64
GetTunnelBridgeTransportType
TransportType GetTunnelBridgeTransportType(Tile t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
Definition tunnelbridge_map.h:39
GetTunnelBridgeReservationTrackBits
TrackBits GetTunnelBridgeReservationTrackBits(Tile t)
Get the reserved track bits for a rail tunnel/bridge.
Definition tunnelbridge_map.h:117
GetOtherTunnelBridgeEnd
TileIndex GetOtherTunnelBridgeEnd(Tile t)
Determines type of the wormhole and returns its other end.
Definition tunnelbridge_map.h:78
SetTunnelBridgeReservation
void SetTunnelBridgeReservation(Tile t, bool b)
Set the reservation state of the rail tunnel/bridge.
Definition tunnelbridge_map.h:104
VehState::Crashed
@ Crashed
Vehicle is crashed.
vehicle_func.h
Functions related to vehicles.
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition vehicle_type.h:25
viewport_func.h
Functions related to (drawing on) viewports.