tron@3101: /* $Id$ */
tron@3101: 
tron@3101: #ifndef RAIL_MAP_H
tron@3101: #define RAIL_MAP_H
tron@3101: 
tron@3239: #include "direction.h"
tron@4041: #include "rail.h"
tron@3101: #include "tile.h"
tron@3239: 
tron@3239: 
tron@3239: typedef enum RailTileType {
rubidium@3792: 	RAIL_TILE_NORMAL         = 0x0,
rubidium@3792: 	RAIL_TILE_SIGNALS        = 0x40,
rubidium@3792: 	RAIL_TILE_UNUSED         = 0x80, /* XXX: Maybe this could become waypoints? */
rubidium@3792: 	RAIL_TILE_DEPOT_WAYPOINT = 0xC0, /* Is really depots and waypoints... */
tron@3239: 	RAIL_TILE_TYPE_MASK      = 0xC0
tron@3239: } RailTileType;
tron@3239: 
tron@3239: static inline RailTileType GetRailTileType(TileIndex t)
tron@3239: {
celestar@5598: 	assert(IsTileType(t, MP_RAILWAY) || IsTileType(t, MP_RAILWAY_BRIDGE));
KUDr@3900: 	return (RailTileType)(_m[t].m5 & RAIL_TILE_TYPE_MASK);
tron@3239: }
tron@3239: 
tron@3772: /**
tron@3772:  * Returns whether this is plain rails, with or without signals. Iow, if this
rubidium@3792:  * tiles RailTileType is RAIL_TILE_NORMAL or RAIL_TILE_SIGNALS.
tron@3772:  */
tron@3772: static inline bool IsPlainRailTile(TileIndex tile)
tron@3772: {
tron@3772: 	RailTileType rtt = GetRailTileType(tile);
rubidium@3792: 	return rtt == RAIL_TILE_NORMAL || rtt == RAIL_TILE_SIGNALS;
tron@3772: }
tron@3772: 
tron@3772: /**
tron@3772:  * Checks if a rail tile has signals.
tron@3772:  */
tron@3772: static inline bool HasSignals(TileIndex tile)
tron@3772: {
rubidium@3792: 	return GetRailTileType(tile) == RAIL_TILE_SIGNALS;
tron@3772: }
tron@3772: 
tron@3239: 
tron@3239: /** These specify the subtype when the main rail type is
rubidium@3792:  * RAIL_TILE_DEPOT_WAYPOINT */
tron@3239: typedef enum RailTileSubtypes {
tron@3239: 	RAIL_SUBTYPE_DEPOT    = 0x00,
tron@3239: 	RAIL_SUBTYPE_WAYPOINT = 0x04,
tron@3239: 	RAIL_SUBTYPE_MASK     = 0x3C
tron@3239: } RailTileSubtype;
tron@3239: 
tron@3772: /**
tron@3772:  * Returns the RailTileSubtype of a given rail tile with type
rubidium@3792:  * RAIL_TILE_DEPOT_WAYPOINT
tron@3772:  */
tron@3772: static inline RailTileSubtype GetRailTileSubtype(TileIndex tile)
tron@3772: {
rubidium@3792: 	assert(GetRailTileType(tile) == RAIL_TILE_DEPOT_WAYPOINT);
tron@3772: 	return (RailTileSubtype)(_m[tile].m5 & RAIL_SUBTYPE_MASK);
tron@3772: }
tron@3772: 
tron@3239: 
tron@4182: static inline bool IsRailDepot(TileIndex t)
tron@4182: {
tron@4182: 	return
tron@4182: 		GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT &&
tron@4182: 		GetRailTileSubtype(t) == RAIL_SUBTYPE_DEPOT;
tron@4182: }
tron@4182: 
tron@4182: 
tron@4044: static inline bool IsRailWaypoint(TileIndex t)
tron@4044: {
tron@4044: 	return
tron@4044: 		GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT &&
tron@4044: 		GetRailTileSubtype(t) == RAIL_SUBTYPE_WAYPOINT;
tron@4044: }
tron@4044: 
tron@4044: 
tron@3239: static inline RailType GetRailType(TileIndex t)
tron@3239: {
tron@3239: 	return (RailType)GB(_m[t].m3, 0, 4);
tron@3239: }
tron@3239: 
tron@3242: // TODO remove this by moving to the same bits as GetRailType()
tron@3242: static inline RailType GetRailTypeCrossing(TileIndex t)
tron@3242: {
tron@3242: 	return (RailType)GB(_m[t].m4, 0, 4);
tron@3242: }
tron@3242: 
tron@3242: static inline void SetRailType(TileIndex t, RailType r)
tron@3242: {
tron@3242: 	SB(_m[t].m3, 0, 4, r);
tron@3242: }
tron@3242: 
tron@3242: // TODO remove this by moving to the same bits as SetRailType()
tron@3242: static inline void SetRailTypeCrossing(TileIndex t, RailType r)
tron@3242: {
tron@3242: 	SB(_m[t].m4, 0, 4, r);
tron@3242: }
tron@3242: 
tron@3239: 
tron@3267: static inline TrackBits GetTrackBits(TileIndex tile)
tron@3267: {
tron@3267: 	return (TrackBits)GB(_m[tile].m5, 0, 6);
tron@3267: }
tron@3267: 
tron@3273: static inline void SetTrackBits(TileIndex t, TrackBits b)
tron@3273: {
tron@3273: 	SB(_m[t].m5, 0, 6, b);
tron@3273: }
tron@3273: 
tron@3772: /**
tron@3772:  * Returns whether the given track is present on the given tile. Tile must be
tron@3772:  * a plain rail tile (IsPlainRailTile()).
tron@3772:  */
tron@3772: static inline bool HasTrack(TileIndex tile, Track track)
tron@3772: {
tron@3772: 	return HASBIT(GetTrackBits(tile), track);
tron@3772: }
tron@3772: 
tron@3101: 
tron@3185: static inline DiagDirection GetRailDepotDirection(TileIndex t)
tron@3185: {
tron@3185: 	return (DiagDirection)GB(_m[t].m5, 0, 2);
tron@3185: }
tron@3185: 
tron@4158: 
tron@4158: static inline Axis GetWaypointAxis(TileIndex t)
tron@4158: {
tron@4474: 	return (Axis)GB(_m[t].m5, 0, 1);
tron@4158: }
tron@4158: 
celestar@3453: static inline Track GetRailWaypointTrack(TileIndex t)
celestar@3448: {
tron@4158: 	return AxisToTrack(GetWaypointAxis(t));
celestar@3448: }
tron@3185: 
tron@3101: static inline TrackBits GetRailWaypointBits(TileIndex t)
tron@3101: {
tron@4158: 	return TrackToTrackBits(GetRailWaypointTrack(t));
celestar@3528: }
celestar@3528: 
tron@3101: 
tron@3238: typedef enum SignalType {
tron@3238: 	SIGTYPE_NORMAL  = 0, // normal signal
tron@3238: 	SIGTYPE_ENTRY   = 1, // presignal block entry
tron@3238: 	SIGTYPE_EXIT    = 2, // presignal block exit
tron@3238: 	SIGTYPE_COMBO   = 3  // presignal inter-block
tron@3238: } SignalType;
tron@3238: 
tron@3238: static inline SignalType GetSignalType(TileIndex t)
tron@3238: {
rubidium@3792: 	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
tron@3238: 	return (SignalType)GB(_m[t].m4, 0, 2);
tron@3238: }
tron@3238: 
tron@3238: static inline void SetSignalType(TileIndex t, SignalType s)
tron@3238: {
rubidium@3792: 	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
tron@3238: 	SB(_m[t].m4, 0, 2, s);
tron@3238: }
tron@3238: 
celestar@3521: static inline bool IsPresignalEntry(TileIndex t)
celestar@3521: {
celestar@3521: 	return GetSignalType(t) == SIGTYPE_ENTRY || GetSignalType(t) == SIGTYPE_COMBO;
celestar@3521: }
celestar@3521: 
celestar@3521: static inline bool IsPresignalExit(TileIndex t)
celestar@3521: {
celestar@3521: 	return GetSignalType(t) == SIGTYPE_EXIT || GetSignalType(t) == SIGTYPE_COMBO;
celestar@3521: }
celestar@3521: 
celestar@3522: static inline void CycleSignalSide(TileIndex t, Track track)
celestar@3522: {
celestar@3522: 	byte sig;
celestar@3522: 	byte pos = 6;
celestar@3522: 	if (track == TRACK_LOWER || track == TRACK_RIGHT) pos = 4;
celestar@3522: 
celestar@3522: 	sig = GB(_m[t].m3, pos, 2);
celestar@3522: 	if (--sig == 0) sig = 3;
celestar@3522: 	SB(_m[t].m3, pos, 2, sig);
celestar@3522: }
celestar@3522: 
tron@3238: 
tron@3237: typedef enum SignalVariant {
tron@3237: 	SIG_ELECTRIC  = 0,
tron@3237: 	SIG_SEMAPHORE = 1
tron@3237: } SignalVariant;
tron@3237: 
tron@3237: static inline SignalVariant GetSignalVariant(TileIndex t)
tron@3237: {
tron@3237: 	return (SignalVariant)GB(_m[t].m4, 2, 1);
tron@3237: }
tron@3237: 
tron@3237: static inline void SetSignalVariant(TileIndex t, SignalVariant v)
tron@3237: {
tron@3237: 	SB(_m[t].m4, 2, 1, v);
tron@3237: }
tron@3237: 
celestar@3575: static inline bool IsSignalPresent(TileIndex t, byte signalbit)
celestar@3575: {
celestar@3575: 	return HASBIT(_m[t].m3, signalbit + 4);
celestar@3575: }
celestar@3575: 
celestar@3575: /** These are states in which a signal can be. Currently these are only two, so
celestar@3575:  * simple boolean logic will do. But do try to compare to this enum instead of
celestar@3575:  * normal boolean evaluation, since that will make future additions easier.
celestar@3575:  */
celestar@3575: typedef enum SignalStates {
rubidium@4344: 	SIGNAL_STATE_RED   = 0,
celestar@3575: 	SIGNAL_STATE_GREEN = 1,
celestar@3575: } SignalState;
celestar@3575: 
celestar@3575: static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)
celestar@3575: {
KUDr@3900: 	return (SignalState)HASBIT(_m[t].m2, signalbit + 4);
celestar@3575: }
celestar@3575: 
tron@3237: 
tron@4041: /**
tron@4041:  * Checks for the presence of signals (either way) on the given track on the
tron@4041:  * given rail tile.
tron@4041:  */
tron@4041: static inline bool HasSignalOnTrack(TileIndex tile, Track track)
tron@4041: {
tron@4041: 	assert(IsValidTrack(track));
tron@4041: 	return
tron@4041: 		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&
tron@4041: 		(_m[tile].m3 & SignalOnTrack(track)) != 0;
tron@4041: }
tron@4041: 
tron@4041: /**
tron@4041:  * Checks for the presence of signals along the given trackdir on the given
tron@4041:  * rail tile.
tron@4041:  *
tron@4041:  * Along meaning if you are currently driving on the given trackdir, this is
tron@4041:  * the signal that is facing us (for which we stop when it's red).
tron@4041:  */
tron@4041: static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)
tron@4041: {
tron@4041: 	assert (IsValidTrackdir(trackdir));
tron@4041: 	return
tron@4041: 		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&
tron@4041: 		_m[tile].m3 & SignalAlongTrackdir(trackdir);
tron@4041: }
tron@4041: 
tron@4041: /**
tron@4041:  * Gets the state of the signal along the given trackdir.
tron@4041:  *
tron@4041:  * Along meaning if you are currently driving on the given trackdir, this is
tron@4041:  * the signal that is facing us (for which we stop when it's red).
tron@4041:  */
tron@4041: static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)
tron@4041: {
tron@4041: 	assert(IsValidTrackdir(trackdir));
tron@4041: 	assert(HasSignalOnTrack(tile, TrackdirToTrack(trackdir)));
tron@4041: 	return _m[tile].m2 & SignalAlongTrackdir(trackdir) ?
tron@4041: 		SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;
tron@4041: }
tron@4041: 
tron@4041: 
tron@4041: /**
tron@4041:  * Return the rail type of tile, or INVALID_RAILTYPE if this is no rail tile.
tron@4041:  * Note that there is no check if the given trackdir is actually present on
tron@4041:  * the tile!
tron@4041:  * The given trackdir is used when there are (could be) multiple rail types on
tron@4041:  * one tile.
tron@4041:  */
tron@4041: RailType GetTileRailType(TileIndex tile, Trackdir trackdir);
tron@4041: 
tron@4041: 
celestar@3523: typedef enum RailGroundType {
rubidium@4344: 	RAIL_GROUND_BARREN       =  0,
rubidium@4344: 	RAIL_GROUND_GRASS        =  1,
rubidium@4344: 	RAIL_GROUND_FENCE_NW     =  2,
rubidium@4344: 	RAIL_GROUND_FENCE_SE     =  3,
rubidium@4344: 	RAIL_GROUND_FENCE_SENW   =  4,
rubidium@4344: 	RAIL_GROUND_FENCE_NE     =  5,
rubidium@4344: 	RAIL_GROUND_FENCE_SW     =  6,
rubidium@4344: 	RAIL_GROUND_FENCE_NESW   =  7,
rubidium@4344: 	RAIL_GROUND_FENCE_VERT1  =  8,
rubidium@4344: 	RAIL_GROUND_FENCE_VERT2  =  9,
celestar@3523: 	RAIL_GROUND_FENCE_HORIZ1 = 10,
celestar@3523: 	RAIL_GROUND_FENCE_HORIZ2 = 11,
rubidium@4344: 	RAIL_GROUND_ICE_DESERT   = 12,
celestar@3523: } RailGroundType;
celestar@3523: 
celestar@3523: static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)
celestar@3523: {
rubidium@3792: 	if (GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT) {
celestar@3523: 		SB(_m[t].m4, 0, 4, rgt);
celestar@3523: 		return;
celestar@3523: 	}
celestar@3523: 	SB(_m[t].m2, 0, 4, rgt);
celestar@3523: }
celestar@3523: 
celestar@3523: static inline RailGroundType GetRailGroundType(TileIndex t)
celestar@3523: {
celestar@3523: 	/* TODO Unify this */
KUDr@3900: 	if (GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT) return (RailGroundType)GB(_m[t].m4, 0, 4);
KUDr@3900: 	return (RailGroundType)GB(_m[t].m2, 0, 4);
celestar@3523: }
celestar@3523: 
celestar@3523: static inline bool IsSnowRailGround(TileIndex t)
celestar@3523: {
celestar@3523: 	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;
celestar@3523: }
celestar@3523: 
celestar@3523: 
tron@3101: static inline void MakeRailNormal(TileIndex t, Owner o, TrackBits b, RailType r)
tron@3101: {
tron@3101: 	SetTileType(t, MP_RAILWAY);
tron@3101: 	SetTileOwner(t, o);
tron@3101: 	_m[t].m2 = 0;
tron@3101: 	_m[t].m3 = r;
tron@3101: 	_m[t].m4 = 0;
rubidium@3792: 	_m[t].m5 = RAIL_TILE_NORMAL | b;
tron@3101: }
tron@3101: 
tron@3101: 
tron@3101: static inline void MakeRailDepot(TileIndex t, Owner o, DiagDirection d, RailType r)
tron@3101: {
tron@3101: 	SetTileType(t, MP_RAILWAY);
tron@3101: 	SetTileOwner(t, o);
tron@3101: 	_m[t].m2 = 0;
tron@3101: 	_m[t].m3 = r;
tron@3101: 	_m[t].m4 = 0;
rubidium@3792: 	_m[t].m5 = RAIL_TILE_DEPOT_WAYPOINT | RAIL_SUBTYPE_DEPOT | d;
tron@3101: }
tron@3101: 
tron@3101: 
tron@3101: static inline void MakeRailWaypoint(TileIndex t, Owner o, Axis a, RailType r, uint index)
tron@3101: {
tron@3101: 	SetTileType(t, MP_RAILWAY);
tron@3101: 	SetTileOwner(t, o);
tron@3101: 	_m[t].m2 = index;
tron@3101: 	_m[t].m3 = r;
tron@3101: 	_m[t].m4 = 0;
rubidium@3792: 	_m[t].m5 = RAIL_TILE_DEPOT_WAYPOINT | RAIL_SUBTYPE_WAYPOINT | a;
tron@3101: }
tron@3101: 
peter1138@4666: #endif /* RAIL_MAP_H */