direction_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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef DIRECTION_FUNC_H
#define DIRECTION_FUNC_H
 
#include "direction_type.h"
 
inline bool IsValidDiagDirection(DiagDirection d)
{
  return d < DIAGDIR_END;
}
 
inline bool IsValidDirection(Direction d)
{
  return d < DIR_END;
}
 
inline bool IsValidAxis(Axis d)
{
  return d < AXIS_END;
}
 
inline Direction ReverseDir(Direction d)
{
  assert(IsValidDirection(d));
  return (Direction)(4 ^ d);
}
 
 
inline DirDiff DirDifference(Direction d0, Direction d1)
{
  assert(IsValidDirection(d0));
  assert(IsValidDirection(d1));
  /* Cast to uint so compiler can use bitmask. If the difference is negative
   * and we used int instead of uint, further "+ 8" would have to be added. */
  return static_cast<DirDiff>((static_cast<uint>(d0) - static_cast<uint>(d1)) % 8);
}
 
inline DirDiff ChangeDirDiff(DirDiff d, DirDiff delta)
{
  /* Cast to uint so compiler can use bitmask. Result can never be negative. */
  return static_cast<DirDiff>((static_cast<uint>(d) + static_cast<uint>(delta)) % 8);
}
 
inline Direction ChangeDir(Direction d, DirDiff delta)
{
  assert(IsValidDirection(d));
  /* Cast to uint so compiler can use bitmask. Result can never be negative. */
  return static_cast<Direction>((static_cast<uint>(d) + static_cast<uint>(delta)) % 8);
}
 
 
inline DiagDirection ReverseDiagDir(DiagDirection d)
{
  assert(IsValidDiagDirection(d));
  return (DiagDirection)(2 ^ d);
}
 
inline DiagDirDiff DiagDirDifference(DiagDirection d0, DiagDirection d1)
{
  assert(IsValidDiagDirection(d0));
  assert(IsValidDiagDirection(d1));
  /* Cast to uint so compiler can use bitmask. Result can never be negative. */
  return (DiagDirDiff)((uint)(d0 - d1) % 4);
}
 
inline DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)
{
  assert(IsValidDiagDirection(d));
  /* Cast to uint so compiler can use bitmask. Result can never be negative. */
  return static_cast<DiagDirection>((static_cast<uint>(d) + static_cast<uint>(delta)) % 4);
}
 
inline DiagDirection DirToDiagDir(Direction dir)
{
  assert(IsValidDirection(dir));
  return (DiagDirection)(dir >> 1);
}
 
inline Direction DiagDirToDir(DiagDirection dir)
{
  assert(IsValidDiagDirection(dir));
  return (Direction)(dir * 2 + 1);
}
 
 
inline Axis OtherAxis(Axis a)
{
  assert(IsValidAxis(a));
  return (Axis)(a ^ 1);
}
 
 
inline Axis DiagDirToAxis(DiagDirection d)
{
  assert(IsValidDiagDirection(d));
  return (Axis)(d & 1);
}
 
 
inline DiagDirection AxisToDiagDir(Axis a)
{
  assert(IsValidAxis(a));
  return (DiagDirection)(2 - a);
}
 
inline Direction AxisToDirection(Axis a)
{
  assert(IsValidAxis(a));
  return (Direction)(5 - 2 * a);
}
 
inline DiagDirection XYNSToDiagDir(Axis xy, uint ns)
{
  assert(IsValidAxis(xy));
  return (DiagDirection)(xy * 3 ^ ns * 2);
}
 
inline bool IsDiagonalDirection(Direction dir)
{
  assert(IsValidDirection(dir));
  return (dir & 1) != 0;
}
 
#endif /* DIRECTION_FUNC_H */