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 "core/bitmath_func.hpp"
#include "track_type.h"
#include "direction_func.h"
#include "slope_func.h"
 
using SetTrackBitIterator = SetBitIterator<Track, TrackBits>;
using SetTrackdirBitIterator = SetBitIterator<Trackdir, TrackdirBits>;

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 != INVALID_TRACKDIR && ((1 << trackdir & TRACKDIR_BIT_MASK) != TRACKDIR_BIT_NONE);
}

inline Track AxisToTrack(Axis a)
{
  assert(IsValidAxis(a));
  return (Track)a;
}

inline TrackBits TrackToTrackBits(Track track)
{
  assert(IsValidTrack(track));
  return (TrackBits)(1 << track);
}

inline TrackBits AxisToTrackBits(Axis a)
{
  return TrackToTrackBits(AxisToTrack(a));
}

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

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

inline Track RemoveFirstTrack(TrackBits *tracks)
{
  if (*tracks != TRACK_BIT_NONE) {
    assert((*tracks & ~TRACK_BIT_MASK) == TRACK_BIT_NONE);
    Track first = (Track)FindFirstBit(*tracks);
    ClrBit(*tracks, first);
    return first;
  }
  return INVALID_TRACK;
}

inline Trackdir RemoveFirstTrackdir(TrackdirBits *trackdirs)
{
  if (*trackdirs != TRACKDIR_BIT_NONE && *trackdirs != INVALID_TRACKDIR_BIT) {
    assert((*trackdirs & ~TRACKDIR_BIT_MASK) == TRACKDIR_BIT_NONE);
    Trackdir first = (Trackdir)FindFirstBit(*trackdirs);
    ClrBit(*trackdirs, first);
    return first;
  }
  return INVALID_TRACKDIR;
}

inline Track FindFirstTrack(TrackBits tracks)
{
  return (tracks != TRACK_BIT_NONE) ? (Track)FindFirstBit(tracks) : INVALID_TRACK;
}

inline Track TrackBitsToTrack(TrackBits tracks)
{
  assert(tracks != TRACK_BIT_NONE && KillFirstBit(tracks & TRACK_BIT_MASK) == TRACK_BIT_NONE);
  return static_cast<Track>(FindFirstBit(tracks & TRACK_BIT_MASK));
}

inline Trackdir FindFirstTrackdir(TrackdirBits trackdirs)
{
  assert((trackdirs & ~TRACKDIR_BIT_MASK) == TRACKDIR_BIT_NONE);
  return (trackdirs != TRACKDIR_BIT_NONE) ? (Trackdir)FindFirstBit(trackdirs) : INVALID_TRACKDIR;
}
 
/*
 * Functions describing logical relations between Tracks, TrackBits, Trackdirs
 * TrackdirBits, Direction and DiagDirections.
 */

inline Track TrackToOppositeTrack(Track t)
{
  assert(IsValidTrack(t));
  return (Track)(t ^ 1);
}

inline Trackdir ReverseTrackdir(Trackdir trackdir)
{
  assert(IsValidTrackdirForRoadVehicle(trackdir));
  return (Trackdir)(trackdir ^ 8);
}

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

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

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

inline TrackBits TrackdirBitsToTrackBits(TrackdirBits bits)
{
  return (TrackBits)((bits | (bits >> 8)) & TRACK_BIT_MASK);
}

inline TrackdirBits TrackBitsToTrackdirBits(TrackBits bits)
{
  return (TrackdirBits)(bits * 0x101);
}

inline bool HasTrack(TrackBits tracks, Track track)
{
  assert(IsValidTrack(track));
  return HasBit(tracks, track);
}

inline bool HasTrackdir(TrackdirBits trackdirs, Trackdir trackdir)
{
  assert(IsValidTrackdir(trackdir));
  return HasBit(trackdirs, trackdir);
}

inline TrackdirBits TrackStatusToTrackdirBits(TrackStatus ts)
{
  return (TrackdirBits)(ts & TRACKDIR_BIT_MASK);
}

inline TrackBits TrackStatusToTrackBits(TrackStatus ts)
{
  return TrackdirBitsToTrackBits(TrackStatusToTrackdirBits(ts));
}

inline TrackdirBits TrackStatusToRedSignals(TrackStatus ts)
{
  return (TrackdirBits)((ts >> 16) & TRACKDIR_BIT_MASK);
}

inline TrackStatus CombineTrackStatus(TrackdirBits trackdirbits, TrackdirBits red_signals)
{
  return (TrackStatus)(trackdirbits | (red_signals << 16));
}

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

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

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

inline Trackdir TrackExitdirToTrackdir(Track track, DiagDirection diagdir)
{
  assert(IsValidTrack(track));
  assert(IsValidDiagDirection(diagdir));
  extern const Trackdir _track_exitdir_to_trackdir[TRACK_END][DIAGDIR_END];
  return _track_exitdir_to_trackdir[track][diagdir];
}

inline Trackdir TrackEnterdirToTrackdir(Track track, DiagDirection diagdir)
{
  assert(IsValidTrack(track));
  assert(IsValidDiagDirection(diagdir));
  extern const Trackdir _track_enterdir_to_trackdir[TRACK_END][DIAGDIR_END];
  return _track_enterdir_to_trackdir[track][diagdir];
}

inline Trackdir TrackDirectionToTrackdir(Track track, Direction dir)
{
  assert(IsValidTrack(track));
  assert(IsValidDirection(dir));
  extern const Trackdir _track_direction_to_trackdir[TRACK_END][DIR_END];
  return _track_direction_to_trackdir[track][dir];
}

inline Track DiagDirToDiagTrack(DiagDirection diagdir)
{
  assert(IsValidDiagDirection(diagdir));
  return (Track)(diagdir & 1);
}

inline TrackBits DiagDirToDiagTrackBits(DiagDirection diagdir)
{
  assert(IsValidDiagDirection(diagdir));
  return TrackToTrackBits(DiagDirToDiagTrack(diagdir));
}

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

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

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

inline TrackdirBits TrackdirReachesTrackdirs(Trackdir trackdir)
{
  assert(IsValidTrackdir(trackdir));
  extern const TrackdirBits _exitdir_reaches_trackdirs[DIAGDIR_END];
  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 TrackdirBits _track_crosses_trackdirs[TRACK_END];
  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 == TRACK_BIT_NONE || KillFirstBit(bits) == TRACK_BIT_NONE) 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 (HasBit(tracks, track)) return true;
  return TracksOverlap(tracks | TrackToTrackBits(track));
}

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

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

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

inline DiagDirection VehicleExitDir(Direction direction, TrackBits track)
{
  static const TrackBits state_dir_table[DIAGDIR_END] = { TRACK_BIT_RIGHT, TRACK_BIT_LOWER, TRACK_BIT_LEFT, TRACK_BIT_UPPER };
 
  DiagDirection diagdir = DirToDiagDir(direction);
 
  /* Determine the diagonal direction in which we will exit this tile */
  if (!HasBit(direction, 0) && track != state_dir_table[diagdir]) {
    diagdir = ChangeDiagDir(diagdir, DIAGDIRDIFF_90LEFT);
  }
 
  return diagdir;
}
 
#endif /* TRACK_FUNC_H */