1

/* $Id$ */

     2

     3

/** @file road_type.h Enums and other types related to roads. */

     4

     5

#ifndef ROAD_TYPE_H

     6

#define ROAD_TYPE_H

     7

     8

#include "core/enum_type.hpp"

     9

    10

/**

    11

 * The different roadtypes we support

    12

 *

    13

 * @note currently only ROADTYPE_ROAD and ROADTYPE_TRAM are supported.

    14

 */

    15

enum RoadType {

    16

	ROADTYPE_BEGIN = 0,     ///< Used for iterations

    17

	ROADTYPE_ROAD = 0,      ///< Basic road type

    18

	ROADTYPE_TRAM = 1,      ///< Trams

    19

	ROADTYPE_HWAY = 2,      ///< Only a placeholder. Not sure what we are going to do with this road type.

    20

	ROADTYPE_END,           ///< Used for iterations

    21

	INVALID_ROADTYPE = 0xFF ///< flag for invalid roadtype

    22

};

    23

DECLARE_POSTFIX_INCREMENT(RoadType);

    24

    25

/**

    26

 * The different roadtypes we support, but then a bitmask of them

    27

 * @note currently only roadtypes with ROADTYPE_ROAD and ROADTYPE_TRAM are supported.

    28

 */

    29

enum RoadTypes {

    30

	ROADTYPES_NONE     = 0,                                                 ///< No roadtypes

    31

	ROADTYPES_ROAD     = 1 << ROADTYPE_ROAD,                                ///< Road

    32

	ROADTYPES_TRAM     = 1 << ROADTYPE_TRAM,                                ///< Trams

    33

	ROADTYPES_HWAY     = 1 << ROADTYPE_HWAY,                                ///< Highway (or whatever substitute)

    34

	ROADTYPES_ROADTRAM = ROADTYPES_ROAD | ROADTYPES_TRAM,                   ///< Road + trams

    35

	ROADTYPES_ROADHWAY = ROADTYPES_ROAD | ROADTYPES_HWAY,                   ///< Road + highway (or whatever substitute)

    36

	ROADTYPES_TRAMHWAY = ROADTYPES_TRAM | ROADTYPES_HWAY,                   ///< Trams + highway (or whatever substitute)

    37

	ROADTYPES_ALL      = ROADTYPES_ROAD | ROADTYPES_TRAM | ROADTYPES_HWAY,  ///< Road + trams + highway (or whatever substitute)

    38

	ROADTYPES_END,                                                          ///< Used for iterations?

    39

	INVALID_ROADTYPES  = 0xFF                                               ///< Invalid roadtypes

    40

};

    41

DECLARE_ENUM_AS_BIT_SET(RoadTypes);

    42

template <> struct EnumPropsT<RoadTypes> : MakeEnumPropsT<RoadTypes, byte, ROADTYPES_NONE, ROADTYPES_END, INVALID_ROADTYPES> {};

    43

typedef TinyEnumT<RoadTypes> RoadTypesByte;

    44

    45

    46

/**

    47

 * Enumeration for the road parts on a tile.

    48

 *

    49

 * This enumeration defines the possible road parts which

    50

 * can be build on a tile.

    51

 */

    52

enum RoadBits {

    53

	ROAD_NONE = 0U,                  ///< No road-part is build

    54

	ROAD_NW   = 1U,                  ///< North-west part

    55

	ROAD_SW   = 2U,                  ///< South-west part

    56

	ROAD_SE   = 4U,                  ///< South-east part

    57

	ROAD_NE   = 8U,                  ///< North-east part

    58

	ROAD_X    = ROAD_SW | ROAD_NE,   ///< Full road along the x-axis (south-west + north-east)

    59

	ROAD_Y    = ROAD_NW | ROAD_SE,   ///< Full road along the y-axis (north-west + south-east)

    60

	ROAD_ALL  = ROAD_X  | ROAD_Y     ///< Full 4-way crossing

    61

};

    62

DECLARE_ENUM_AS_BIT_SET(RoadBits);

    63

    64

#endif /* ROAD_TYPE_H */