2006-03-01 08:56:38 +00:00
|
|
|
/* $Id$ */
|
|
|
|
|
2007-03-28 20:41:35 +00:00
|
|
|
/** @file rail_map.h Hides the direct accesses to the map array with map accessors */
|
|
|
|
|
2006-03-01 08:56:38 +00:00
|
|
|
#ifndef RAIL_MAP_H
|
|
|
|
#define RAIL_MAP_H
|
|
|
|
|
2006-03-17 07:02:34 +00:00
|
|
|
#include "direction.h"
|
2006-06-18 15:28:29 +00:00
|
|
|
#include "rail.h"
|
2006-03-01 08:56:38 +00:00
|
|
|
#include "tile.h"
|
2006-03-17 07:02:34 +00:00
|
|
|
|
|
|
|
|
2007-03-07 12:11:48 +00:00
|
|
|
enum RailTileType {
|
2007-02-27 23:36:28 +00:00
|
|
|
RAIL_TILE_NORMAL = 0,
|
|
|
|
RAIL_TILE_SIGNALS = 1,
|
|
|
|
RAIL_TILE_WAYPOINT = 2,
|
|
|
|
RAIL_TILE_DEPOT = 3,
|
2007-03-07 12:11:48 +00:00
|
|
|
};
|
2006-03-17 07:02:34 +00:00
|
|
|
|
|
|
|
static inline RailTileType GetRailTileType(TileIndex t)
|
|
|
|
{
|
|
|
|
assert(IsTileType(t, MP_RAILWAY));
|
2007-02-27 23:36:28 +00:00
|
|
|
return (RailTileType)GB(_m[t].m5, 6, 2);
|
2006-03-17 07:02:34 +00:00
|
|
|
}
|
|
|
|
|
2006-05-07 07:01:48 +00:00
|
|
|
/**
|
|
|
|
* Returns whether this is plain rails, with or without signals. Iow, if this
|
2006-05-09 08:17:33 +00:00
|
|
|
* tiles RailTileType is RAIL_TILE_NORMAL or RAIL_TILE_SIGNALS.
|
2006-05-07 07:01:48 +00:00
|
|
|
*/
|
|
|
|
static inline bool IsPlainRailTile(TileIndex tile)
|
|
|
|
{
|
|
|
|
RailTileType rtt = GetRailTileType(tile);
|
2006-05-09 08:17:33 +00:00
|
|
|
return rtt == RAIL_TILE_NORMAL || rtt == RAIL_TILE_SIGNALS;
|
2006-05-07 07:01:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks if a rail tile has signals.
|
|
|
|
*/
|
|
|
|
static inline bool HasSignals(TileIndex tile)
|
|
|
|
{
|
2006-05-09 08:17:33 +00:00
|
|
|
return GetRailTileType(tile) == RAIL_TILE_SIGNALS;
|
2006-05-07 07:01:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-02-27 23:36:28 +00:00
|
|
|
* Add/remove the 'has signal' bit from the RailTileType
|
2006-05-07 07:01:48 +00:00
|
|
|
*/
|
2007-02-27 23:36:28 +00:00
|
|
|
static inline void SetHasSignals(TileIndex tile, bool signals)
|
2006-05-07 07:01:48 +00:00
|
|
|
{
|
2007-02-27 23:36:28 +00:00
|
|
|
assert(IsPlainRailTile(tile));
|
|
|
|
SB(_m[tile].m5, 6, 1, signals);
|
2006-05-07 07:01:48 +00:00
|
|
|
}
|
|
|
|
|
2006-03-17 07:02:34 +00:00
|
|
|
|
2006-07-27 05:30:53 +00:00
|
|
|
static inline bool IsRailDepot(TileIndex t)
|
|
|
|
{
|
2007-02-27 23:36:28 +00:00
|
|
|
return GetRailTileType(t) == RAIL_TILE_DEPOT;
|
2006-07-27 05:30:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-19 09:15:16 +00:00
|
|
|
static inline bool IsRailWaypoint(TileIndex t)
|
|
|
|
{
|
2007-02-27 23:36:28 +00:00
|
|
|
return GetRailTileType(t) == RAIL_TILE_WAYPOINT;
|
2006-06-19 09:15:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-03-17 07:02:34 +00:00
|
|
|
static inline RailType GetRailType(TileIndex t)
|
|
|
|
{
|
|
|
|
return (RailType)GB(_m[t].m3, 0, 4);
|
|
|
|
}
|
|
|
|
|
2006-03-17 10:10:31 +00:00
|
|
|
static inline void SetRailType(TileIndex t, RailType r)
|
|
|
|
{
|
|
|
|
SB(_m[t].m3, 0, 4, r);
|
|
|
|
}
|
|
|
|
|
2006-03-17 07:02:34 +00:00
|
|
|
|
2006-03-19 12:06:12 +00:00
|
|
|
static inline TrackBits GetTrackBits(TileIndex tile)
|
|
|
|
{
|
|
|
|
return (TrackBits)GB(_m[tile].m5, 0, 6);
|
|
|
|
}
|
|
|
|
|
2006-03-19 17:52:02 +00:00
|
|
|
static inline void SetTrackBits(TileIndex t, TrackBits b)
|
|
|
|
{
|
|
|
|
SB(_m[t].m5, 0, 6, b);
|
|
|
|
}
|
|
|
|
|
2006-05-07 07:01:48 +00:00
|
|
|
/**
|
|
|
|
* Returns whether the given track is present on the given tile. Tile must be
|
|
|
|
* a plain rail tile (IsPlainRailTile()).
|
|
|
|
*/
|
|
|
|
static inline bool HasTrack(TileIndex tile, Track track)
|
|
|
|
{
|
|
|
|
return HASBIT(GetTrackBits(tile), track);
|
|
|
|
}
|
|
|
|
|
2006-03-01 08:56:38 +00:00
|
|
|
|
2006-03-12 16:13:16 +00:00
|
|
|
static inline DiagDirection GetRailDepotDirection(TileIndex t)
|
|
|
|
{
|
|
|
|
return (DiagDirection)GB(_m[t].m5, 0, 2);
|
|
|
|
}
|
|
|
|
|
2006-07-22 08:59:52 +00:00
|
|
|
|
|
|
|
static inline Axis GetWaypointAxis(TileIndex t)
|
2006-04-05 05:22:42 +00:00
|
|
|
{
|
2006-08-31 08:16:28 +00:00
|
|
|
return (Axis)GB(_m[t].m5, 0, 1);
|
2006-04-05 05:22:42 +00:00
|
|
|
}
|
2006-03-12 16:13:16 +00:00
|
|
|
|
2006-07-22 08:59:52 +00:00
|
|
|
static inline Track GetRailWaypointTrack(TileIndex t)
|
2006-03-01 08:56:38 +00:00
|
|
|
{
|
2006-07-22 08:59:52 +00:00
|
|
|
return AxisToTrack(GetWaypointAxis(t));
|
2006-03-17 06:26:37 +00:00
|
|
|
}
|
|
|
|
|
2006-07-22 08:59:52 +00:00
|
|
|
static inline TrackBits GetRailWaypointBits(TileIndex t)
|
2006-04-12 12:50:40 +00:00
|
|
|
{
|
2006-07-22 08:59:52 +00:00
|
|
|
return TrackToTrackBits(GetRailWaypointTrack(t));
|
2006-04-12 12:50:40 +00:00
|
|
|
}
|
|
|
|
|
2007-03-01 13:35:40 +00:00
|
|
|
static inline WaypointID GetWaypointIndex(TileIndex t)
|
|
|
|
{
|
|
|
|
return (WaypointID)_m[t].m2;
|
|
|
|
}
|
2006-03-17 06:26:37 +00:00
|
|
|
|
2007-03-07 12:11:48 +00:00
|
|
|
enum SignalType {
|
2006-03-17 06:26:37 +00:00
|
|
|
SIGTYPE_NORMAL = 0, // normal signal
|
|
|
|
SIGTYPE_ENTRY = 1, // presignal block entry
|
|
|
|
SIGTYPE_EXIT = 2, // presignal block exit
|
|
|
|
SIGTYPE_COMBO = 3 // presignal inter-block
|
2007-03-07 12:11:48 +00:00
|
|
|
};
|
2006-03-17 06:26:37 +00:00
|
|
|
|
|
|
|
static inline SignalType GetSignalType(TileIndex t)
|
|
|
|
{
|
2006-05-09 08:17:33 +00:00
|
|
|
assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
|
2007-02-27 23:36:28 +00:00
|
|
|
return (SignalType)GB(_m[t].m2, 0, 2);
|
2006-03-17 06:26:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void SetSignalType(TileIndex t, SignalType s)
|
|
|
|
{
|
2006-05-09 08:17:33 +00:00
|
|
|
assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
|
2007-02-27 23:36:28 +00:00
|
|
|
SB(_m[t].m2, 0, 2, s);
|
2006-04-12 09:12:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool IsPresignalEntry(TileIndex t)
|
|
|
|
{
|
|
|
|
return GetSignalType(t) == SIGTYPE_ENTRY || GetSignalType(t) == SIGTYPE_COMBO;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool IsPresignalExit(TileIndex t)
|
|
|
|
{
|
|
|
|
return GetSignalType(t) == SIGTYPE_EXIT || GetSignalType(t) == SIGTYPE_COMBO;
|
2006-04-12 09:36:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void CycleSignalSide(TileIndex t, Track track)
|
|
|
|
{
|
|
|
|
byte sig;
|
|
|
|
byte pos = 6;
|
|
|
|
if (track == TRACK_LOWER || track == TRACK_RIGHT) pos = 4;
|
|
|
|
|
|
|
|
sig = GB(_m[t].m3, pos, 2);
|
|
|
|
if (--sig == 0) sig = 3;
|
|
|
|
SB(_m[t].m3, pos, 2, sig);
|
2006-03-01 08:56:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-03-07 12:11:48 +00:00
|
|
|
enum SignalVariant {
|
2006-03-16 21:44:58 +00:00
|
|
|
SIG_ELECTRIC = 0,
|
|
|
|
SIG_SEMAPHORE = 1
|
2007-03-07 12:11:48 +00:00
|
|
|
};
|
2006-03-16 21:44:58 +00:00
|
|
|
|
|
|
|
static inline SignalVariant GetSignalVariant(TileIndex t)
|
|
|
|
{
|
2007-02-27 23:36:28 +00:00
|
|
|
return (SignalVariant)GB(_m[t].m2, 2, 1);
|
2006-03-16 21:44:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void SetSignalVariant(TileIndex t, SignalVariant v)
|
|
|
|
{
|
2007-02-27 23:36:28 +00:00
|
|
|
SB(_m[t].m2, 2, 1, v);
|
2006-03-16 21:44:58 +00:00
|
|
|
}
|
|
|
|
|
2006-04-17 19:09:30 +00:00
|
|
|
static inline bool IsSignalPresent(TileIndex t, byte signalbit)
|
|
|
|
{
|
|
|
|
return HASBIT(_m[t].m3, signalbit + 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** These are states in which a signal can be. Currently these are only two, so
|
|
|
|
* simple boolean logic will do. But do try to compare to this enum instead of
|
|
|
|
* normal boolean evaluation, since that will make future additions easier.
|
|
|
|
*/
|
2007-03-07 12:11:48 +00:00
|
|
|
enum SignalState {
|
2006-08-22 14:38:37 +00:00
|
|
|
SIGNAL_STATE_RED = 0,
|
2006-04-17 19:09:30 +00:00
|
|
|
SIGNAL_STATE_GREEN = 1,
|
2007-03-07 12:11:48 +00:00
|
|
|
};
|
2006-04-17 19:09:30 +00:00
|
|
|
|
|
|
|
static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)
|
|
|
|
{
|
2006-05-27 16:12:16 +00:00
|
|
|
return (SignalState)HASBIT(_m[t].m2, signalbit + 4);
|
2006-04-17 19:09:30 +00:00
|
|
|
}
|
|
|
|
|
2006-03-16 21:44:58 +00:00
|
|
|
|
2006-06-18 15:28:29 +00:00
|
|
|
/**
|
|
|
|
* Checks for the presence of signals (either way) on the given track on the
|
|
|
|
* given rail tile.
|
|
|
|
*/
|
|
|
|
static inline bool HasSignalOnTrack(TileIndex tile, Track track)
|
|
|
|
{
|
|
|
|
assert(IsValidTrack(track));
|
|
|
|
return
|
|
|
|
GetRailTileType(tile) == RAIL_TILE_SIGNALS &&
|
|
|
|
(_m[tile].m3 & SignalOnTrack(track)) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks for the presence of signals along the given trackdir on the given
|
|
|
|
* rail tile.
|
|
|
|
*
|
|
|
|
* Along meaning if you are currently driving on the given trackdir, this is
|
|
|
|
* the signal that is facing us (for which we stop when it's red).
|
|
|
|
*/
|
|
|
|
static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)
|
|
|
|
{
|
|
|
|
assert (IsValidTrackdir(trackdir));
|
|
|
|
return
|
|
|
|
GetRailTileType(tile) == RAIL_TILE_SIGNALS &&
|
|
|
|
_m[tile].m3 & SignalAlongTrackdir(trackdir);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets the state of the signal along the given trackdir.
|
|
|
|
*
|
|
|
|
* Along meaning if you are currently driving on the given trackdir, this is
|
|
|
|
* the signal that is facing us (for which we stop when it's red).
|
|
|
|
*/
|
|
|
|
static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)
|
|
|
|
{
|
|
|
|
assert(IsValidTrackdir(trackdir));
|
|
|
|
assert(HasSignalOnTrack(tile, TrackdirToTrack(trackdir)));
|
|
|
|
return _m[tile].m2 & SignalAlongTrackdir(trackdir) ?
|
|
|
|
SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the rail type of tile, or INVALID_RAILTYPE if this is no rail tile.
|
|
|
|
*/
|
2007-02-25 11:36:19 +00:00
|
|
|
RailType GetTileRailType(TileIndex tile);
|
2006-06-18 15:28:29 +00:00
|
|
|
|
|
|
|
|
2007-03-07 12:11:48 +00:00
|
|
|
enum RailGroundType {
|
2006-08-22 14:38:37 +00:00
|
|
|
RAIL_GROUND_BARREN = 0,
|
|
|
|
RAIL_GROUND_GRASS = 1,
|
|
|
|
RAIL_GROUND_FENCE_NW = 2,
|
|
|
|
RAIL_GROUND_FENCE_SE = 3,
|
|
|
|
RAIL_GROUND_FENCE_SENW = 4,
|
|
|
|
RAIL_GROUND_FENCE_NE = 5,
|
|
|
|
RAIL_GROUND_FENCE_SW = 6,
|
|
|
|
RAIL_GROUND_FENCE_NESW = 7,
|
|
|
|
RAIL_GROUND_FENCE_VERT1 = 8,
|
|
|
|
RAIL_GROUND_FENCE_VERT2 = 9,
|
2006-04-12 11:58:07 +00:00
|
|
|
RAIL_GROUND_FENCE_HORIZ1 = 10,
|
|
|
|
RAIL_GROUND_FENCE_HORIZ2 = 11,
|
2006-08-22 14:38:37 +00:00
|
|
|
RAIL_GROUND_ICE_DESERT = 12,
|
2007-03-07 12:11:48 +00:00
|
|
|
};
|
2006-04-12 11:58:07 +00:00
|
|
|
|
|
|
|
static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)
|
|
|
|
{
|
2007-02-27 23:36:28 +00:00
|
|
|
SB(_m[t].m4, 0, 4, rgt);
|
2006-04-12 11:58:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline RailGroundType GetRailGroundType(TileIndex t)
|
|
|
|
{
|
2007-02-27 23:36:28 +00:00
|
|
|
return (RailGroundType)GB(_m[t].m4, 0, 4);
|
2006-04-12 11:58:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool IsSnowRailGround(TileIndex t)
|
|
|
|
{
|
|
|
|
return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-03-01 08:56:38 +00:00
|
|
|
static inline void MakeRailNormal(TileIndex t, Owner o, TrackBits b, RailType r)
|
|
|
|
{
|
|
|
|
SetTileType(t, MP_RAILWAY);
|
|
|
|
SetTileOwner(t, o);
|
|
|
|
_m[t].m2 = 0;
|
|
|
|
_m[t].m3 = r;
|
|
|
|
_m[t].m4 = 0;
|
2007-02-27 23:36:28 +00:00
|
|
|
_m[t].m5 = RAIL_TILE_NORMAL << 6 | b;
|
2006-03-01 08:56:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline void MakeRailDepot(TileIndex t, Owner o, DiagDirection d, RailType r)
|
|
|
|
{
|
|
|
|
SetTileType(t, MP_RAILWAY);
|
|
|
|
SetTileOwner(t, o);
|
|
|
|
_m[t].m2 = 0;
|
|
|
|
_m[t].m3 = r;
|
|
|
|
_m[t].m4 = 0;
|
2007-02-27 23:36:28 +00:00
|
|
|
_m[t].m5 = RAIL_TILE_DEPOT << 6 | d;
|
2006-03-01 08:56:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline void MakeRailWaypoint(TileIndex t, Owner o, Axis a, RailType r, uint index)
|
|
|
|
{
|
|
|
|
SetTileType(t, MP_RAILWAY);
|
|
|
|
SetTileOwner(t, o);
|
|
|
|
_m[t].m2 = index;
|
|
|
|
_m[t].m3 = r;
|
|
|
|
_m[t].m4 = 0;
|
2007-02-27 23:36:28 +00:00
|
|
|
_m[t].m5 = RAIL_TILE_WAYPOINT << 6 | a;
|
2006-03-01 08:56:38 +00:00
|
|
|
}
|
|
|
|
|
2006-09-28 18:42:35 +00:00
|
|
|
#endif /* RAIL_MAP_H */
|