track_func.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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef TRACK_FUNC_H
#define TRACK_FUNC_H
 
#include "track_type.h"
#include "direction_func.h"
#include "slope_func.h"

inline bool IsValidTrack(Track track)
{
  return track < Track::End;
}

inline bool IsValidTrackdirForRoadVehicle(Trackdir trackdir)
{
  return trackdir < Trackdir::End;
}

inline bool IsValidTrackdir(Trackdir trackdir)
{
  return trackdir < Trackdir::End && TRACKDIR_BIT_MASK.Test(trackdir);
}

inline Track AxisToTrack(Axis a)
{
  assert(IsValidAxis(a));
  return static_cast<Track>(to_underlying(a));
}

inline TrackBits CornerToTrackBits(Corner corner)
{
  extern const CornerIndexArray<TrackBits> _corner_to_trackbits;
  assert(IsValidCorner(corner));
  return _corner_to_trackbits[corner];
}

inline TrackdirBits TrackdirToTrackdirBits(Trackdir trackdir)
{
  assert(IsValidTrackdir(trackdir));
  return trackdir;
}

inline Track RemoveFirstTrack(TrackBits &tracks)
{
  if (tracks.None()) return Track::Invalid;
 
  assert(!tracks.Any({Track::Wormhole, Track::Depot}));
  Track first = tracks.GetNthSetBit(0).value();
  tracks.Reset(first);
  return first;
}

inline Trackdir RemoveFirstTrackdir(TrackdirBits &trackdirs)
{
  if (trackdirs.None() || trackdirs == INVALID_TRACKDIR_BIT) return Trackdir::Invalid;
 
  assert(!trackdirs.Any({Trackdir::RvRev_NE, Trackdir::RvRev_SE, Trackdir::RvRev_SW, Trackdir::RvRev_NW}));
  Trackdir first = trackdirs.GetNthSetBit(0).value();
  trackdirs.Reset(first);
  return first;
}

inline Track FindFirstTrack(TrackBits tracks)
{
  return tracks.GetNthSetBit(0).value_or(Track::Invalid);
}

inline Track TrackBitsToTrack(TrackBits tracks)
{
  assert(tracks.Count() == 1 && !tracks.Any({Track::Wormhole, Track::Depot}));
  return FindFirstTrack(tracks);
}

inline Trackdir FindFirstTrackdir(TrackdirBits trackdirs)
{
  assert(!trackdirs.Any({Trackdir::RvRev_NE, Trackdir::RvRev_SE, Trackdir::RvRev_SW, Trackdir::RvRev_NW}));
  return trackdirs.GetNthSetBit(0).value_or(Trackdir::Invalid);
}
 
/*
 * Functions describing logical relations between Tracks, TrackBits, Trackdirs
 * TrackdirBits, Direction and DiagDirections.
 */

inline Track TrackToOppositeTrack(Track t)
{
  assert(IsValidTrack(t));
  return static_cast<Track>(to_underlying(t) ^ 1);
}

inline Trackdir ReverseTrackdir(Trackdir trackdir)
{
  assert(IsValidTrackdirForRoadVehicle(trackdir));
  return static_cast<Trackdir>(to_underlying(trackdir) ^ 8);
}

inline Track TrackdirToTrack(Trackdir trackdir)
{
  assert(IsValidTrackdir(trackdir));
  return static_cast<Track>(to_underlying(trackdir) & 0x7);
}

inline Trackdir TrackToTrackdir(Track track)
{
  assert(IsValidTrack(track));
  return static_cast<Trackdir>(track);
}

inline TrackdirBits TrackToTrackdirBits(Track track)
{
  Trackdir td = TrackToTrackdir(track);
  return TrackdirToTrackdirBits(td) | TrackdirToTrackdirBits(ReverseTrackdir(td));
}

inline TrackBits TrackdirBitsToTrackBits(TrackdirBits bits)
{
  return static_cast<TrackBits>((bits.base() | (bits.base() >> 8)) & TRACK_BIT_ALL.base());
}

inline TrackdirBits TrackBitsToTrackdirBits(TrackBits bits)
{
  return static_cast<TrackdirBits>(bits.base() * 0x101);
}

inline Trackdir NextTrackdir(Trackdir trackdir)
{
  assert(IsValidTrackdir(trackdir));
  extern const TrackdirIndexArray<Trackdir> _next_trackdir;
  return _next_trackdir[trackdir];
}

inline TrackBits TrackCrossesTracks(Track track)
{
  assert(IsValidTrack(track));
  extern const TrackIndexArray<TrackBits> _track_crosses_tracks;
  return _track_crosses_tracks[track];
}

inline DiagDirection TrackdirToExitdir(Trackdir trackdir)
{
  assert(IsValidTrackdirForRoadVehicle(trackdir));
  extern const TrackdirIndexArray<DiagDirection> _trackdir_to_exitdir;
  return _trackdir_to_exitdir[trackdir];
}

