rail_map.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#ifndef RAIL_MAP_H
#define RAIL_MAP_H
 
#include "rail_type.h"
#include "depot_type.h"
#include "signal_func.h"
#include "track_func.h"
#include "tile_map.h"
#include "water_map.h"
#include "signal_type.h"
 
 
enum RailTileType {
  RAIL_TILE_NORMAL   = 0, 
  RAIL_TILE_SIGNALS  = 1, 
  RAIL_TILE_DEPOT    = 3, 
};
 
debug_inline static RailTileType GetRailTileType(Tile t)
{
  assert(IsTileType(t, MP_RAILWAY));
  return (RailTileType)GB(t.m5(), 6, 2);
}
 
debug_inline static bool IsPlainRail(Tile t)
{
  RailTileType rtt = GetRailTileType(t);
  return rtt == RAIL_TILE_NORMAL || rtt == RAIL_TILE_SIGNALS;
}
 
debug_inline static bool IsPlainRailTile(Tile t)
{
  return IsTileType(t, MP_RAILWAY) && IsPlainRail(t);
}
 
 
inline bool HasSignals(Tile t)
{
  return GetRailTileType(t) == RAIL_TILE_SIGNALS;
}
 
inline void SetHasSignals(Tile tile, bool signals)
{
  assert(IsPlainRailTile(tile));
  SB(tile.m5(), 6, 1, signals);
}
 
debug_inline static bool IsRailDepot(Tile t)
{
  return GetRailTileType(t) == RAIL_TILE_DEPOT;
}
 
debug_inline static bool IsRailDepotTile(Tile t)
{
  return IsTileType(t, MP_RAILWAY) && IsRailDepot(t);
}
 
inline RailType GetRailType(Tile t)
{
  return (RailType)GB(t.m8(), 0, 6);
}
 
inline void SetRailType(Tile t, RailType r)
{
  SB(t.m8(), 0, 6, r);
}
 
 
inline TrackBits GetTrackBits(Tile tile)
{
  assert(IsPlainRailTile(tile));
  return (TrackBits)GB(tile.m5(), 0, 6);
}
 
inline void SetTrackBits(Tile t, TrackBits b)
{
  assert(IsPlainRailTile(t));
  SB(t.m5(), 0, 6, b);
}
 
inline bool HasTrack(Tile tile, Track track)
{
  return HasBit(GetTrackBits(tile), track);
}
 
inline DiagDirection GetRailDepotDirection(Tile t)
{
  return (DiagDirection)GB(t.m5(), 0, 2);
}
 
inline Track GetRailDepotTrack(Tile t)
{
  return DiagDirToDiagTrack(GetRailDepotDirection(t));
}
 
 
inline TrackBits GetRailReservationTrackBits(Tile t)
{
  assert(IsPlainRailTile(t));
  byte track_b = GB(t.m2(), 8, 3);
  Track track = (Track)(track_b - 1);    // map array saves Track+1
  if (track_b == 0) return TRACK_BIT_NONE;
  return (TrackBits)(TrackToTrackBits(track) | (HasBit(t.m2(), 11) ? TrackToTrackBits(TrackToOppositeTrack(track)) : 0));
}
 
inline void SetTrackReservation(Tile t, TrackBits b)
{
  assert(IsPlainRailTile(t));
  assert(b != INVALID_TRACK_BIT);
  assert(!TracksOverlap(b));
  Track track = RemoveFirstTrack(&b);
  SB(t.m2(), 8, 3, track == INVALID_TRACK ? 0 : track + 1);
  SB(t.m2(), 11, 1, (byte)(b != TRACK_BIT_NONE));
}
 
inline bool TryReserveTrack(Tile tile, Track t)
{
  assert(HasTrack(tile, t));
  TrackBits bits = TrackToTrackBits(t);
  TrackBits res = GetRailReservationTrackBits(tile);
  if ((res & bits) != TRACK_BIT_NONE) return false;  // already reserved
  res |= bits;
  if (TracksOverlap(res)) return false;  // crossing reservation present
  SetTrackReservation(tile, res);
  return true;
}
 
inline void UnreserveTrack(Tile tile, Track t)
{
  assert(HasTrack(tile, t));
  TrackBits res = GetRailReservationTrackBits(tile);
  res &= ~TrackToTrackBits(t);
  SetTrackReservation(tile, res);
}
 
inline bool HasDepotReservation(Tile t)
{
  assert(IsRailDepot(t));
  return HasBit(t.m5(), 4);
}
 
inline void SetDepotReservation(Tile t, bool b)
{
  assert(IsRailDepot(t));
  SB(t.m5(), 4, 1, (byte)b);
}
 
inline TrackBits GetDepotReservationTrackBits(Tile t)
{
  return HasDepotReservation(t) ? TrackToTrackBits(GetRailDepotTrack(t)) : TRACK_BIT_NONE;
}
 
 
inline bool IsPbsSignal(SignalType s)
{
  return s == SIGTYPE_PBS || s == SIGTYPE_PBS_ONEWAY;
}
 
inline SignalType GetSignalType(Tile t, Track track)
{
  assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
  byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;
  return (SignalType)GB(t.m2(), pos, 3);
}
 
inline void SetSignalType(Tile t, Track track, SignalType s)
{
  assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
  byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;
  SB(t.m2(), pos, 3, s);
  if (track == INVALID_TRACK) SB(t.m2(), 4, 3, s);
}
 
inline bool IsPresignalEntry(Tile t, Track track)
{
  return GetSignalType(t, track) == SIGTYPE_ENTRY || GetSignalType(t, track) == SIGTYPE_COMBO;
}
 
