OpenTTD Source 20241224-master-gf74b0cf984
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 <http://www.gnu.org/licenses/>.
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
28
36debug_inline static RailTileType GetRailTileType(Tile t)
37{
38 assert(IsTileType(t, MP_RAILWAY));
39 return (RailTileType)GB(t.m5(), 6, 2);
40}
41
49debug_inline static bool IsPlainRail(Tile t)
50{
52 return rtt == RAIL_TILE_NORMAL || rtt == RAIL_TILE_SIGNALS;
53}
54
60debug_inline static bool IsPlainRailTile(Tile t)
61{
62 return IsTileType(t, MP_RAILWAY) && IsPlainRail(t);
63}
64
65
72inline bool HasSignals(Tile t)
73{
75}
76
83inline void SetHasSignals(Tile tile, bool signals)
84{
85 assert(IsPlainRailTile(tile));
86 AssignBit(tile.m5(), 6, signals);
87}
88
95debug_inline static bool IsRailDepot(Tile t)
96{
98}
99
105debug_inline static bool IsRailDepotTile(Tile t)
106{
107 return IsTileType(t, MP_RAILWAY) && IsRailDepot(t);
108}
109
116{
117 return (RailType)GB(t.m8(), 0, 6);
118}
119
125inline void SetRailType(Tile t, RailType r)
126{
127 SB(t.m8(), 0, 6, r);
128}
129
130
137{
138 assert(IsPlainRailTile(tile));
139 return (TrackBits)GB(tile.m5(), 0, 6);
140}
141
147inline void SetTrackBits(Tile t, TrackBits b)
148{
149 assert(IsPlainRailTile(t));
150 SB(t.m5(), 0, 6, b);
151}
152
160inline bool HasTrack(Tile tile, Track track)
161{
162 return HasBit(GetTrackBits(tile), track);
163}
164
172{
173 return (DiagDirection)GB(t.m5(), 0, 2);
174}
175
186
187
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
210{
211 assert(IsPlainRailTile(t));
212 assert(b != INVALID_TRACK_BIT);
213 assert(!TracksOverlap(b));
214 Track track = RemoveFirstTrack(&b);
215 SB(t.m2(), 8, 3, track == INVALID_TRACK ? 0 : track + 1);
216 AssignBit(t.m2(), 11, b != TRACK_BIT_NONE);
217}
218
226inline bool TryReserveTrack(Tile tile, Track t)
227{
228 assert(HasTrack(tile, t));
229 TrackBits bits = TrackToTrackBits(t);
231 if ((res & bits) != TRACK_BIT_NONE) return false; // already reserved
232 res |= bits;
233 if (TracksOverlap(res)) return false; // crossing reservation present
234 SetTrackReservation(tile, res);
235 return true;
236}
237
244inline void UnreserveTrack(Tile tile, Track t)
245{
246 assert(HasTrack(tile, t));
248 res &= ~TrackToTrackBits(t);
249 SetTrackReservation(tile, res);
250}
251
259{
260 assert(IsRailDepot(t));
261 return HasBit(t.m5(), 4);
262}
263
270inline void SetDepotReservation(Tile t, bool b)
271{
272 assert(IsRailDepot(t));
273 AssignBit(t.m5(), 4, b);
274}
275
286
287
288inline bool IsPbsSignal(SignalType s)
289{
290 return s == SIGTYPE_PBS || s == SIGTYPE_PBS_ONEWAY;
291}
292
293inline SignalType GetSignalType(Tile t, Track track)
294{
296 uint8_t pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;
297 return (SignalType)GB(t.m2(), pos, 3);
298}
299
300inline void SetSignalType(Tile t, Track track, SignalType s)
301{
303 uint8_t pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;
304 SB(t.m2(), pos, 3, s);
305 if (track == INVALID_TRACK) SB(t.m2(), 4, 3, s);
306}
307
308inline bool IsPresignalEntry(Tile t, Track track)
309{
310 return GetSignalType(t, track) == SIGTYPE_ENTRY || GetSignalType(t, track) == SIGTYPE_COMBO;
311}
312
313inline bool IsPresignalExit(Tile t, Track track)
314{
315 return GetSignalType(t, track) == SIGTYPE_EXIT || GetSignalType(t, track) == SIGTYPE_COMBO;
316}
317
319inline bool IsOnewaySignal(Tile t, Track track)
320{
321 return GetSignalType(t, track) != SIGTYPE_PBS;
322}
323
324inline void CycleSignalSide(Tile t, Track track)
325{
326 uint8_t sig;
327 uint8_t pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 6;
328
329 sig = GB(t.m3(), pos, 2);
330 if (--sig == 0) sig = IsPbsSignal(GetSignalType(t, track)) ? 2 : 3;
331 SB(t.m3(), pos, 2, sig);
332}
333
334inline SignalVariant GetSignalVariant(Tile t, Track track)
335{
336 uint8_t pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 7 : 3;
337 return (SignalVariant)GB(t.m2(), pos, 1);
338}
339
340inline void SetSignalVariant(Tile t, Track track, SignalVariant v)
341{
342 uint8_t pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 7 : 3;
343 SB(t.m2(), pos, 1, v);
344 if (track == INVALID_TRACK) SB(t.m2(), 7, 1, v);
345}
346
352inline void SetSignalStates(Tile tile, uint state)
353{
354 SB(tile.m4(), 4, 4, state);
355}
356
362inline uint GetSignalStates(Tile tile)
363{
364 return GB(tile.m4(), 4, 4);
365}
366
373inline SignalState GetSingleSignalState(Tile t, uint8_t signalbit)
374{
375 return (SignalState)HasBit(GetSignalStates(t), signalbit);
376}
377
383inline void SetPresentSignals(Tile tile, uint signals)
384{
385 SB(tile.m3(), 4, 4, signals);
386}
387
393inline uint GetPresentSignals(Tile tile)
394{
395 return GB(tile.m3(), 4, 4);
396}
397
404inline bool IsSignalPresent(Tile t, uint8_t signalbit)
405{
406 return HasBit(GetPresentSignals(t), signalbit);
407}
408
413inline bool HasSignalOnTrack(Tile tile, Track track)
414{
415 assert(IsValidTrack(track));
416 return GetRailTileType(tile) == RAIL_TILE_SIGNALS && (GetPresentSignals(tile) & SignalOnTrack(track)) != 0;
417}
418
426inline bool HasSignalOnTrackdir(Tile tile, Trackdir trackdir)
427{
428 assert (IsValidTrackdir(trackdir));
429 return GetRailTileType(tile) == RAIL_TILE_SIGNALS && GetPresentSignals(tile) & SignalAlongTrackdir(trackdir);
430}
431
439{
440 assert(IsValidTrackdir(trackdir));
441 assert(HasSignalOnTrack(tile, TrackdirToTrack(trackdir)));
442 return GetSignalStates(tile) & SignalAlongTrackdir(trackdir) ?
444}
445
449inline void SetSignalStateByTrackdir(Tile tile, Trackdir trackdir, SignalState state)
450{
451 if (state == SIGNAL_STATE_GREEN) { // set 1
452 SetSignalStates(tile, GetSignalStates(tile) | SignalAlongTrackdir(trackdir));
453 } else {
454 SetSignalStates(tile, GetSignalStates(tile) & ~SignalAlongTrackdir(trackdir));
455 }
456}
457
464{
465 return IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, td) &&
466 IsPbsSignal(GetSignalType(tile, TrackdirToTrack(td)));
467}
468
476{
477 return IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, ReverseTrackdir(td)) &&
478 !HasSignalOnTrackdir(tile, td) && IsOnewaySignal(tile, TrackdirToTrack(td));
479}
480
481
483
502
503inline void SetRailGroundType(Tile t, RailGroundType rgt)
504{
505 SB(t.m4(), 0, 4, rgt);
506}
507
508inline RailGroundType GetRailGroundType(Tile t)
509{
510 return (RailGroundType)GB(t.m4(), 0, 4);
511}
512
513inline bool IsSnowRailGround(Tile t)
514{
515 return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;
516}
517
518
519inline void MakeRailNormal(Tile t, Owner o, TrackBits b, RailType r)
520{
522 SetTileOwner(t, o);
523 SetDockingTile(t, false);
524 t.m2() = 0;
525 t.m3() = 0;
526 t.m4() = 0;
527 t.m5() = RAIL_TILE_NORMAL << 6 | b;
528 SB(t.m6(), 2, 4, 0);
529 t.m7() = 0;
530 t.m8() = r;
531}
532
539{
540 assert(IsRailDepotTile(tile));
541 SB(tile.m5(), 0, 2, dir);
542}
543
552inline void MakeRailDepot(Tile tile, Owner owner, DepotID depot_id, DiagDirection dir, RailType rail_type)
553{
554 SetTileType(tile, MP_RAILWAY);
555 SetTileOwner(tile, owner);
556 SetDockingTile(tile, false);
557 tile.m2() = depot_id;
558 tile.m3() = 0;
559 tile.m4() = 0;
560 tile.m5() = RAIL_TILE_DEPOT << 6 | dir;
561 SB(tile.m6(), 2, 4, 0);
562 tile.m7() = 0;
563 tile.m8() = rail_type;
564}
565
566#endif /* RAIL_MAP_H */
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T AssignBit(T &x, const uint8_t y, bool value)
Assigns a bit in a variable.
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.
debug_inline static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
Wrapper class to abstract away the way the tiles are stored.
Definition map_func.h:25
debug_inline uint16_t & m8()
General purpose.
Definition map_func.h:197
debug_inline uint16_t & m2()
Primarily used for indices to towns, industries and stations.
Definition map_func.h:125
debug_inline uint8_t & m7()
Primarily used for newgrf support.
Definition map_func.h:185
debug_inline uint8_t & m4()
General purpose.
Definition map_func.h:149
debug_inline uint8_t & m6()
General purpose.
Definition map_func.h:173
debug_inline uint8_t & m3()
General purpose.
Definition map_func.h:137
debug_inline uint8_t & m5()
General purpose.
Definition map_func.h:161
Owner
Enum for all companies/owners.
Header files for depots (not hangars)
uint16_t DepotID
Type for the unique identifier of depots.
Definition depot_type.h:13
DiagDirection
Enumeration for diagonal directions.
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
uint GetSignalStates(Tile tile)
Set the states of the signals (Along/AgainstTrackDir)
Definition rail_map.h:362
void MakeRailDepot(Tile tile, Owner owner, DepotID depot_id, DiagDirection dir, RailType rail_type)
Make a rail depot.
Definition rail_map.h:552
RailType GetRailType(Tile t)
Gets the rail type of the given tile.
Definition rail_map.h:115
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 RailTileType GetRailTileType(Tile t)
Returns the RailTileType (normal with or without signals, waypoint or depot).
Definition rail_map.h:36
TrackBits GetTrackBits(Tile tile)
Gets the track bits of the given tile.
Definition rail_map.h:136
static debug_inline bool IsRailDepotTile(Tile t)
Is this tile rail tile and a rail depot?
Definition rail_map.h:105
RailGroundType
The ground 'under' the rail.
Definition rail_map.h:485
@ RAIL_GROUND_FENCE_HORIZ1
Grass with a fence at the southern side.
Definition rail_map.h:496
@ RAIL_GROUND_FENCE_VERT1
Grass with a fence at the eastern side.
Definition rail_map.h:494
@ RAIL_GROUND_ICE_DESERT
Icy or sandy.
Definition rail_map.h:498
@ RAIL_GROUND_FENCE_NE
Grass with a fence at the NE edge.
Definition rail_map.h:491
@ RAIL_GROUND_FENCE_NESW
Grass with a fence at the NE and SW edges.
Definition rail_map.h:493
@ RAIL_GROUND_FENCE_HORIZ2
Grass with a fence at the northern side.
Definition rail_map.h:497
@ RAIL_GROUND_FENCE_SW
Grass with a fence at the SW edge.
Definition rail_map.h:492
@ RAIL_GROUND_FENCE_NW
Grass with a fence at the NW edge.
Definition rail_map.h:488
@ RAIL_GROUND_WATER
Grass with a fence and shore or water on the free halftile.
Definition rail_map.h:499
@ RAIL_GROUND_BARREN
Nothing (dirt)
Definition rail_map.h:486
@ RAIL_GROUND_FENCE_VERT2
Grass with a fence at the western side.
Definition rail_map.h:495
@ RAIL_GROUND_GRASS
Grassy.
Definition rail_map.h:487
@ RAIL_GROUND_HALF_SNOW
Snow only on higher part of slope (steep or one corner raised)
Definition rail_map.h:500
@ RAIL_GROUND_FENCE_SENW
Grass with a fence at the NW and SE edges.
Definition rail_map.h:490
@ RAIL_GROUND_FENCE_SE
Grass with a fence at the SE edge.
Definition rail_map.h:489
Track GetRailDepotTrack(Tile t)
Returns the track of a depot, ignoring direction.
Definition rail_map.h:182
void SetTrackReservation(Tile t, TrackBits b)
Sets the reserved track bits of the tile.
Definition rail_map.h:209
bool IsSignalPresent(Tile t, uint8_t signalbit)
Checks whether the given signals is present.
Definition rail_map.h:404
DiagDirection GetRailDepotDirection(Tile t)
Returns the direction the depot is facing to.
Definition rail_map.h:171
void SetTrackBits(Tile t, TrackBits b)
Sets the track bits of the given tile.
Definition rail_map.h:147
void SetSignalStateByTrackdir(Tile tile, Trackdir trackdir, SignalState state)
Sets the state of the signal along the given trackdir.
Definition rail_map.h:449
uint GetPresentSignals(Tile tile)
Get whether the given signals are present (Along/AgainstTrackDir)
Definition rail_map.h:393
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:413
bool HasPbsSignalOnTrackdir(Tile tile, Trackdir td)
Is a pbs signal present along the trackdir?
Definition rail_map.h:463
bool IsOnewaySignal(Tile t, Track track)
One-way signals can't be passed the 'wrong' way.
Definition rail_map.h:319
void SetPresentSignals(Tile tile, uint signals)
Set whether the given signals are present (Along/AgainstTrackDir)
Definition rail_map.h:383
static debug_inline bool IsRailDepot(Tile t)
Is this rail tile a rail depot?
Definition rail_map.h:95
void SetRailDepotExitDirection(Tile tile, DiagDirection dir)
Sets the exit direction of a rail depot.
Definition rail_map.h:538
void UnreserveTrack(Tile tile, Track t)
Lift the reservation of a specific track on a tile.
Definition rail_map.h:244
RailType GetTileRailType(Tile tile)
Return the rail type of tile, or INVALID_RAILTYPE if this is no rail tile.
Definition rail.cpp:155
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
void SetHasSignals(Tile tile, bool signals)
Add/remove the 'has signal' bit from the RailTileType.
Definition rail_map.h:83
bool TryReserveTrack(Tile tile, Track t)
Try to reserve a specific track on a tile.
Definition rail_map.h:226
RailTileType
Different types of Rail-related tiles.
Definition rail_map.h:23
@ RAIL_TILE_DEPOT
Depot (one entrance)
Definition rail_map.h:26
@ RAIL_TILE_NORMAL
Normal rail tile without signals.
Definition rail_map.h:24
@ RAIL_TILE_SIGNALS
Normal rail tile with signals.
Definition rail_map.h:25
bool HasSignals(Tile t)
Checks if a rail tile has signals.
Definition rail_map.h:72
static debug_inline bool IsPlainRailTile(Tile t)
Checks whether the tile is a rail tile or rail tile with signals.
Definition rail_map.h:60
SignalState GetSignalStateByTrackdir(Tile tile, Trackdir trackdir)
Gets the state of the signal along the given trackdir.
Definition rail_map.h:438
bool HasTrack(Tile tile, Track track)
Returns whether the given track is present on the given tile.
Definition rail_map.h:160
SignalState GetSingleSignalState(Tile t, uint8_t signalbit)
Get the state of a single signal.
Definition rail_map.h:373
void SetSignalStates(Tile tile, uint state)
Set the states of the signals (Along/AgainstTrackDir)
Definition rail_map.h:352
void SetRailType(Tile t, RailType r)
Sets the rail type of the given tile.
Definition rail_map.h:125
The different types of rail.
RailType
Enumeration for all possible railtypes.
Definition rail_type.h:27
Functions related to signals.
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
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
Types and classes related to signals.
SignalType
Type of signal, i.e.
Definition signal_type.h:23
@ SIGTYPE_PBS_ONEWAY
no-entry signal
Definition signal_type.h:29
@ SIGTYPE_PBS
normal pbs signal
Definition signal_type.h:28
@ SIGTYPE_ENTRY
presignal block entry
Definition signal_type.h:25
@ SIGTYPE_COMBO
presignal inter-block
Definition signal_type.h:27
@ SIGTYPE_EXIT
presignal block exit
Definition signal_type.h:26
SignalState
These are states in which a signal can be.
Definition signal_type.h:42
@ SIGNAL_STATE_RED
The signal is red.
Definition signal_type.h:43
@ SIGNAL_STATE_GREEN
The signal is green.
Definition signal_type.h:44
SignalVariant
Variant of the signal, i.e.
Definition signal_type.h:16
Map writing/reading functions for tiles.
void SetTileType(Tile tile, TileType type)
Set the type of a tile.
Definition tile_map.h:131
void SetTileOwner(Tile tile, Owner owner)
Sets the owner of a tile.
Definition tile_map.h:198
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
@ MP_RAILWAY
A railway.
Definition tile_type.h:49
Different conversion functions from one kind of track to another.
Track TrackdirToTrack(Trackdir trackdir)
Returns the Track that a given Trackdir represents.
Definition track_func.h:262
Track TrackToOppositeTrack(Track t)
Find the opposite track to a given track.
Definition track_func.h:231
TrackBits TrackToTrackBits(Track track)
Maps a Track to the corresponding TrackBits value.
Definition track_func.h:77
Trackdir ReverseTrackdir(Trackdir trackdir)
Maps a trackdir to the reverse trackdir.
Definition track_func.h:247
bool TracksOverlap(TrackBits bits)
Checks if the given tracks overlap, ie form a crossing.
Definition track_func.h:645
bool IsValidTrackdir(Trackdir trackdir)
Checks if a Trackdir is valid for non-road vehicles.
Definition track_func.h:52
bool IsValidTrack(Track track)
Checks if a Track is valid.
Definition track_func.h:28
Track RemoveFirstTrack(TrackBits *tracks)
Removes first Track from TrackBits and returns it.
Definition track_func.h:131
Track DiagDirToDiagTrack(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal track incidating with that diagdir.
Definition track_func.h:512
TrackBits
Allow incrementing of Track variables.
Definition track_type.h:35
@ INVALID_TRACK_BIT
Flag for an invalid trackbits value.
Definition track_type.h:54
@ TRACK_BIT_NONE
No track.
Definition track_type.h:36
Trackdir
Enumeration for tracks and directions.
Definition track_type.h:67
Track
These are used to specify a single track.
Definition track_type.h:19
@ INVALID_TRACK
Flag for an invalid track.
Definition track_type.h:28
@ TRACK_LOWER
Track in the lower corner of the tile (south)
Definition track_type.h:24
@ TRACK_RIGHT
Track in the right corner of the tile (east)
Definition track_type.h:26
Map accessors for water tiles.
void SetDockingTile(Tile t, bool b)
Set the docking tile state of a tile.
Definition water_map.h:361