OpenTTD Source: src/pbs.cpp Source File

OpenTTD Source 15.0-beta1

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"
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 && 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:
123 if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL && !GetTunnelBridgeReservationTrackBits(tile)) {
124 SetTunnelBridgeReservation(tile, true);
125 return true;
126 }
127 break;
128
129 default:
130 break;
131 }
132 return false;
133}
134
140 void UnreserveRailTrack(TileIndex tile, Track t)
141{
142 assert(HasTrack(TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)), t));
143
144 if (_settings_client.gui.show_track_reservation) {
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:
177 if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL) SetTunnelBridgeReservation(tile, false);
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)) {
201 TrackdirBits reserved = ft.new_td_bits & TrackBitsToTrackdirBits(GetReservedTrackbits(ft.new_tile));
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. */
207 TileIndexDiff diff = TileOffsByDiagDir(ft.exitdir);
208 while (ft.tiles_skipped-- > 0) {
209 ft.new_tile -= diff;
210 if (HasStationReservation(ft.new_tile)) {
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
254 struct FindTrainOnTrackInfo {
255 PBSTileInfo res;
256 Train *best;
257
259 FindTrainOnTrackInfo() : best(nullptr) {}
260};
261
263 static Vehicle *FindTrainOnTrackEnum(Vehicle *v, void *data)
264{
265 FindTrainOnTrackInfo *info = (FindTrainOnTrackInfo *)data;
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
288 PBSTileInfo FollowTrainReservation(const Train *v, Vehicle **train_on_res)
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);
299 ftoti.res.okay = IsSafeWaitingPosition(v, ftoti.res.tile, ftoti.res.trackdir, true, _settings_game.pf.forbid_90_deg);
300 if (train_on_res != nullptr) {
301 FindVehicleOnPos(ftoti.res.tile, &ftoti, FindTrainOnTrackEnum);
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. */
308 TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(ftoti.res.trackdir)));
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. */
316 FindVehicleOnPos(GetOtherTunnelBridgeEnd(ftoti.res.tile), &ftoti, FindTrainOnTrackEnum);
317 if (ftoti.best != nullptr) *train_on_res = ftoti.best->First();
318 }
319 }
320 return ftoti.res;
321}
322
330 Train *GetTrainForReservation(TileIndex tile, Track track)
331{
332 assert(HasReservedTracks(tile, TrackToTrackBits(track)));
333 Trackdir trackdir = TrackToTrackdir(track);
334
335 RailTypes rts = GetRailTypeInfo(GetTileRailType(tile))->compatible_railtypes;
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
348 FindVehicleOnPos(ftoti.res.tile, &ftoti, FindTrainOnTrackEnum);
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)) {
353 TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(ftoti.res.trackdir)));
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)) {
362 FindVehicleOnPos(GetOtherTunnelBridgeEnd(ftoti.res.tile), &ftoti, FindTrainOnTrackEnum);
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. */
390 CFollowTrackRail ft(v, GetRailTypeInfo(v->railtype)->compatible_railtypes);
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. */
399 ft.new_td_bits &= DiagdirReachesTrackdirs(ft.exitdir);
400 if (Rail90DegTurnDisallowed(GetTileRailType(ft.old_tile), GetTileRailType(ft.new_tile), forbid_90deg)) ft.new_td_bits &= ~TrackdirCrossesTrackdirs(trackdir);
401 if (ft.new_td_bits == TRACKDIR_BIT_NONE) return include_line_end;
402
403 if (ft.new_td_bits != TRACKDIR_BIT_NONE && KillFirstBit(ft.new_td_bits) == TRACKDIR_BIT_NONE) {
404 Trackdir td = FindFirstTrackdir(ft.new_td_bits);
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. */
408 if (IsTileType(ft.new_tile, MP_RAILWAY) && HasSignalOnTrackdir(ft.new_tile, ReverseTrackdir(td)) &&
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. */
439 CFollowTrackRail ft(v, GetRailTypeInfo(v->railtype)->compatible_railtypes);
440
441 if (!ft.Follow(tile, trackdir)) return true;
442
443 /* Check for reachable tracks. */
444 ft.new_td_bits &= DiagdirReachesTrackdirs(ft.exitdir);
445 if (Rail90DegTurnDisallowed(GetTileRailType(ft.old_tile), GetTileRailType(ft.new_tile), forbid_90deg)) ft.new_td_bits &= ~TrackdirCrossesTrackdirs(trackdir);
446
447 return !HasReservedTracks(ft.new_tile, TrackdirBitsToTrackBits(ft.new_td_bits));
448}
HasBit
debug_inline 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:250
IsBridgeTile
bool IsBridgeTile(Tile t)
checks if there is a bridge on this tile
Definition bridge_map.h:35
RailTypeInfo::compatible_railtypes
RailTypes compatible_railtypes
bitmask to the OTHER railtypes on which an engine of THIS railtype can physically travel
Definition rail.h:191
Owner
Owner
Enum for all companies/owners.
Definition company_type.h:18
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:73
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:2057
GetTileTrackStatus
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition landscape.cpp:554
TileAdd
constexpr TileIndex TileAdd(TileIndex tile, TileIndexDiff offset)
Adds a given offset to a tile.
Definition map_func.h:454
TileOffsByDiagDir
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition map_func.h:567
TileIndexDiff
int32_t TileIndexDiff
An offset value between two tiles.
Definition map_type.h:23
TriggerStationRandomisation
void TriggerStationRandomisation(Station *st, TileIndex trigger_tile, StationRandomTrigger trigger, CargoID cargo_type)
Trigger station randomisation.
Definition newgrf_station.cpp:919
newgrf_station.h
Header file for NewGRF stations.
SRT_PATH_RESERVATION
@ SRT_PATH_RESERVATION
Trigger platform when train reserves path.
Definition newgrf_station.h:111
GetTrainForReservation
Train * GetTrainForReservation(TileIndex tile, Track track)
Find the train which has reserved a specific path.
Definition pbs.cpp:330
SetRailStationPlatformReservation
void SetRailStationPlatformReservation(TileIndex start, DiagDirection dir, bool b)
Set the reservation for a complete station platform.
Definition pbs.cpp:57
GetReservedTrackbits
TrackBits GetReservedTrackbits(TileIndex t)
Get the reserved trackbits for any tile, regardless of type.
Definition pbs.cpp:24
FindTrainOnTrackEnum
static Vehicle * FindTrainOnTrackEnum(Vehicle *v, void *data)
Callback for Has/FindVehicleOnPos to find a train on a specific track.
Definition pbs.cpp:263
FollowTrainReservation
PBSTileInfo FollowTrainReservation(const Train *v, Vehicle **train_on_res)
Follow a train reservation to the last tile.
Definition pbs.cpp:288
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:426
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:187
UnreserveRailTrack
void UnreserveRailTrack(TileIndex tile, Track t)
Lift the reservation of a specific track on a tile.
Definition pbs.cpp:140
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:380
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:155
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:357
GetRailTypeInfo
const RailTypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Definition rail.h:307
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:475
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:426
IsRailDepotTile
static debug_inline bool IsRailDepotTile(Tile t)
Is this tile rail tile and a rail depot?
Definition rail_map.h:105
HasPbsSignalOnTrackdir
bool HasPbsSignalOnTrackdir(Tile tile, Trackdir td)
Is a pbs signal present along the trackdir?
Definition rail_map.h:463
IsRailDepot
static debug_inline bool IsRailDepot(Tile t)
Is this rail tile a rail depot?
Definition rail_map.h:95
UnreserveTrack
void UnreserveTrack(Tile tile, Track t)
Lift the reservation of a specific track on a tile.
Definition rail_map.h:244
SetDepotReservation
void SetDepotReservation(Tile t, bool b)
Set the reservation state of the depot.
Definition rail_map.h:270
GetDepotReservationTrackBits
TrackBits GetDepotReservationTrackBits(Tile t)
Get the reserved track bits for a depot.
Definition rail_map.h:282
IsPlainRail
static debug_inline bool IsPlainRail(Tile t)
Returns whether this is plain rails, with or without signals.
Definition rail_map.h:49
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:258
TryReserveTrack
bool TryReserveTrack(Tile tile, Track t)
Try to reserve a specific track on a tile.
Definition rail_map.h:226
HasTrack
bool HasTrack(Tile tile, Track track)
Returns whether the given track is present on the given tile.
Definition rail_map.h:160
RailTypes
RailTypes
Allow incrementing of Track variables.
Definition rail_type.h:44
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:1773
HasCrossingReservation
bool HasCrossingReservation(Tile t)
Get the reservation state of the rail crossing.
Definition road_map.h:380
GetCrossingReservationTrackBits
TrackBits GetCrossingReservationTrackBits(Tile t)
Get the reserved track bits for a rail crossing.
Definition road_map.h:405
SetCrossingReservation
void SetCrossingReservation(Tile t, bool b)
Set the reservation state of the rail crossing.
Definition road_map.h:393
IsLevelCrossing
bool IsLevelCrossing(Tile t)
Return whether a tile is a level crossing.
Definition road_map.h:85
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:57
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:56
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
IsRailStation
bool IsRailStation(Tile t)
Is this station tile a rail station?
Definition station_map.h:92
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
stdafx.h
Definition of base types and functions in a cross-platform compatible way.
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:29
CFollowTrackT::Follow
bool Follow(TileIndex old_tile, Trackdir old_td)
main follower routine.
Definition follow_track.hpp:121
CFollowTrackT::tiles_skipped
int tiles_skipped
number of skipped tunnel or station tiles
Definition follow_track.hpp:49
CFollowTrackT::exitdir
DiagDirection exitdir
exit direction (leaving the old tile)
Definition follow_track.hpp:45
CFollowTrackT::new_td_bits
TrackdirBits new_td_bits
the new set of available trackdirs
Definition follow_track.hpp:44
CFollowTrackT::new_tile
TileIndex new_tile
the new tile (the vehicle has entered)
Definition follow_track.hpp:43
CFollowTrackT::is_station
bool is_station
last turn passed station
Definition follow_track.hpp:48
CFollowTrackT::old_tile
TileIndex old_tile
the origin (vehicle moved from) before move
Definition follow_track.hpp:41
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition settings_type.h:610
FindTrainOnTrackInfo
Helper struct for finding the best matching vehicle on a specific track.
Definition pbs.cpp:254
FindTrainOnTrackInfo::res
PBSTileInfo res
Information about the track.
Definition pbs.cpp:255
FindTrainOnTrackInfo::FindTrainOnTrackInfo
FindTrainOnTrackInfo()
Init the best location to nullptr always!
Definition pbs.cpp:259
FindTrainOnTrackInfo::best
Train * best
The currently "best" vehicle we have found.
Definition pbs.cpp:256
GUISettings::show_track_reservation
bool show_track_reservation
highlight reserved tracks.
Definition settings_type.h:193
GameSettings::pf
PathfinderSettings pf
settings for all pathfinders
Definition settings_type.h:599
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:466
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition pool_type.hpp:238
SpecializedVehicle::From
static T * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition vehicle_base.h:1215
SpecializedVehicle::First
T * First() const
Get the first vehicle in the chain.
Definition vehicle_base.h:1112
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:89
Train::GetVehicleTrackdir
Trackdir GetVehicleTrackdir() const override
Get the tracks of the train vehicle.
Definition train_cmd.cpp:4220
Vehicle
Vehicle data structure.
Definition vehicle_base.h:244
Vehicle::vehstatus
uint8_t vehstatus
Status.
Definition vehicle_base.h:354
Vehicle::tile
TileIndex tile
Current tile index.
Definition vehicle_base.h:264
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition vehicle_base.h:309
GetTileOwner
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition tile_map.h:178
GetTileType
static debug_inline TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition tile_map.h:96
IsTileType
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
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:67
TrackdirBits
TrackdirBits
Allow incrementing of Trackdir variables.
Definition track_type.h:98
TRACKDIR_BIT_NONE
@ TRACKDIR_BIT_NONE
No track build.
Definition track_type.h:99
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:27
MarkBridgeDirty
void MarkBridgeDirty(TileIndex begin, TileIndex end, DiagDirection direction, uint bridge_height)
Mark bridge tiles dirty.
Definition tunnelbridge_cmd.cpp:67
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
FindVehicleOnPos
void FindVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
Find a vehicle from a specific location.
Definition vehicle.cpp:505
VS_CRASHED
@ VS_CRASHED
Vehicle is crashed.
Definition vehicle_base.h:40
vehicle_func.h
Functions related to vehicles.
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition vehicle_type.h:24
viewport_func.h
Functions related to (drawing on) viewports.