Mercurial > hg > openttd
changeset 8100:6d739a5490a9 draft
(svn r11661) -Codechange: some header reworks in order to try to reduce the compile time of OpenTTD by reduce the amount of circular-ish dependencies.
author | rubidium <rubidium@openttd.org> |
---|---|
date | Tue, 18 Dec 2007 19:52:14 +0000 |
parents | 2ed2e5ba55ef |
children | b222582555cb |
files | src/airport.h src/bridge_map.h src/cmd_helper.h src/core/enum_type.hpp src/depot.h src/direction.h src/direction_func.h src/direction_type.h src/helpers.hpp src/map.cpp src/map.h src/misc/dbg_helpers.cpp src/newgrf_engine.h src/pathfind.h src/rail.h src/rail_map.h src/road_cmd.h src/train_cmd.cpp src/tunnel_map.h src/tunnelbridge_map.h |
diffstat | 20 files changed, 467 insertions(+), 444 deletions(-) [+] |
line wrap: on
line diff
--- 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};
--- 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"
--- 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"
new file mode 100644 --- /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 */
--- 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"
deleted file mode 100644 --- a/src/direction.h +++ /dev/null @@ -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 */
new file mode 100644 --- /dev/null +++ b/src/direction_func.h @@ -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 */
new file mode 100644 --- /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 */
--- 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 @@ } -/** 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 +++ 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! */
--- 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;
--- 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"
--- 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;
--- 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 {
--- 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"
--- 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"
--- 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);
--- 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"
--- 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"
--- 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 */