From 013df98f79866a75f367853c9e436f3c5c79f645 Mon Sep 17 00:00:00 2001 From: rubidium Date: Tue, 2 Jan 2007 19:19:48 +0000 Subject: (svn r7759) -Merge: makefile rewrite. This merge features: - A proper ./configure, so everything needs to be configured only once, not for every make. - Usage of makedepend when available. This greatly reduces the time needed for generating the dependencies. - A generator for all project files. There is a single file with sources, which is used to generate Makefiles and the project files for MSVC. - Proper support for OSX universal binaries. - Object files for non-MSVC compiles are also placed in separate directories, making is faster to switch between debug and release compiles and it does not touch the directory with the source files. - Functionality to make a bundle of all needed files for for example a nightly or distribution of a binary with all needed GRFs and language files. Note: as this merge moves almost all files, it is recommended to make a backup of your working copy before updating your working copy. --- src/rail_map.h | 342 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 342 insertions(+) create mode 100644 src/rail_map.h (limited to 'src/rail_map.h') diff --git a/src/rail_map.h b/src/rail_map.h new file mode 100644 index 000000000..902d4e6a4 --- /dev/null +++ b/src/rail_map.h @@ -0,0 +1,342 @@ +/* $Id$ */ + +#ifndef RAIL_MAP_H +#define RAIL_MAP_H + +#include "direction.h" +#include "rail.h" +#include "tile.h" + + +typedef enum RailTileType { + RAIL_TILE_NORMAL = 0x0, + RAIL_TILE_SIGNALS = 0x40, + RAIL_TILE_UNUSED = 0x80, /* XXX: Maybe this could become waypoints? */ + RAIL_TILE_DEPOT_WAYPOINT = 0xC0, /* Is really depots and waypoints... */ + RAIL_TILE_TYPE_MASK = 0xC0 +} RailTileType; + +static inline RailTileType GetRailTileType(TileIndex t) +{ + assert(IsTileType(t, MP_RAILWAY)); + return (RailTileType)(_m[t].m5 & RAIL_TILE_TYPE_MASK); +} + +/** + * Returns whether this is plain rails, with or without signals. Iow, if this + * tiles RailTileType is RAIL_TILE_NORMAL or RAIL_TILE_SIGNALS. + */ +static inline bool IsPlainRailTile(TileIndex tile) +{ + RailTileType rtt = GetRailTileType(tile); + return rtt == RAIL_TILE_NORMAL || rtt == RAIL_TILE_SIGNALS; +} + +/** + * Checks if a rail tile has signals. + */ +static inline bool HasSignals(TileIndex tile) +{ + return GetRailTileType(tile) == RAIL_TILE_SIGNALS; +} + + +/** These specify the subtype when the main rail type is + * RAIL_TILE_DEPOT_WAYPOINT */ +typedef enum RailTileSubtypes { + RAIL_SUBTYPE_DEPOT = 0x00, + RAIL_SUBTYPE_WAYPOINT = 0x04, + RAIL_SUBTYPE_MASK = 0x3C +} RailTileSubtype; + +/** + * Returns the RailTileSubtype of a given rail tile with type + * RAIL_TILE_DEPOT_WAYPOINT + */ +static inline RailTileSubtype GetRailTileSubtype(TileIndex tile) +{ + assert(GetRailTileType(tile) == RAIL_TILE_DEPOT_WAYPOINT); + return (RailTileSubtype)(_m[tile].m5 & RAIL_SUBTYPE_MASK); +} + + +static inline bool IsRailDepot(TileIndex t) +{ + return + GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT && + GetRailTileSubtype(t) == RAIL_SUBTYPE_DEPOT; +} + + +static inline bool IsRailWaypoint(TileIndex t) +{ + return + GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT && + GetRailTileSubtype(t) == RAIL_SUBTYPE_WAYPOINT; +} + + +static inline RailType GetRailType(TileIndex t) +{ + return (RailType)GB(_m[t].m3, 0, 4); +} + +// TODO remove this by moving to the same bits as GetRailType() +static inline RailType GetRailTypeCrossing(TileIndex t) +{ + return (RailType)GB(_m[t].m4, 0, 4); +} + +static inline void SetRailType(TileIndex t, RailType r) +{ + SB(_m[t].m3, 0, 4, r); +} + +// TODO remove this by moving to the same bits as SetRailType() +static inline void SetRailTypeCrossing(TileIndex t, RailType r) +{ + SB(_m[t].m4, 0, 4, r); +} + + +static inline TrackBits GetTrackBits(TileIndex tile) +{ + return (TrackBits)GB(_m[tile].m5, 0, 6); +} + +static inline void SetTrackBits(TileIndex t, TrackBits b) +{ + SB(_m[t].m5, 0, 6, b); +} + +/** + * 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); +} + + +static inline DiagDirection GetRailDepotDirection(TileIndex t) +{ + return (DiagDirection)GB(_m[t].m5, 0, 2); +} + + +static inline Axis GetWaypointAxis(TileIndex t) +{ + return (Axis)GB(_m[t].m5, 0, 1); +} + +static inline Track GetRailWaypointTrack(TileIndex t) +{ + return AxisToTrack(GetWaypointAxis(t)); +} + +static inline TrackBits GetRailWaypointBits(TileIndex t) +{ + return TrackToTrackBits(GetRailWaypointTrack(t)); +} + + +typedef enum SignalType { + SIGTYPE_NORMAL = 0, // normal signal + SIGTYPE_ENTRY = 1, // presignal block entry + SIGTYPE_EXIT = 2, // presignal block exit + SIGTYPE_COMBO = 3 // presignal inter-block +} SignalType; + +static inline SignalType GetSignalType(TileIndex t) +{ + assert(GetRailTileType(t) == RAIL_TILE_SIGNALS); + return (SignalType)GB(_m[t].m4, 0, 2); +} + +static inline void SetSignalType(TileIndex t, SignalType s) +{ + assert(GetRailTileType(t) == RAIL_TILE_SIGNALS); + SB(_m[t].m4, 0, 2, s); +} + +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; +} + +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); +} + + +typedef enum SignalVariant { + SIG_ELECTRIC = 0, + SIG_SEMAPHORE = 1 +} SignalVariant; + +static inline SignalVariant GetSignalVariant(TileIndex t) +{ + return (SignalVariant)GB(_m[t].m4, 2, 1); +} + +static inline void SetSignalVariant(TileIndex t, SignalVariant v) +{ + SB(_m[t].m4, 2, 1, v); +} + +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. + */ +typedef enum SignalStates { + SIGNAL_STATE_RED = 0, + SIGNAL_STATE_GREEN = 1, +} SignalState; + +static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit) +{ + return (SignalState)HASBIT(_m[t].m2, signalbit + 4); +} + + +/** + * 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. + * Note that there is no check if the given trackdir is actually present on + * the tile! + * The given trackdir is used when there are (could be) multiple rail types on + * one tile. + */ +RailType GetTileRailType(TileIndex tile, Trackdir trackdir); + + +typedef enum RailGroundType { + 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, + RAIL_GROUND_FENCE_HORIZ1 = 10, + RAIL_GROUND_FENCE_HORIZ2 = 11, + RAIL_GROUND_ICE_DESERT = 12, +} RailGroundType; + +static inline void SetRailGroundType(TileIndex t, RailGroundType rgt) +{ + if (GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT) { + SB(_m[t].m4, 0, 4, rgt); + return; + } + SB(_m[t].m2, 0, 4, rgt); +} + +static inline RailGroundType GetRailGroundType(TileIndex t) +{ + /* TODO Unify this */ + if (GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT) return (RailGroundType)GB(_m[t].m4, 0, 4); + return (RailGroundType)GB(_m[t].m2, 0, 4); +} + +static inline bool IsSnowRailGround(TileIndex t) +{ + return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT; +} + + +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; + _m[t].m5 = RAIL_TILE_NORMAL | b; +} + + +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; + _m[t].m5 = RAIL_TILE_DEPOT_WAYPOINT | RAIL_SUBTYPE_DEPOT | d; +} + + +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; + _m[t].m5 = RAIL_TILE_DEPOT_WAYPOINT | RAIL_SUBTYPE_WAYPOINT | a; +} + +#endif /* RAIL_MAP_H */ -- cgit v1.2.3-70-g09d2