inline bool IsPresignalExit(Tile t, Track track)
{
  return GetSignalType(t, track) == SIGTYPE_EXIT || GetSignalType(t, track) == SIGTYPE_COMBO;
}
 
inline bool IsOnewaySignal(Tile t, Track track)
{
  return GetSignalType(t, track) != SIGTYPE_PBS;
}
 
inline void CycleSignalSide(Tile t, Track track)
{
  byte sig;
  byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 6;
 
  sig = GB(t.m3(), pos, 2);
  if (--sig == 0) sig = IsPbsSignal(GetSignalType(t, track)) ? 2 : 3;
  SB(t.m3(), pos, 2, sig);
}
 
inline SignalVariant GetSignalVariant(Tile t, Track track)
{
  byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 7 : 3;
  return (SignalVariant)GB(t.m2(), pos, 1);
}
 
inline void SetSignalVariant(Tile t, Track track, SignalVariant v)
{
  byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 7 : 3;
  SB(t.m2(), pos, 1, v);
  if (track == INVALID_TRACK) SB(t.m2(), 7, 1, v);
}
 
inline void SetSignalStates(Tile tile, uint state)
{
  SB(tile.m4(), 4, 4, state);
}
 
inline uint GetSignalStates(Tile tile)
{
  return GB(tile.m4(), 4, 4);
}
 
inline SignalState GetSingleSignalState(Tile t, byte signalbit)
{
  return (SignalState)HasBit(GetSignalStates(t), signalbit);
}
 
inline void SetPresentSignals(Tile tile, uint signals)
{
  SB(tile.m3(), 4, 4, signals);
}
 
inline uint GetPresentSignals(Tile tile)
{
  return GB(tile.m3(), 4, 4);
}
 
inline bool IsSignalPresent(Tile t, byte signalbit)
{
  return HasBit(GetPresentSignals(t), signalbit);
}
 
inline bool HasSignalOnTrack(Tile tile, Track track)
{
  assert(IsValidTrack(track));
  return GetRailTileType(tile) == RAIL_TILE_SIGNALS && (GetPresentSignals(tile) & SignalOnTrack(track)) != 0;
}
 
inline bool HasSignalOnTrackdir(Tile tile, Trackdir trackdir)
{
  assert (IsValidTrackdir(trackdir));
  return GetRailTileType(tile) == RAIL_TILE_SIGNALS && GetPresentSignals(tile) & SignalAlongTrackdir(trackdir);
}
 
inline SignalState GetSignalStateByTrackdir(Tile tile, Trackdir trackdir)
{
  assert(IsValidTrackdir(trackdir));
  assert(HasSignalOnTrack(tile, TrackdirToTrack(trackdir)));
  return GetSignalStates(tile) & SignalAlongTrackdir(trackdir) ?
    SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;
}
 
inline void SetSignalStateByTrackdir(Tile tile, Trackdir trackdir, SignalState state)
{
  if (state == SIGNAL_STATE_GREEN) { // set 1
    SetSignalStates(tile, GetSignalStates(tile) | SignalAlongTrackdir(trackdir));
  } else {
    SetSignalStates(tile, GetSignalStates(tile) & ~SignalAlongTrackdir(trackdir));
  }
}
 
inline bool HasPbsSignalOnTrackdir(Tile tile, Trackdir td)
{
  return IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, td) &&
      IsPbsSignal(GetSignalType(tile, TrackdirToTrack(td)));
}
 
inline bool HasOnewaySignalBlockingTrackdir(Tile tile, Trackdir td)
{
  return IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, ReverseTrackdir(td)) &&
      !HasSignalOnTrackdir(tile, td) && IsOnewaySignal(tile, TrackdirToTrack(td));
}
 
 
RailType GetTileRailType(Tile tile);
 
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, 
  RAIL_GROUND_WATER        = 13, 
  RAIL_GROUND_HALF_SNOW    = 14, 
};
 
inline void SetRailGroundType(Tile t, RailGroundType rgt)
{
  SB(t.m4(), 0, 4, rgt);
}
 
inline RailGroundType GetRailGroundType(Tile t)
{
  return (RailGroundType)GB(t.m4(), 0, 4);
}
 
inline bool IsSnowRailGround(Tile t)
{
  return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;
}
 
 
inline void MakeRailNormal(Tile t, Owner o, TrackBits b, RailType r)
{
  SetTileType(t, MP_RAILWAY);
  SetTileOwner(t, o);
  SetDockingTile(t, false);
  t.m2() = 0;
  t.m3() = 0;
  t.m4() = 0;
  t.m5() = RAIL_TILE_NORMAL << 6 | b;
  SB(t.m6(), 2, 4, 0);
  t.m7() = 0;
  t.m8() = r;
}
 
inline void SetRailDepotExitDirection(Tile tile, DiagDirection dir)
{
  assert(IsRailDepotTile(tile));
  SB(tile.m5(), 0, 2, dir);
}
 
inline void MakeRailDepot(Tile tile, Owner owner, DepotID depot_id, DiagDirection dir, RailType rail_type)
{
  SetTileType(tile, MP_RAILWAY);
  SetTileOwner(tile, owner);
  SetDockingTile(tile, false);
  tile.m2() = depot_id;
  tile.m3() = 0;
  tile.m4() = 0;
  tile.m5() = RAIL_TILE_DEPOT << 6 | dir;
  SB(tile.m6(), 2, 4, 0);
  tile.m7() = 0;
  tile.m8() = rail_type;
}
 
#endif /* RAIL_MAP_H */