OpenTTD Source: src/rail_map.h Source File

OpenTTD Source 15.3

rail_map.h
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#ifndef RAIL_MAP_H
11#define RAIL_MAP_H
12
13#include "rail_type.h"
14#include "depot_type.h"
15#include "signal_func.h"
16#include "track_func.h"
17#include "tile_map.h"
18#include "water_map.h"
19#include "signal_type.h"
20
21
23 enum class RailTileType : uint8_t {
24 Normal = 0,
25 Signals = 1,
26 Depot = 3,
27};
28
36[[debug_inline]] inline static RailTileType GetRailTileType(Tile t)
37{
38 assert(IsTileType(t, MP_RAILWAY));
39 return static_cast<RailTileType>(GB(t.m5(), 6, 2));
40}
41
49[[debug_inline]] inline static bool IsPlainRail(Tile t)
50{
51 RailTileType rtt = GetRailTileType(t);
52 return rtt == RailTileType::Normal || rtt == RailTileType::Signals;
53}
54
60[[debug_inline]] inline static bool IsPlainRailTile(Tile t)
61{
62 return IsTileType(t, MP_RAILWAY) && IsPlainRail(t);
63}
64
65
72 inline bool HasSignals(Tile t)
73{
74 return GetRailTileType(t) == RailTileType::Signals;
75}
76
83 inline void SetHasSignals(Tile tile, bool signals)
84{
85 assert(IsPlainRailTile(tile));
86 SB(tile.m5(), 6, 2, to_underlying(signals ? RailTileType::Signals : RailTileType::Normal));
87}
88
95[[debug_inline]] inline static bool IsRailDepot(Tile t)
96{
97 return GetRailTileType(t) == RailTileType::Depot;
98}
99
105[[debug_inline]] inline static bool IsRailDepotTile(Tile t)
106{
107 return IsTileType(t, MP_RAILWAY) && IsRailDepot(t);
108}
109
115 inline RailType GetRailType(Tile t)
116{
117 return (RailType)GB(t.m8(), 0, 6);
118}
119
125 inline void SetRailType(Tile t, RailType r)
126{
127 SB(t.m8(), 0, 6, r);
128}
129
130
136 inline TrackBits GetTrackBits(Tile tile)
137{
138 assert(IsPlainRailTile(tile));
139 return (TrackBits)GB(tile.m5(), 0, 6);
140}
141
147 inline void SetTrackBits(Tile t, TrackBits b)
148{
149 assert(IsPlainRailTile(t));
150 SB(t.m5(), 0, 6, b);
151}
152
160 inline bool HasTrack(Tile tile, Track track)
161{
162 return HasBit(GetTrackBits(tile), track);
163}
164
171 inline DiagDirection GetRailDepotDirection(Tile t)
172{
173 return (DiagDirection)GB(t.m5(), 0, 2);
174}
175
182 inline Track GetRailDepotTrack(Tile t)
183{
184 return DiagDirToDiagTrack(GetRailDepotDirection(t));
185}
186
187
194 inline TrackBits GetRailReservationTrackBits(Tile t)
195{
196 assert(IsPlainRailTile(t));
197 uint8_t track_b = GB(t.m2(), 8, 3);
198 Track track = (Track)(track_b - 1); // map array saves Track+1
199 if (track_b == 0) return TRACK_BIT_NONE;
200 return (TrackBits)(TrackToTrackBits(track) | (HasBit(t.m2(), 11) ? TrackToTrackBits(TrackToOppositeTrack(track)) : 0));
201}
202
209 inline void SetTrackReservation(Tile t, TrackBits b)
210{
211 assert(IsPlainRailTile(t));
212 assert(!TracksOverlap(b));
213 Track track = RemoveFirstTrack(&b);
214 SB(t.m2(), 8, 3, track == INVALID_TRACK ? 0 : track + 1);
215 AssignBit(t.m2(), 11, b != TRACK_BIT_NONE);
216}
217
225 inline bool TryReserveTrack(Tile tile, Track t)
226{
227 assert(HasTrack(tile, t));
228 TrackBits bits = TrackToTrackBits(t);
229 TrackBits res = GetRailReservationTrackBits(tile);
230 if ((res & bits) != TRACK_BIT_NONE) return false; // already reserved
231 res |= bits;
232 if (TracksOverlap(res)) return false; // crossing reservation present
233 SetTrackReservation(tile, res);
234 return true;
235}
236
243 inline void UnreserveTrack(Tile tile, Track t)
244{
245 assert(HasTrack(tile, t));
246 TrackBits res = GetRailReservationTrackBits(tile);
247 res &= ~TrackToTrackBits(t);
248 SetTrackReservation(tile, res);
249}
250
257 inline bool HasDepotReservation(Tile t)
258{
259 assert(IsRailDepot(t));
260 return HasBit(t.m5(), 4);
261}
262
269 inline void SetDepotReservation(Tile t, bool b)
270{
271 assert(IsRailDepot(t));
272 AssignBit(t.m5(), 4, b);
273}
274
281 inline TrackBits GetDepotReservationTrackBits(Tile t)
282{
283 return HasDepotReservation(t) ? TrackToTrackBits(GetRailDepotTrack(t)) : TRACK_BIT_NONE;
284}
285
286
287inline bool IsPbsSignal(SignalType s)
288{
289 return s == SIGTYPE_PBS || s == SIGTYPE_PBS_ONEWAY;
290}
291
292inline SignalType GetSignalType(Tile t, Track track)
293{
294 assert(GetRailTileType(t) == RailTileType::Signals);
295 uint8_t pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;
296 return (SignalType)GB(t.m2(), pos, 3);
297}
298
299inline void SetSignalType(Tile t, Track track, SignalType s)
300{
301 assert(GetRailTileType(t) == RailTileType::Signals);
302 uint8_t pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;
303 SB(t.m2(), pos, 3, s);
304 if (track == INVALID_TRACK) SB(t.m2(), 4, 3, s);
305}
306
307inline bool IsPresignalEntry(Tile t, Track track)
308{
309 return GetSignalType(t, track) == SIGTYPE_ENTRY || GetSignalType(t, track) == SIGTYPE_COMBO;
310}
311
312inline bool IsPresignalExit(Tile t, Track track)
313{
314 return GetSignalType(t, track) == SIGTYPE_EXIT || GetSignalType(t, track) == SIGTYPE_COMBO;
315}
316
318 inline bool IsOnewaySignal(Tile t, Track track)
319{
320 return GetSignalType(t, track) != SIGTYPE_PBS;
321}
322
323inline void CycleSignalSide(Tile t, Track track)
324{
325 uint8_t sig;
326 uint8_t pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 6;
327
328 sig = GB(t.m3(), pos, 2);
329 if (--sig == 0) sig = IsPbsSignal(GetSignalType(t, track)) ? 2 : 3;
330 SB(t.m3(), pos, 2, sig);
331}
332
333inline SignalVariant GetSignalVariant(Tile t, Track track)
334{
335 uint8_t pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 7 : 3;
336 return (SignalVariant)GB(t.m2(), pos, 1);
337}
338
339inline void SetSignalVariant(Tile t, Track track, SignalVariant v)
340{
341 uint8_t pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 7 : 3;
342 SB(t.m2(), pos, 1, v);
343 if (track == INVALID_TRACK) SB(t.m2(), 7, 1, v);
344}
345
351 inline void SetSignalStates(Tile tile, uint state)
352{
353 SB(tile.m4(), 4, 4, state);
354}
355
361 inline uint GetSignalStates(Tile tile)
362{
363 return GB(tile.m4(), 4, 4);
364}
365
372 inline SignalState GetSingleSignalState(Tile t, uint8_t signalbit)
373{
374 return (SignalState)HasBit(GetSignalStates(t), signalbit);
375}
376
382 inline void SetPresentSignals(Tile tile, uint signals)
383{
384 SB(tile.m3(), 4, 4, signals);
385}
386
392 inline uint GetPresentSignals(Tile tile)
393{
394 return GB(tile.m3(), 4, 4);
395}
396
403 inline bool IsSignalPresent(Tile t, uint8_t signalbit)
404{
405 return HasBit(GetPresentSignals(t), signalbit);
406}
407
412 inline bool HasSignalOnTrack(Tile tile, Track track)
413{
414 assert(IsValidTrack(track));
415 return GetRailTileType(tile) == RailTileType::Signals && (GetPresentSignals(tile) & SignalOnTrack(track)) != 0;
416}
417
425 inline bool HasSignalOnTrackdir(Tile tile, Trackdir trackdir)
426{
427 assert (IsValidTrackdir(trackdir));
428 return GetRailTileType(tile) == RailTileType::Signals && GetPresentSignals(tile) & SignalAlongTrackdir(trackdir);
429}
430
437 inline SignalState GetSignalStateByTrackdir(Tile tile, Trackdir trackdir)
438{
439 assert(IsValidTrackdir(trackdir));
440 assert(HasSignalOnTrack(tile, TrackdirToTrack(trackdir)));
441 return GetSignalStates(tile) & SignalAlongTrackdir(trackdir) ?
442 SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;
443}
444
448 inline void SetSignalStateByTrackdir(Tile tile, Trackdir trackdir, SignalState state)
449{
450 if (state == SIGNAL_STATE_GREEN) { // set 1
451 SetSignalStates(tile, GetSignalStates(tile) | SignalAlongTrackdir(trackdir));
452 } else {
453 SetSignalStates(tile, GetSignalStates(tile) & ~SignalAlongTrackdir(trackdir));
454 }
455}
456
462 inline bool HasPbsSignalOnTrackdir(Tile tile, Trackdir td)
463{
464 return IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, td) &&
465 IsPbsSignal(GetSignalType(tile, TrackdirToTrack(td)));
466}
467
474 inline bool HasOnewaySignalBlockingTrackdir(Tile tile, Trackdir td)
475{
476 return IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, ReverseTrackdir(td)) &&
477 !HasSignalOnTrackdir(tile, td) && IsOnewaySignal(tile, TrackdirToTrack(td));
478}
479
480
481 RailType GetTileRailType(Tile tile);
482
484 enum class RailGroundType : uint8_t {
485 Barren = 0,
486 Grass = 1,
487 FenceNW = 2,
488 FenceSE = 3,
489 FenceSENW = 4,
490 FenceNE = 5,
491 FenceSW = 6,
492 FenceNESW = 7,
493 FenceVert1 = 8,
494 FenceVert2 = 9,
495 FenceHoriz1 = 10,
496 FenceHoriz2 = 11,
497 SnowOrDesert = 12,
498 HalfTileWater = 13,
499 HalfTileSnow = 14,
500};
501
502inline void SetRailGroundType(Tile t, RailGroundType rgt)
503{
504 SB(t.m4(), 0, 4, to_underlying(rgt));
505}
506
507inline RailGroundType GetRailGroundType(Tile t)
508{
509 return static_cast<RailGroundType>(GB(t.m4(), 0, 4));
510}
511
512inline bool IsSnowRailGround(Tile t)
513{
514 return GetRailGroundType(t) == RailGroundType::SnowOrDesert;
515}
516
517
518inline void MakeRailNormal(Tile t, Owner o, TrackBits b, RailType r)
519{
520 SetTileType(t, MP_RAILWAY);
521 SetTileOwner(t, o);
522 SetDockingTile(t, false);
523 t.m2() = 0;
524 t.m3() = 0;
525 t.m4() = 0;
526 t.m5() = to_underlying(RailTileType::Normal) << 6 | b;
527 SB(t.m6(), 2, 6, 0);
528 t.m7() = 0;
529 t.m8() = r;
530}
531
537 inline void SetRailDepotExitDirection(Tile tile, DiagDirection dir)
538{
539 assert(IsRailDepotTile(tile));
540 SB(tile.m5(), 0, 2, dir);
541}
542
551 inline void MakeRailDepot(Tile tile, Owner owner, DepotID depot_id, DiagDirection dir, RailType rail_type)
552{
553 SetTileType(tile, MP_RAILWAY);
554 SetTileOwner(tile, owner);
555 SetDockingTile(tile, false);
556 tile.m2() = depot_id.base();
557 tile.m3() = 0;
558 tile.m4() = 0;
559 tile.m5() = to_underlying(RailTileType::Depot) << 6 | dir;
560 SB(tile.m6(), 2, 6, 0);
561 tile.m7() = 0;
562 tile.m8() = rail_type;
563}
564
565#endif /* RAIL_MAP_H */
AssignBit
constexpr T AssignBit(T &x, const uint8_t y, bool value)
Assigns a bit in a variable.
Definition bitmath_func.hpp:176
SB
constexpr T SB(T &x, const uint8_t s, const uint8_t n, const U d)
Set n bits in x starting at bit s to d.
Definition bitmath_func.hpp:58
GB
static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
Definition bitmath_func.hpp:32
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
Tile
Wrapper class to abstract away the way the tiles are stored.
Definition map_func.h:25
Tile::m5
uint8_t & m5()
General purpose.
Definition map_func.h:161
Tile::m4
uint8_t & m4()
General purpose.
Definition map_func.h:149
Tile::m6
uint8_t & m6()
General purpose.
Definition map_func.h:173
Tile::m7
uint8_t & m7()
Primarily used for newgrf support.
Definition map_func.h:185
Tile::m3
uint8_t & m3()
General purpose.
Definition map_func.h:137
Tile::m8
uint16_t & m8()
General purpose.
Definition map_func.h:197
Tile::m2
uint16_t & m2()
Primarily used for indices to towns, industries and stations.
Definition map_func.h:125
depot_type.h
Header files for depots (not hangars)
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition direction_type.h:78
to_underlying
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23)
Definition enum_type.hpp:17
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
GetRailTileType
static RailTileType GetRailTileType(Tile t)
Returns the RailTileType (normal with or without signals, waypoint or depot).
Definition rail_map.h:36
IsPlainRail
static bool IsPlainRail(Tile t)
Returns whether this is plain rails, with or without signals.
Definition rail_map.h:49
GetSignalStates
uint GetSignalStates(Tile tile)
Set the states of the signals (Along/AgainstTrackDir)
Definition rail_map.h:361
MakeRailDepot
void MakeRailDepot(Tile tile, Owner owner, DepotID depot_id, DiagDirection dir, RailType rail_type)
Make a rail depot.
Definition rail_map.h:551
GetRailType
RailType GetRailType(Tile t)
Gets the rail type of the given tile.
Definition rail_map.h:115
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
GetTrackBits
TrackBits GetTrackBits(Tile tile)
Gets the track bits of the given tile.
Definition rail_map.h:136
IsPlainRailTile
static bool IsPlainRailTile(Tile t)
Checks whether the tile is a rail tile or rail tile with signals.
Definition rail_map.h:60
RailTileType
RailTileType
Different types of Rail-related tiles.
Definition rail_map.h:23
RailTileType::Normal
@ Normal
Normal rail tile without signals.
RailTileType::Depot
@ Depot
Depot (one entrance)
RailTileType::Signals
@ Signals
Normal rail tile with signals.
GetRailDepotTrack
Track GetRailDepotTrack(Tile t)
Returns the track of a depot, ignoring direction.
Definition rail_map.h:182
SetTrackReservation
void SetTrackReservation(Tile t, TrackBits b)
Sets the reserved track bits of the tile.
Definition rail_map.h:209
IsSignalPresent
bool IsSignalPresent(Tile t, uint8_t signalbit)
Checks whether the given signals is present.
Definition rail_map.h:403
GetRailDepotDirection
DiagDirection GetRailDepotDirection(Tile t)
Returns the direction the depot is facing to.
Definition rail_map.h:171
SetTrackBits
void SetTrackBits(Tile t, TrackBits b)
Sets the track bits of the given tile.
Definition rail_map.h:147
RailGroundType
RailGroundType
The ground 'under' the rail.
Definition rail_map.h:484
RailGroundType::FenceSENW
@ FenceSENW
Grass with a fence at the NW and SE edges.
RailGroundType::FenceVert2
@ FenceVert2
Grass with a fence at the western side.
RailGroundType::HalfTileSnow
@ HalfTileSnow
Snow only on higher part of slope (steep or one corner raised)
RailGroundType::Barren
@ Barren
Nothing (dirt)
RailGroundType::FenceNESW
@ FenceNESW
Grass with a fence at the NE and SW edges.
RailGroundType::FenceHoriz2
@ FenceHoriz2
Grass with a fence at the northern side.
RailGroundType::SnowOrDesert
@ SnowOrDesert
Icy or sandy.
RailGroundType::HalfTileWater
@ HalfTileWater
Grass with a fence and shore or water on the free halftile.
RailGroundType::FenceVert1
@ FenceVert1
Grass with a fence at the eastern side.
RailGroundType::FenceNW
@ FenceNW
Grass with a fence at the NW edge.
RailGroundType::FenceSE
@ FenceSE
Grass with a fence at the SE edge.
RailGroundType::FenceNE
@ FenceNE
Grass with a fence at the NE edge.
RailGroundType::Grass
@ Grass
Grassy.
RailGroundType::FenceSW
@ FenceSW
Grass with a fence at the SW edge.
RailGroundType::FenceHoriz1
@ FenceHoriz1
Grass with a fence at the southern side.
SetSignalStateByTrackdir
void SetSignalStateByTrackdir(Tile tile, Trackdir trackdir, SignalState state)
Sets the state of the signal along the given trackdir.
Definition rail_map.h:448
GetPresentSignals
uint GetPresentSignals(Tile tile)
Get whether the given signals are present (Along/AgainstTrackDir)
Definition rail_map.h:392
HasSignalOnTrack
bool HasSignalOnTrack(Tile tile, Track track)
Checks for the presence of signals (either way) on the given track on the given rail tile.
Definition rail_map.h:412
HasPbsSignalOnTrackdir
bool HasPbsSignalOnTrackdir(Tile tile, Trackdir td)
Is a pbs signal present along the trackdir?
Definition rail_map.h:462
IsOnewaySignal
bool IsOnewaySignal(Tile t, Track track)
One-way signals can't be passed the 'wrong' way.
Definition rail_map.h:318
SetPresentSignals
void SetPresentSignals(Tile tile, uint signals)
Set whether the given signals are present (Along/AgainstTrackDir)
Definition rail_map.h:382
SetRailDepotExitDirection
void SetRailDepotExitDirection(Tile tile, DiagDirection dir)
Sets the exit direction of a rail depot.
Definition rail_map.h:537
UnreserveTrack
void UnreserveTrack(Tile tile, Track t)
Lift the reservation of a specific track on a tile.
Definition rail_map.h:243
GetTileRailType
RailType GetTileRailType(Tile tile)
Return the rail type of tile, or INVALID_RAILTYPE if this is no rail tile.
Definition rail.cpp:37
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
SetHasSignals
void SetHasSignals(Tile tile, bool signals)
Add/remove the 'has signal' bit from the RailTileType.
Definition rail_map.h:83
TryReserveTrack
bool TryReserveTrack(Tile tile, Track t)
Try to reserve a specific track on a tile.
Definition rail_map.h:225
HasSignals
bool HasSignals(Tile t)
Checks if a rail tile has signals.
Definition rail_map.h:72
GetSignalStateByTrackdir
SignalState GetSignalStateByTrackdir(Tile tile, Trackdir trackdir)
Gets the state of the signal along the given trackdir.
Definition rail_map.h:437
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
GetSingleSignalState
SignalState GetSingleSignalState(Tile t, uint8_t signalbit)
Get the state of a single signal.
Definition rail_map.h:372
SetSignalStates
void SetSignalStates(Tile tile, uint state)
Set the states of the signals (Along/AgainstTrackDir)
Definition rail_map.h:351
SetRailType
void SetRailType(Tile t, RailType r)
Sets the rail type of the given tile.
Definition rail_map.h:125
rail_type.h
The different types of rail.
RailType
RailType
Enumeration for all possible railtypes.
Definition rail_type.h:25
signal_func.h
Functions related to signals.
SignalAlongTrackdir
uint8_t SignalAlongTrackdir(Trackdir trackdir)
Maps a trackdir to the bit that stores its status in the map arrays, in the direction along with the ...
Definition signal_func.h:22
SignalOnTrack
uint8_t SignalOnTrack(Track track)
Maps a Track to the bits that store the status of the two signals that can be present on the given tr...
Definition signal_func.h:42
signal_type.h
Types and classes related to signals.
SignalType
SignalType
Type of signal, i.e.
Definition signal_type.h:23
SIGTYPE_PBS_ONEWAY
@ SIGTYPE_PBS_ONEWAY
no-entry signal
Definition signal_type.h:29
SIGTYPE_PBS
@ SIGTYPE_PBS
normal pbs signal
Definition signal_type.h:28
SIGTYPE_ENTRY
@ SIGTYPE_ENTRY
presignal block entry
Definition signal_type.h:25
SIGTYPE_COMBO
@ SIGTYPE_COMBO
presignal inter-block
Definition signal_type.h:27
SIGTYPE_EXIT
@ SIGTYPE_EXIT
presignal block exit
Definition signal_type.h:26
SignalState
SignalState
These are states in which a signal can be.
Definition signal_type.h:42
SIGNAL_STATE_RED
@ SIGNAL_STATE_RED
The signal is red.
Definition signal_type.h:43
SIGNAL_STATE_GREEN
@ SIGNAL_STATE_GREEN
The signal is green.
Definition signal_type.h:44
SignalVariant
SignalVariant
Variant of the signal, i.e.
Definition signal_type.h:16
Depot
Definition depot_base.h:20
PoolID< uint8_t, struct CompanyIDTag, 0xF, 0xFF >
tile_map.h
Map writing/reading functions for tiles.
IsTileType
static bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
SetTileType
void SetTileType(Tile tile, TileType type)
Set the type of a tile.
Definition tile_map.h:131
SetTileOwner
void SetTileOwner(Tile tile, Owner owner)
Sets the owner of a tile.
Definition tile_map.h:198
MP_RAILWAY
@ MP_RAILWAY
A railway.
Definition tile_type.h:49
track_func.h
Different conversion functions from one kind of track to another.
TrackdirToTrack
Track TrackdirToTrack(Trackdir trackdir)
Returns the Track that a given Trackdir represents.
Definition track_func.h:262
TrackToOppositeTrack
Track TrackToOppositeTrack(Track t)
Find the opposite track to a given track.
Definition track_func.h:231
TrackToTrackBits
TrackBits TrackToTrackBits(Track track)
Maps a Track to the corresponding TrackBits value.
Definition track_func.h:77
ReverseTrackdir
Trackdir ReverseTrackdir(Trackdir trackdir)
Maps a trackdir to the reverse trackdir.
Definition track_func.h:247
TracksOverlap
bool TracksOverlap(TrackBits bits)
Checks if the given tracks overlap, ie form a crossing.
Definition track_func.h:645
IsValidTrackdir
bool IsValidTrackdir(Trackdir trackdir)
Checks if a Trackdir is valid for non-road vehicles.
Definition track_func.h:52
IsValidTrack
bool IsValidTrack(Track track)
Checks if a Track is valid.
Definition track_func.h:28
RemoveFirstTrack
Track RemoveFirstTrack(TrackBits *tracks)
Removes first Track from TrackBits and returns it.
Definition track_func.h:131
DiagDirToDiagTrack
Track DiagDirToDiagTrack(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal track incidating with that diagdir.
Definition track_func.h:512
TrackBits
TrackBits
Allow incrementing of Track variables.
Definition track_type.h:35
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
Track
Track
These are used to specify a single track.
Definition track_type.h:19
INVALID_TRACK
@ INVALID_TRACK
Flag for an invalid track.
Definition track_type.h:28
TRACK_LOWER
@ TRACK_LOWER
Track in the lower corner of the tile (south)
Definition track_type.h:24
TRACK_RIGHT
@ TRACK_RIGHT
Track in the right corner of the tile (east)
Definition track_type.h:26
water_map.h
Map accessors for water tiles.
SetDockingTile
void SetDockingTile(Tile t, bool b)
Set the docking tile state of a tile.
Definition water_map.h:363