summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/airport.h2
-rw-r--r--src/bridge_map.h2
-rw-r--r--src/cmd_helper.h2
-rw-r--r--src/core/enum_type.hpp115
-rw-r--r--src/depot.h2
-rw-r--r--src/direction_func.h (renamed from src/direction.h)116
-rw-r--r--src/direction_type.h122
-rw-r--r--src/helpers.hpp108
-rw-r--r--src/map.cpp2
-rw-r--r--src/map.h2
-rw-r--r--src/misc/dbg_helpers.cpp2
-rw-r--r--src/newgrf_engine.h2
-rw-r--r--src/pathfind.h2
-rw-r--r--src/rail.h2
-rw-r--r--src/rail_map.h2
-rw-r--r--src/road_cmd.h2
-rw-r--r--src/train_cmd.cpp2
-rw-r--r--src/tunnel_map.h2
-rw-r--r--src/tunnelbridge_map.h2
19 files changed, 257 insertions, 234 deletions
diff --git a/src/airport.h b/src/airport.h
index 95501dfec..756a03c89 100644
--- a/src/airport.h
+++ b/src/airport.h
@@ -5,7 +5,7 @@
#ifndef AIRPORT_H
#define AIRPORT_H
-#include "direction.h"
+#include "direction_type.h"
enum {MAX_TERMINALS = 10};
enum {MAX_HELIPADS = 4};
diff --git a/src/bridge_map.h b/src/bridge_map.h
index 3a329d93b..13030092f 100644
--- a/src/bridge_map.h
+++ b/src/bridge_map.h
@@ -5,7 +5,7 @@
#ifndef BRIDGE_MAP_H
#define BRIDGE_MAP_H
-#include "direction.h"
+#include "direction_func.h"
#include "macros.h"
#include "map.h"
#include "rail.h"
diff --git a/src/cmd_helper.h b/src/cmd_helper.h
index 115b0e1cf..9fad39735 100644
--- a/src/cmd_helper.h
+++ b/src/cmd_helper.h
@@ -3,7 +3,7 @@
#ifndef CMD_HELPER_H
#define CMD_HELPER_H
-#include "direction.h"
+#include "direction_type.h"
#include "macros.h"
#include "road.h"
diff --git a/src/core/enum_type.hpp b/src/core/enum_type.hpp
new file mode 100644
index 000000000..725d3985f
--- /dev/null
+++ b/src/core/enum_type.hpp
@@ -0,0 +1,115 @@
+/* $Id$ */
+
+/** @file enum_type.hpp Type (helpers) for enums */
+
+#ifndef ENUM_TYPE_HPP
+#define ENUM_TYPE_HPP
+
+/** Some enums need to have allowed incrementing (i.e. StationClassID) */
+#define DECLARE_POSTFIX_INCREMENT(type) \
+ FORCEINLINE type operator ++(type& e, int) \
+ { \
+ type e_org = e; \
+ e = (type)((int)e + 1); \
+ return e_org; \
+ } \
+ FORCEINLINE type operator --(type& e, int) \
+ { \
+ type e_org = e; \
+ e = (type)((int)e - 1); \
+ return e_org; \
+ }
+
+
+
+/** Operators to allow to work with enum as with type safe bit set in C++ */
+# define DECLARE_ENUM_AS_BIT_SET(mask_t) \
+ FORCEINLINE mask_t operator | (mask_t m1, mask_t m2) {return (mask_t)((int)m1 | m2);} \
+ FORCEINLINE mask_t operator & (mask_t m1, mask_t m2) {return (mask_t)((int)m1 & m2);} \
+ FORCEINLINE mask_t operator ^ (mask_t m1, mask_t m2) {return (mask_t)((int)m1 ^ m2);} \
+ FORCEINLINE mask_t& operator |= (mask_t& m1, mask_t m2) {m1 = m1 | m2; return m1;} \
+ FORCEINLINE mask_t& operator &= (mask_t& m1, mask_t m2) {m1 = m1 & m2; return m1;} \
+ FORCEINLINE mask_t& operator ^= (mask_t& m1, mask_t m2) {m1 = m1 ^ m2; return m1;} \
+ FORCEINLINE mask_t operator ~(mask_t m) {return (mask_t)(~(int)m);}
+
+
+/** Informative template class exposing basic enumeration properties used by several
+ * other templates below. Here we have only forward declaration. For each enum type
+ * we will create specialization derived from MakeEnumPropsT<>.
+ * i.e.:
+ * template <> struct EnumPropsT<Track> : MakeEnumPropsT<Track, byte, TRACK_BEGIN, TRACK_END, INVALID_TRACK> {};
+ * followed by:
+ * typedef TinyEnumT<Track> TrackByte;
+ */
+template <typename Tenum_t> struct EnumPropsT;
+
+/** Helper template class that makes basic properties of given enumeration type visible
+ * from outsize. It is used as base class of several EnumPropsT specializations each
+ * dedicated to one of commonly used enumeration types.
+ * @param Tenum_t enumeration type that you want to describe
+ * @param Tstorage_t what storage type would be sufficient (i.e. byte)
+ * @param Tbegin first valid value from the contiguous range (i.e. TRACK_BEGIN)
+ * @param Tend one past the last valid value from the contiguous range (i.e. TRACK_END)
+ * @param Tinvalid value used as invalid value marker (i.e. INVALID_TRACK)
+ */
+template <typename Tenum_t, typename Tstorage_t, Tenum_t Tbegin, Tenum_t Tend, Tenum_t Tinvalid>
+struct MakeEnumPropsT {
+ typedef Tenum_t type; ///< enum type (i.e. Trackdir)
+ typedef Tstorage_t storage; ///< storage type (i.e. byte)
+ static const Tenum_t begin = Tbegin; ///< lowest valid value (i.e. TRACKDIR_BEGIN)
+ static const Tenum_t end = Tend; ///< one after the last valid value (i.e. TRACKDIR_END)
+ static const Tenum_t invalid = Tinvalid; ///< what value is used as invalid value (i.e. INVALID_TRACKDIR)
+};
+
+
+
+/** In some cases we use byte or uint16 to store values that are defined as enum. It is
+ * necessary in order to control the sizeof() such values. Some compilers make enum
+ * the same size as int (4 or 8 bytes instead of 1 or 2). As a consequence the strict
+ * compiler type-checking causes errors like:
+ * 'HasPowerOnRail' : cannot convert parameter 1 from 'byte' to 'RailType' when
+ * u->u.rail.railtype is passed as argument or type RailType. In such cases it is better
+ * to teach the compiler that u->u.rail.railtype is to be treated as RailType. */
+template <typename Tenum_t> struct TinyEnumT;
+
+/** The general declaration of TinyEnumT<> (above) */
+template <typename Tenum_t> struct TinyEnumT
+{
+ typedef Tenum_t enum_type; ///< expose our enumeration type (i.e. Trackdir) to outside
+ typedef EnumPropsT<Tenum_t> Props; ///< make easier access to our enumeration propeties
+ typedef typename Props::storage storage_type; ///< small storage type
+ static const enum_type begin = Props::begin; ///< enum beginning (i.e. TRACKDIR_BEGIN)
+ static const enum_type end = Props::end; ///< enum end (i.e. TRACKDIR_END)
+ static const enum_type invalid = Props::invalid;///< invalid value (i.e. INVALID_TRACKDIR)
+
+ storage_type m_val; ///< here we hold the actual value in small (i.e. byte) form
+
+ /** Cast operator - invoked then the value is assigned to the Tenum_t type */
+ FORCEINLINE operator enum_type () const
+ {
+ return (enum_type)m_val;
+ }
+
+ /** Assignment operator (from Tenum_t type) */
+ FORCEINLINE TinyEnumT& operator = (enum_type e)
+ {
+ m_val = (storage_type)e; return *this;
+ }
+
+ /** postfix ++ operator on tiny type */
+ FORCEINLINE TinyEnumT operator ++ (int)
+ {
+ TinyEnumT org = *this;
+ if (++m_val >= end) m_val -= (storage_type)(end - begin);
+ return org;
+ }
+
+ /** prefix ++ operator on tiny type */
+ FORCEINLINE TinyEnumT& operator ++ ()
+ {
+ if (++m_val >= end) m_val -= (storage_type)(end - begin);
+ return *this;
+ }
+};
+
+#endif /* HELPERS_HPP */
diff --git a/src/depot.h b/src/depot.h
index 2b47452cd..baa53573c 100644
--- a/src/depot.h
+++ b/src/depot.h
@@ -5,7 +5,7 @@
#ifndef DEPOT_H
#define DEPOT_H
-#include "direction.h"
+#include "direction_type.h"
#include "oldpool.h"
#include "tile.h"
#include "variables.h"
diff --git a/src/direction.h b/src/direction_func.h
index 9e678c9c9..2cfe99534 100644
--- a/src/direction.h
+++ b/src/direction_func.h
@@ -1,38 +1,11 @@
/* $Id$ */
-/** @file direction.h */
+/** @file direction_func.h Different functions related to conversions between directions. */
-#ifndef DIRECTION_H
-#define DIRECTION_H
+#ifndef DIRECTION_FUNC_H
+#define DIRECTION_FUNC_H
-#include "helpers.hpp"
-
-/**
- * Defines the 8 directions on the map.
- *
- * This enum defines 8 possible directions which are used for
- * the vehicles in the game. The directions are aligned straight
- * to the viewport, not to the map. So north points to the top of
- * your viewport and not rotated by 45 degrees left or right to get
- * a "north" used in you games.
- */
-enum Direction {
- DIR_BEGIN = 0, ///< Used to iterate
- DIR_N = 0, ///< North
- DIR_NE = 1, ///< Northeast
- DIR_E = 2, ///< East
- DIR_SE = 3, ///< Southeast
- DIR_S = 4, ///< South
- DIR_SW = 5, ///< Southwest
- DIR_W = 6, ///< West
- DIR_NW = 7, ///< Northwest
- DIR_END, ///< Used to iterate
- INVALID_DIR = 0xFF, ///< Flag for an invalid direction
-};
-
-/** Define basic enum properties */
-template <> struct EnumPropsT<Direction> : MakeEnumPropsT<Direction, byte, DIR_BEGIN, DIR_END, INVALID_DIR> {};
-typedef TinyEnumT<Direction> DirectionByte; //typedefing-enumification of Direction
+#include "direction_type.h"
/**
* Return the reverse of a direction
@@ -47,32 +20,6 @@ static inline Direction ReverseDir(Direction d)
/**
- * Enumeration for the difference between two directions.
- *
- * This enumeration is used to mark differences between
- * two directions. If you get one direction you can align
- * a second direction in 8 different ways. This enumeration
- * only contains 6 of these 8 differences, but the remaining
- * two can be calculated by adding to differences together.
- * This also means you can add two differences together and
- * get the difference you really want to get. The difference
- * of 45 degrees left + the difference of 45 degrees right results in the
- * difference of 0 degrees.
- *
- * @note To get this mentioned addition of direction you must use
- * modulo DIR_END or use the #ChangeDirDiff(DirDiff, DirDiff) function.
- * @see ChangeDirDiff(DirDiff, DirDiff)
- */
-enum DirDiff {
- DIRDIFF_SAME = 0, ///< Both directions faces to the same direction
- DIRDIFF_45RIGHT = 1, ///< Angle of 45 degrees right
- DIRDIFF_90RIGHT = 2, ///< Angle of 90 degrees right
- DIRDIFF_REVERSE = 4, ///< One direction is the opposit of the other one
- DIRDIFF_90LEFT = 6, ///< Angle of 90 degrees left
- DIRDIFF_45LEFT = 7 ///< Angle of 45 degrees left
-};
-
-/**
* Calculate the difference between to directions
*
* @param d0 The first direction as the base
@@ -117,27 +64,6 @@ static inline Direction ChangeDir(Direction d, DirDiff delta)
/**
- * Enumeration for diagonal directions.
- *
- * This enumeration is used for the 4 direction of the tile-edges.
- */
-enum DiagDirection {
- DIAGDIR_BEGIN = 0, ///< Used for iterations
- DIAGDIR_NE = 0, ///< Northeast, upper right on your monitor
- DIAGDIR_SE = 1, ///< Southeast
- DIAGDIR_SW = 2, ///< Southwest
- DIAGDIR_NW = 3, ///< Northwest
- DIAGDIR_END, ///< Used for iterations
- INVALID_DIAGDIR = 0xFF, ///< Flag for an invalid DiagDirection
-};
-
-DECLARE_POSTFIX_INCREMENT(DiagDirection);
-
-/** Define basic enum properties */
-template <> struct EnumPropsT<DiagDirection> : MakeEnumPropsT<DiagDirection, byte, DIAGDIR_BEGIN, DIAGDIR_END, INVALID_DIAGDIR> {};
-typedef TinyEnumT<DiagDirection> DiagDirectionByte; //typedefing-enumification of DiagDirection
-
-/**
* Returns the reverse direction of the given DiagDirection
*
* @param d The DiagDirection to get the reverse from
@@ -148,25 +74,6 @@ static inline DiagDirection ReverseDiagDir(DiagDirection d)
return (DiagDirection)(2 ^ d);
}
-/**
- * Enumeration for the difference between to DiagDirection.
- *
- * As the DiagDirection only contains 4 possible directions the
- * difference between two of these directions can only be in 4 ways.
- * As the DirDiff enumeration the values can be added together and
- * you will get the resulting difference (use modulo DIAGDIR_END).
- *
- * @see DirDiff
- */
-enum DiagDirDiff {
- DIAGDIRDIFF_SAME = 0, ///< Same directions
- DIAGDIRDIFF_90RIGHT = 1, ///< 90 degrees right
- DIAGDIRDIFF_REVERSE = 2, ///< Reverse directions
- DIAGDIRDIFF_90LEFT = 3 ///< 90 degrees left
-};
-
-/** Allow incrementing of DiagDirDiff variables */
-DECLARE_POSTFIX_INCREMENT(DiagDirDiff);
/**
* Applies a difference on a DiagDirection
@@ -215,21 +122,6 @@ static inline Direction DiagDirToDir(DiagDirection dir)
/**
- * Enumeration for the two axis X and Y
- *
- * This enumeration represente the two axis X and Y in the game.
- * The X axis is the one which goes align the north-west edge
- * (and south-east edge). The Y axis must be so the one which goes
- * align the north-east edge (and south-west) edge.
- */
-enum Axis {
- AXIS_X = 0, ///< The X axis
- AXIS_Y = 1, ///< The y axis
- AXIS_END ///< Used for iterations
-};
-
-
-/**
* Select the other axis as provided.
*
* This is basically the not-operator for the axis.
diff --git a/src/direction_type.h b/src/direction_type.h
new file mode 100644
index 000000000..d1f8d8920
--- /dev/null
+++ b/src/direction_type.h
@@ -0,0 +1,122 @@
+/* $Id$ */
+
+/** @file direction_type.h Different types to 'show' directions. */
+
+#ifndef DIRECTION_TYPE_H
+#define DIRECTION_TYPE_H
+
+#include "core/enum_type.hpp"
+
+/**
+ * Defines the 8 directions on the map.
+ *
+ * This enum defines 8 possible directions which are used for
+ * the vehicles in the game. The directions are aligned straight
+ * to the viewport, not to the map. So north points to the top of
+ * your viewport and not rotated by 45 degrees left or right to get
+ * a "north" used in you games.
+ */
+enum Direction {
+ DIR_BEGIN = 0, ///< Used to iterate
+ DIR_N = 0, ///< North
+ DIR_NE = 1, ///< Northeast
+ DIR_E = 2, ///< East
+ DIR_SE = 3, ///< Southeast
+ DIR_S = 4, ///< South
+ DIR_SW = 5, ///< Southwest
+ DIR_W = 6, ///< West
+ DIR_NW = 7, ///< Northwest
+ DIR_END, ///< Used to iterate
+ INVALID_DIR = 0xFF, ///< Flag for an invalid direction
+};
+
+/** Define basic enum properties */
+template <> struct EnumPropsT<Direction> : MakeEnumPropsT<Direction, byte, DIR_BEGIN, DIR_END, INVALID_DIR> {};
+typedef TinyEnumT<Direction> DirectionByte; //typedefing-enumification of Direction
+
+
+/**
+ * Enumeration for the difference between two directions.
+ *
+ * This enumeration is used to mark differences between
+ * two directions. If you get one direction you can align
+ * a second direction in 8 different ways. This enumeration
+ * only contains 6 of these 8 differences, but the remaining
+ * two can be calculated by adding to differences together.
+ * This also means you can add two differences together and
+ * get the difference you really want to get. The difference
+ * of 45 degrees left + the difference of 45 degrees right results in the
+ * difference of 0 degrees.
+ *
+ * @note To get this mentioned addition of direction you must use
+ * modulo DIR_END or use the #ChangeDirDiff(DirDiff, DirDiff) function.
+ * @see ChangeDirDiff(DirDiff, DirDiff)
+ */
+enum DirDiff {
+ DIRDIFF_SAME = 0, ///< Both directions faces to the same direction
+ DIRDIFF_45RIGHT = 1, ///< Angle of 45 degrees right
+ DIRDIFF_90RIGHT = 2, ///< Angle of 90 degrees right
+ DIRDIFF_REVERSE = 4, ///< One direction is the opposit of the other one
+ DIRDIFF_90LEFT = 6, ///< Angle of 90 degrees left
+ DIRDIFF_45LEFT = 7 ///< Angle of 45 degrees left
+};
+
+
+/**
+ * Enumeration for diagonal directions.
+ *
+ * This enumeration is used for the 4 direction of the tile-edges.
+ */
+enum DiagDirection {
+ DIAGDIR_BEGIN = 0, ///< Used for iterations
+ DIAGDIR_NE = 0, ///< Northeast, upper right on your monitor
+ DIAGDIR_SE = 1, ///< Southeast
+ DIAGDIR_SW = 2, ///< Southwest
+ DIAGDIR_NW = 3, ///< Northwest
+ DIAGDIR_END, ///< Used for iterations
+ INVALID_DIAGDIR = 0xFF, ///< Flag for an invalid DiagDirection
+};
+
+DECLARE_POSTFIX_INCREMENT(DiagDirection);
+
+/** Define basic enum properties */
+template <> struct EnumPropsT<DiagDirection> : MakeEnumPropsT<DiagDirection, byte, DIAGDIR_BEGIN, DIAGDIR_END, INVALID_DIAGDIR> {};
+typedef TinyEnumT<DiagDirection> DiagDirectionByte; //typedefing-enumification of DiagDirection
+
+
+/**
+ * Enumeration for the difference between to DiagDirection.
+ *
+ * As the DiagDirection only contains 4 possible directions the
+ * difference between two of these directions can only be in 4 ways.
+ * As the DirDiff enumeration the values can be added together and
+ * you will get the resulting difference (use modulo DIAGDIR_END).
+ *
+ * @see DirDiff
+ */
+enum DiagDirDiff {
+ DIAGDIRDIFF_SAME = 0, ///< Same directions
+ DIAGDIRDIFF_90RIGHT = 1, ///< 90 degrees right
+ DIAGDIRDIFF_REVERSE = 2, ///< Reverse directions
+ DIAGDIRDIFF_90LEFT = 3 ///< 90 degrees left
+};
+
+/** Allow incrementing of DiagDirDiff variables */
+DECLARE_POSTFIX_INCREMENT(DiagDirDiff);
+
+
+/**
+ * Enumeration for the two axis X and Y
+ *
+ * This enumeration represente the two axis X and Y in the game.
+ * The X axis is the one which goes align the north-west edge
+ * (and south-east edge). The Y axis must be so the one which goes
+ * align the north-east edge (and south-west) edge.
+ */
+enum Axis {
+ AXIS_X = 0, ///< The X axis
+ AXIS_Y = 1, ///< The y axis
+ AXIS_END ///< Used for iterations
+};
+
+#endif /* DIRECTION_TYPE_H */
diff --git a/src/helpers.hpp b/src/helpers.hpp
index 651cb0f3c..d7bedae55 100644
--- a/src/helpers.hpp
+++ b/src/helpers.hpp
@@ -6,6 +6,7 @@
#define HELPERS_HPP
#include "macros.h"
+#include "core/enum_type.hpp"
/** When allocating using malloc/calloc in C++ it is usually needed to cast the return value
* from void* to the proper pointer type. Another alternative would be MallocT<> as follows */
@@ -42,113 +43,6 @@ template<typename T> void Swap(T& a, T& b)
}
-/** Some enums need to have allowed incrementing (i.e. StationClassID) */
-#define DECLARE_POSTFIX_INCREMENT(type) \
- FORCEINLINE type operator ++(type& e, int) \
- { \
- type e_org = e; \
- e = (type)((int)e + 1); \
- return e_org; \
- } \
- FORCEINLINE type operator --(type& e, int) \
- { \
- type e_org = e; \
- e = (type)((int)e - 1); \
- return e_org; \
- }
-
-
-
-/** Operators to allow to work with enum as with type safe bit set in C++ */
-# define DECLARE_ENUM_AS_BIT_SET(mask_t) \
- FORCEINLINE mask_t operator | (mask_t m1, mask_t m2) {return (mask_t)((int)m1 | m2);} \
- FORCEINLINE mask_t operator & (mask_t m1, mask_t m2) {return (mask_t)((int)m1 & m2);} \
- FORCEINLINE mask_t operator ^ (mask_t m1, mask_t m2) {return (mask_t)((int)m1 ^ m2);} \
- FORCEINLINE mask_t& operator |= (mask_t& m1, mask_t m2) {m1 = m1 | m2; return m1;} \
- FORCEINLINE mask_t& operator &= (mask_t& m1, mask_t m2) {m1 = m1 & m2; return m1;} \
- FORCEINLINE mask_t& operator ^= (mask_t& m1, mask_t m2) {m1 = m1 ^ m2; return m1;} \
- FORCEINLINE mask_t operator ~(mask_t m) {return (mask_t)(~(int)m);}
-
-
-/** Informative template class exposing basic enumeration properties used by several
- * other templates below. Here we have only forward declaration. For each enum type
- * we will create specialization derived from MakeEnumPropsT<>.
- * i.e.:
- * template <> struct EnumPropsT<Track> : MakeEnumPropsT<Track, byte, TRACK_BEGIN, TRACK_END, INVALID_TRACK> {};
- * followed by:
- * typedef TinyEnumT<Track> TrackByte;
- */
-template <typename Tenum_t> struct EnumPropsT;
-
-/** Helper template class that makes basic properties of given enumeration type visible
- * from outsize. It is used as base class of several EnumPropsT specializations each
- * dedicated to one of commonly used enumeration types.
- * @param Tenum_t enumeration type that you want to describe
- * @param Tstorage_t what storage type would be sufficient (i.e. byte)
- * @param Tbegin first valid value from the contiguous range (i.e. TRACK_BEGIN)
- * @param Tend one past the last valid value from the contiguous range (i.e. TRACK_END)
- * @param Tinvalid value used as invalid value marker (i.e. INVALID_TRACK)
- */
-template <typename Tenum_t, typename Tstorage_t, Tenum_t Tbegin, Tenum_t Tend, Tenum_t Tinvalid>
-struct MakeEnumPropsT {
- typedef Tenum_t type; ///< enum type (i.e. Trackdir)
- typedef Tstorage_t storage; ///< storage type (i.e. byte)
- static const Tenum_t begin = Tbegin; ///< lowest valid value (i.e. TRACKDIR_BEGIN)
- static const Tenum_t end = Tend; ///< one after the last valid value (i.e. TRACKDIR_END)
- static const Tenum_t invalid = Tinvalid; ///< what value is used as invalid value (i.e. INVALID_TRACKDIR)
-};
-
-
-
-/** In some cases we use byte or uint16 to store values that are defined as enum. It is
- * necessary in order to control the sizeof() such values. Some compilers make enum
- * the same size as int (4 or 8 bytes instead of 1 or 2). As a consequence the strict
- * compiler type-checking causes errors like:
- * 'HasPowerOnRail' : cannot convert parameter 1 from 'byte' to 'RailType' when
- * u->u.rail.railtype is passed as argument or type RailType. In such cases it is better
- * to teach the compiler that u->u.rail.railtype is to be treated as RailType. */
-template <typename Tenum_t> struct TinyEnumT;
-
-/** The general declaration of TinyEnumT<> (above) */
-template <typename Tenum_t> struct TinyEnumT
-{
- typedef Tenum_t enum_type; ///< expose our enumeration type (i.e. Trackdir) to outside
- typedef EnumPropsT<Tenum_t> Props; ///< make easier access to our enumeration propeties
- typedef typename Props::storage storage_type; ///< small storage type
- static const enum_type begin = Props::begin; ///< enum beginning (i.e. TRACKDIR_BEGIN)
- static const enum_type end = Props::end; ///< enum end (i.e. TRACKDIR_END)
- static const enum_type invalid = Props::invalid;///< invalid value (i.e. INVALID_TRACKDIR)
-
- storage_type m_val; ///< here we hold the actual value in small (i.e. byte) form
-
- /** Cast operator - invoked then the value is assigned to the Tenum_t type */
- FORCEINLINE operator enum_type () const
- {
- return (enum_type)m_val;
- }
-
- /** Assignment operator (from Tenum_t type) */
- FORCEINLINE TinyEnumT& operator = (enum_type e)
- {
- m_val = (storage_type)e; return *this;
- }
-
- /** postfix ++ operator on tiny type */
- FORCEINLINE TinyEnumT operator ++ (int)
- {
- TinyEnumT org = *this;
- if (++m_val >= end) m_val -= (storage_type)(end - begin);
- return org;
- }
-
- /** prefix ++ operator on tiny type */
- FORCEINLINE TinyEnumT& operator ++ ()
- {
- if (++m_val >= end) m_val -= (storage_type)(end - begin);
- return *this;
- }
-};
-
/**
* Overflow safe template for integers, i.e. integers that will never overflow
* you multiply the maximum value with 2, or add 2, or substract somethng from
diff --git a/src/map.cpp b/src/map.cpp
index a54760652..60cad92b0 100644
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -8,7 +8,7 @@
#include "functions.h"
#include "macros.h"
#include "map.h"
-#include "direction.h"
+#include "direction_func.h"
#include "helpers.hpp"
#if defined(_MSC_VER) && _MSC_VER >= 1400 /* VStudio 2005 is stupid! */
diff --git a/src/map.h b/src/map.h
index 064e595c1..aac084193 100644
--- a/src/map.h
+++ b/src/map.h
@@ -6,7 +6,7 @@
#define MAP_H
#include "stdafx.h"
-#include "direction.h"
+#include "direction_func.h"
extern uint _map_tile_mask;
diff --git a/src/misc/dbg_helpers.cpp b/src/misc/dbg_helpers.cpp
index 561de50f3..2e95ee1b8 100644
--- a/src/misc/dbg_helpers.cpp
+++ b/src/misc/dbg_helpers.cpp
@@ -2,7 +2,7 @@
/** @file dbg_helpers.cpp */
#include "../stdafx.h"
-#include "../direction.h"
+#include "../direction_type.h"
#include "../rail.h"
#include "../rail_map.h"
#include "dbg_helpers.h"
diff --git a/src/newgrf_engine.h b/src/newgrf_engine.h
index bb86661e2..c94bff9b6 100644
--- a/src/newgrf_engine.h
+++ b/src/newgrf_engine.h
@@ -6,7 +6,7 @@
#define NEWGRF_ENGINE_H
#include "newgrf.h"
-#include "direction.h"
+#include "direction_type.h"
#include "newgrf_cargo.h"
extern int _traininfo_vehicle_pitch;
diff --git a/src/pathfind.h b/src/pathfind.h
index 2bafe97f3..91dd7be6f 100644
--- a/src/pathfind.h
+++ b/src/pathfind.h
@@ -5,7 +5,7 @@
#ifndef PATHFIND_H
#define PATHFIND_H
-#include "direction.h"
+#include "direction_type.h"
#include "openttd.h"
enum {
diff --git a/src/rail.h b/src/rail.h
index 8f965aa7b..30d7e7e4e 100644
--- a/src/rail.h
+++ b/src/rail.h
@@ -6,7 +6,7 @@
#define RAIL_H
#include "gfx.h"
-#include "direction.h"
+#include "direction_func.h"
#include "tile.h"
#include "variables.h"
diff --git a/src/rail_map.h b/src/rail_map.h
index 2b20e9598..3c89b8f78 100644
--- a/src/rail_map.h
+++ b/src/rail_map.h
@@ -5,7 +5,7 @@
#ifndef RAIL_MAP_H
#define RAIL_MAP_H
-#include "direction.h"
+#include "direction_func.h"
#include "rail.h"
#include "tile.h"
diff --git a/src/road_cmd.h b/src/road_cmd.h
index 66ea2f652..c5d98daf2 100644
--- a/src/road_cmd.h
+++ b/src/road_cmd.h
@@ -5,7 +5,7 @@
#ifndef ROAD_CMD_H
#define ROAD_CMD_H
-#include "direction.h"
+#include "direction_type.h"
void DrawRoadDepotSprite(int x, int y, DiagDirection dir, RoadType rt);
diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp
index 2b32faff3..5d56be133 100644
--- a/src/train_cmd.cpp
+++ b/src/train_cmd.cpp
@@ -36,7 +36,7 @@
#include "newgrf_engine.h"
#include "newgrf_sound.h"
#include "newgrf_text.h"
-#include "direction.h"
+#include "direction_func.h"
#include "yapf/yapf.h"
#include "date.h"
#include "cargotype.h"
diff --git a/src/tunnel_map.h b/src/tunnel_map.h
index 921137a6e..5226c1f90 100644
--- a/src/tunnel_map.h
+++ b/src/tunnel_map.h
@@ -5,7 +5,7 @@
#ifndef TUNNEL_MAP_H
#define TUNNEL_MAP_H
-#include "direction.h"
+#include "direction_func.h"
#include "macros.h"
#include "map.h"
#include "rail.h"
diff --git a/src/tunnelbridge_map.h b/src/tunnelbridge_map.h
index dda1cc258..892d4ed58 100644
--- a/src/tunnelbridge_map.h
+++ b/src/tunnelbridge_map.h
@@ -5,7 +5,7 @@
#ifndef TUNNELBRIDGE_MAP_H
#define TUNNELBRIDGE_MAP_H
-#include "direction.h" /* DiagDirection */
+#include "direction_func.h"
#include "core/bitmath_func.hpp" /* GB, HasBit, SB */
#include "map.h" /* Tile, TileIndex */
#include "tile.h" /* TileType, IsTileType */
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-11-23 07:09:08 +0000