--- a/src/airport.h	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/airport.h	Tue Dec 18 19:52:14 2007 +0000
@@ -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};

--- a/src/bridge_map.h	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/bridge_map.h	Tue Dec 18 19:52:14 2007 +0000
@@ -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"

--- a/src/cmd_helper.h	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/cmd_helper.h	Tue Dec 18 19:52:14 2007 +0000
@@ -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"
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/core/enum_type.hpp	Tue Dec 18 19:52:14 2007 +0000
@@ -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 */

--- a/src/depot.h	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/depot.h	Tue Dec 18 19:52:14 2007 +0000
@@ -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"

--- a/src/direction.h	Tue Dec 18 18:08:51 2007 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,322 +0,0 @@
-/* $Id$ */
-
-/** @file direction.h */
-
-#ifndef DIRECTION_H
-#define DIRECTION_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
-
-/**
- * Return the reverse of a direction
- *
- * @param d The direction to get the reverse from
- * @return The reverse Direction
- */
-static inline Direction ReverseDir(Direction d)
-{
-	return (Direction)(4 ^ 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
- * @param d1 The second direction as the offset from the base
- * @return The difference how the second directions drifts of the first one.
- */
-static inline DirDiff DirDifference(Direction d0, Direction d1)
-{
-	return (DirDiff)((d0 + 8 - d1) % 8);
-}
-
-/**
- * Applies two differences together
- *
- * This function adds two differences together and return the resulting
- * difference. So adding two DIRDIFF_REVERSE together results in the
- * DIRDIFF_SAME difference.
- *
- * @param d The first difference
- * @param delta The second difference to add on
- * @return The resulting difference
- */
-static inline DirDiff ChangeDirDiff(DirDiff d, DirDiff delta)
-{
-	return (DirDiff)((d + delta) % 8);
-}
-
-/**
- * Change a direction by a given difference
- *
- * This functions returns a new direction of the given direction
- * which is rotated by the given difference.
- *
- * @param d The direction to get a new direction from
- * @param delta The offset/drift applied to the direction
- * @return The new direction
- */
-static inline Direction ChangeDir(Direction d, DirDiff delta)
-{
-	return (Direction)((d + delta) % 8);
-}
-
-
-/**
- * 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
- * @return The reverse direction
- */
-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
- *
- * This function applies a difference on a DiagDirection and returns
- * the new DiagDirection.
- *
- * @param d The DiagDirection
- * @param delta The difference to applie on
- * @return The new direction which was calculated
- */
-static inline DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)
-{
-	return (DiagDirection)((d + delta) % 4);
-}
-
-/**
- * Convert a Direction to a DiagDirection.
- *
- * This function can be used to convert the 8-way Direction to
- * the 4-way DiagDirection. If the direction cannot be mapped its
- * "rounded clockwise". So DIR_N becomes DIAGDIR_NE.
- *
- * @param dir The direction to convert
- * @return The resulting DiagDirection, maybe "rounded clockwise".
- */
-static inline DiagDirection DirToDiagDir(Direction dir)
-{
-	return (DiagDirection)(dir >> 1);
-}
-
-/**
- * Convert a DiagDirection to a Direction.
- *
- * This function can be used to convert the 4-way DiagDirection
- * to the 8-way Direction. As 4-way are less than 8-way not all
- * possible directions can be calculated.
- *
- * @param dir The direction to convert
- * @return The resulting Direction
- */
-static inline Direction DiagDirToDir(DiagDirection dir)
-{
-	return (Direction)(dir * 2 + 1);
-}
-
-
-/**
- * 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.
- *
- * @param a The given axis
- * @return The other axis
- */
-static inline Axis OtherAxis(Axis a)
-{
-	return (Axis)(a ^ 1);
-}
-
-
-/**
- * Convert a DiagDirection to the axis.
- *
- * This function returns the axis which belongs to the given
- * DiagDirection. The axis X belongs to the DiagDirection
- * north-east and south-west.
- *
- * @param d The DiagDirection
- * @return The axis which belongs to the direction
- */
-static inline Axis DiagDirToAxis(DiagDirection d)
-{
-	return (Axis)(d & 1);
-}
-
-
-/**
- * Converts an Axis to a DiagDirection
- *
- * This function returns the DiagDirection which
- * belongs to the axis. As 2 directions are mapped to an axis
- * this function returns the one which points to south,
- * either south-west (on X axis) or south-east (on Y axis)
- *
- * @param a The axis
- * @return The direction pointed to south
- */
-static inline DiagDirection AxisToDiagDir(Axis a)
-{
-	return (DiagDirection)(2 - a);
-}
-
-/**
- * Convert an axis and a flag for north/south into a DiagDirection
- * @param xy axis to convert
- * @param ns north -> 0, south -> 1
- * @return the desired DiagDirection
- */
-static inline DiagDirection XYNSToDiagDir(Axis xy, uint ns)
-{
-	return (DiagDirection)(xy * 3 ^ ns * 2);
-}
-
-/**
- * Checks if an interger value is a valid DiagDirection
- *
- * @param d The value to check
- * @return True if the value belongs to a DiagDirection, else false
- */
-static inline bool IsValidDiagDirection(DiagDirection d)
-{
-	return d < DIAGDIR_END;
-}
-
-/**
- * Checks if an integer value is a valid Direction
- *
- * @param d The value to check
- * @return True if the value belongs to a Direction, else false
- */
-static inline bool IsValidDirection(Direction d)
-{
-	return d < DIR_END;
-}
-
-/**
- * Checks if an integer value is a valid Axis
- *
- * @param d The value to check
- * @return True if the value belongs to an Axis, else false
- */
-static inline bool IsValidAxis(Axis d)
-{
-	return d < AXIS_END;
-}
-
-#endif /* DIRECTION_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/direction_func.h	Tue Dec 18 19:52:14 2007 +0000
@@ -0,0 +1,214 @@
+/* $Id$ */
+
+/** @file direction_func.h Different functions related to conversions between directions. */
+
+#ifndef DIRECTION_FUNC_H
+#define DIRECTION_FUNC_H
+
+#include "direction_type.h"
+
+/**
+ * Return the reverse of a direction
+ *
+ * @param d The direction to get the reverse from
+ * @return The reverse Direction
+ */
+static inline Direction ReverseDir(Direction d)
+{
+	return (Direction)(4 ^ d);
+}
+
+
+/**
+ * Calculate the difference between to directions
+ *
+ * @param d0 The first direction as the base
+ * @param d1 The second direction as the offset from the base
+ * @return The difference how the second directions drifts of the first one.
+ */
+static inline DirDiff DirDifference(Direction d0, Direction d1)
+{
+	return (DirDiff)((d0 + 8 - d1) % 8);
+}
+
+/**
+ * Applies two differences together
+ *
+ * This function adds two differences together and return the resulting
+ * difference. So adding two DIRDIFF_REVERSE together results in the
+ * DIRDIFF_SAME difference.
+ *
+ * @param d The first difference
+ * @param delta The second difference to add on
+ * @return The resulting difference
+ */
+static inline DirDiff ChangeDirDiff(DirDiff d, DirDiff delta)
+{
+	return (DirDiff)((d + delta) % 8);
+}
+
+/**
+ * Change a direction by a given difference
+ *
+ * This functions returns a new direction of the given direction
+ * which is rotated by the given difference.
+ *
+ * @param d The direction to get a new direction from
+ * @param delta The offset/drift applied to the direction
+ * @return The new direction
+ */
+static inline Direction ChangeDir(Direction d, DirDiff delta)
+{
+	return (Direction)((d + delta) % 8);
+}
+
+
+/**
+ * Returns the reverse direction of the given DiagDirection
+ *
+ * @param d The DiagDirection to get the reverse from
+ * @return The reverse direction
+ */
+static inline DiagDirection ReverseDiagDir(DiagDirection d)
+{
+	return (DiagDirection)(2 ^ d);
+}
+
+
+/**
+ * Applies a difference on a DiagDirection
+ *
+ * This function applies a difference on a DiagDirection and returns
+ * the new DiagDirection.
+ *
+ * @param d The DiagDirection
+ * @param delta The difference to applie on
+ * @return The new direction which was calculated
+ */
+static inline DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)
+{
+	return (DiagDirection)((d + delta) % 4);
+}
+
+/**
+ * Convert a Direction to a DiagDirection.
+ *
+ * This function can be used to convert the 8-way Direction to
+ * the 4-way DiagDirection. If the direction cannot be mapped its
+ * "rounded clockwise". So DIR_N becomes DIAGDIR_NE.
+ *
+ * @param dir The direction to convert
+ * @return The resulting DiagDirection, maybe "rounded clockwise".
+ */
+static inline DiagDirection DirToDiagDir(Direction dir)
+{
+	return (DiagDirection)(dir >> 1);
+}
+
+/**
+ * Convert a DiagDirection to a Direction.
+ *
+ * This function can be used to convert the 4-way DiagDirection
+ * to the 8-way Direction. As 4-way are less than 8-way not all
+ * possible directions can be calculated.
+ *
+ * @param dir The direction to convert
+ * @return The resulting Direction
+ */
+static inline Direction DiagDirToDir(DiagDirection dir)
+{
+	return (Direction)(dir * 2 + 1);
+}
+
+
+/**
+ * Select the other axis as provided.
+ *
+ * This is basically the not-operator for the axis.
+ *
+ * @param a The given axis
+ * @return The other axis
+ */
+static inline Axis OtherAxis(Axis a)
+{
+	return (Axis)(a ^ 1);
+}
+
+
+/**
+ * Convert a DiagDirection to the axis.
+ *
+ * This function returns the axis which belongs to the given
+ * DiagDirection. The axis X belongs to the DiagDirection
+ * north-east and south-west.
+ *
+ * @param d The DiagDirection
+ * @return The axis which belongs to the direction
+ */
+static inline Axis DiagDirToAxis(DiagDirection d)
+{
+	return (Axis)(d & 1);
+}
+
+
+/**
+ * Converts an Axis to a DiagDirection
+ *
+ * This function returns the DiagDirection which
+ * belongs to the axis. As 2 directions are mapped to an axis
+ * this function returns the one which points to south,
+ * either south-west (on X axis) or south-east (on Y axis)
+ *
+ * @param a The axis
+ * @return The direction pointed to south
+ */
+static inline DiagDirection AxisToDiagDir(Axis a)
+{
+	return (DiagDirection)(2 - a);
+}
+
+/**
+ * Convert an axis and a flag for north/south into a DiagDirection
+ * @param xy axis to convert
+ * @param ns north -> 0, south -> 1
+ * @return the desired DiagDirection
+ */
+static inline DiagDirection XYNSToDiagDir(Axis xy, uint ns)
+{
+	return (DiagDirection)(xy * 3 ^ ns * 2);
+}
+
+/**
+ * Checks if an interger value is a valid DiagDirection
+ *
+ * @param d The value to check
+ * @return True if the value belongs to a DiagDirection, else false
+ */
+static inline bool IsValidDiagDirection(DiagDirection d)
+{
+	return d < DIAGDIR_END;
+}
+
+/**
+ * Checks if an integer value is a valid Direction
+ *
+ * @param d The value to check
+ * @return True if the value belongs to a Direction, else false
+ */
+static inline bool IsValidDirection(Direction d)
+{
+	return d < DIR_END;
+}
+
+/**
+ * Checks if an integer value is a valid Axis
+ *
+ * @param d The value to check
+ * @return True if the value belongs to an Axis, else false
+ */
+static inline bool IsValidAxis(Axis d)
+{
+	return d < AXIS_END;
+}
+
+#endif /* DIRECTION_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/direction_type.h	Tue Dec 18 19:52:14 2007 +0000
@@ -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 */