inline Trackdir TrackExitdirToTrackdir(Track track, DiagDirection diagdir)
{
  assert(IsValidTrack(track));
  assert(IsValidDiagDirection(diagdir));
  extern const TrackIndexArray<DiagDirectionIndexArray<Trackdir>> _track_exitdir_to_trackdir;
  return _track_exitdir_to_trackdir[track][diagdir];
}

inline Trackdir TrackEnterdirToTrackdir(Track track, DiagDirection diagdir)
{
  assert(IsValidTrack(track));
  assert(IsValidDiagDirection(diagdir));
  extern const TrackIndexArray<DiagDirectionIndexArray<Trackdir>> _track_enterdir_to_trackdir;
  return _track_enterdir_to_trackdir[track][diagdir];
}

inline Trackdir TrackDirectionToTrackdir(Track track, Direction dir)
{
  assert(IsValidTrack(track));
  assert(IsValidDirection(dir));
  extern const TrackIndexArray<DirectionIndexArray<Trackdir>> _track_direction_to_trackdir;
  return _track_direction_to_trackdir[track][dir];
}

inline Track DiagDirToDiagTrack(DiagDirection diagdir)
{
  assert(IsValidDiagDirection(diagdir));
  return static_cast<Track>(to_underlying(diagdir) & 1);
}

inline Trackdir DiagDirToDiagTrackdir(DiagDirection diagdir)
{
  assert(IsValidDiagDirection(diagdir));
  extern const DiagDirectionIndexArray<Trackdir> _dir_to_diag_trackdir;
  return _dir_to_diag_trackdir[diagdir];
}

inline TrackdirBits DiagdirReachesTrackdirs(DiagDirection diagdir)
{
  assert(IsValidDiagDirection(diagdir));
  extern const DiagDirectionIndexArray<TrackdirBits> _exitdir_reaches_trackdirs;
  return _exitdir_reaches_trackdirs[diagdir];
}

inline TrackBits DiagdirReachesTracks(DiagDirection diagdir) { return TrackdirBitsToTrackBits(DiagdirReachesTrackdirs(diagdir)); }

inline TrackdirBits TrackdirReachesTrackdirs(Trackdir trackdir)
{
  assert(IsValidTrackdir(trackdir));
  extern const DiagDirectionIndexArray<TrackdirBits> _exitdir_reaches_trackdirs;
  return _exitdir_reaches_trackdirs[TrackdirToExitdir(trackdir)];
}
/* Note that there is no direct table for this function (there used to be),
 * but it uses two simpler tables to achieve the result */

inline TrackdirBits TrackdirCrossesTrackdirs(Trackdir trackdir)
{
  assert(IsValidTrackdir(trackdir));
  extern const TrackIndexArray<TrackdirBits> _track_crosses_trackdirs;
  return _track_crosses_trackdirs[TrackdirToTrack(trackdir)];
}

inline bool IsDiagonalTrack(Track track)
{
  assert(IsValidTrack(track));
  return (track == Track::X) || (track == Track::Y);
}

inline bool IsDiagonalTrackdir(Trackdir trackdir)
{
  assert(IsValidTrackdir(trackdir));
  return IsDiagonalTrack(TrackdirToTrack(trackdir));
}
 

inline bool TracksOverlap(TrackBits bits)
{
  /* With no, or only one track, there is no overlap */
  if (bits.Count() <= 1) return false;
  /* We know that there are at least two tracks present. When there are more
   * than 2 tracks, they will surely overlap. When there are two, they will
   * always overlap unless they are lower & upper or right & left. */
  return bits != TRACK_BIT_HORZ && bits != TRACK_BIT_VERT;
}

inline bool TrackOverlapsTracks(TrackBits tracks, Track track)
{
  if (tracks.Test(track)) return true;
  return TracksOverlap(tracks | track);
}

inline bool IsReversingRoadTrackdir(Trackdir dir)
{
  assert(IsValidTrackdirForRoadVehicle(dir));
  return (to_underlying(dir) & 0x07) >= 6;
}

inline bool IsStraightRoadTrackdir(Trackdir dir)
{
  assert(IsValidTrackdirForRoadVehicle(dir));
  return (to_underlying(dir) & 0x06) == 0;
}

inline bool IsUphillTrackdir(Slope slope, Trackdir dir)
{
  assert(IsValidTrackdirForRoadVehicle(dir));
  extern const TrackdirBits _uphill_trackdirs[];
  return _uphill_trackdirs[RemoveHalftileSlope(slope)].Test(dir);
}

inline DiagDirection VehicleExitDir(Direction direction, TrackBits track)
{
  static const DiagDirectionIndexArray<TrackBits> state_dir_table{Track::Right, Track::Lower, Track::Left, Track::Upper};
 
  DiagDirection diagdir = DirToDiagDir(direction);
 
  /* Determine the diagonal direction in which we will exit this tile */
  if (!IsDiagonalDirection(direction) && track != state_dir_table[diagdir]) {
    diagdir = ChangeDiagDir(diagdir, DiagDirDiff::Left90);
  }
 
  return diagdir;
}
 
#endif /* TRACK_FUNC_H */