--- a/src/helpers.hpp	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/helpers.hpp	Tue Dec 18 19:52:14 2007 +0000
@@ -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 @@
 }
 
 
-/** 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

--- a/src/map.cpp	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/map.cpp	Tue Dec 18 19:52:14 2007 +0000
@@ -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! */

--- a/src/map.h	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/map.h	Tue Dec 18 19:52:14 2007 +0000
@@ -6,7 +6,7 @@
 #define MAP_H
 
 #include "stdafx.h"
-#include "direction.h"
+#include "direction_func.h"
 
 extern uint _map_tile_mask;
 

--- a/src/misc/dbg_helpers.cpp	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/misc/dbg_helpers.cpp	Tue Dec 18 19:52:14 2007 +0000
@@ -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"

--- a/src/newgrf_engine.h	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/newgrf_engine.h	Tue Dec 18 19:52:14 2007 +0000
@@ -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;

--- a/src/pathfind.h	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/pathfind.h	Tue Dec 18 19:52:14 2007 +0000
@@ -5,7 +5,7 @@
 #ifndef PATHFIND_H
 #define PATHFIND_H
 
-#include "direction.h"
+#include "direction_type.h"
 #include "openttd.h"
 
 enum {

--- a/src/rail.h	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/rail.h	Tue Dec 18 19:52:14 2007 +0000
@@ -6,7 +6,7 @@
 #define RAIL_H
 
 #include "gfx.h"
-#include "direction.h"
+#include "direction_func.h"
 #include "tile.h"
 #include "variables.h"
 

--- a/src/rail_map.h	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/rail_map.h	Tue Dec 18 19:52:14 2007 +0000
@@ -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"
 

--- a/src/road_cmd.h	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/road_cmd.h	Tue Dec 18 19:52:14 2007 +0000
@@ -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);
 

--- a/src/train_cmd.cpp	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/train_cmd.cpp	Tue Dec 18 19:52:14 2007 +0000
@@ -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"

--- a/src/tunnel_map.h	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/tunnel_map.h	Tue Dec 18 19:52:14 2007 +0000
@@ -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"

--- a/src/tunnelbridge_map.h	Tue Dec 18 18:08:51 2007 +0000
+++ b/src/tunnelbridge_map.h	Tue Dec 18 19:52:14 2007 +0000
@@ -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 */