1

/* $Id$ */

     2

     3

/** @file road.h */

     4

     5

#ifndef ROAD_H

     6

#define ROAD_H

     7

     8

#include "helpers.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_ROAD = 0,      ///< Basic road type

    17

	ROADTYPE_TRAM = 1,      ///< Trams

    18

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

    19

	ROADTYPE_END,           ///< Used for iterations

    20

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

    21

};

    22

DECLARE_POSTFIX_INCREMENT(RoadType);

    23

    24

/**

    25

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

    26

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

    27

 */

    28

enum RoadTypes {

    29

	ROADTYPES_NONE     = 0,                                                 ///< No roadtypes

    30

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

    31

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

    32

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

    33

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

    34

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

    35

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

    36

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

    37

};

    38

DECLARE_ENUM_AS_BIT_SET(RoadTypes);

    39

    40

/**

    41

 * Whether the given roadtype is valid.

    42

 * @param rt the roadtype to check for validness

    43

 * @return true if and only if valid

    44

 */

    45

static inline bool IsValidRoadType(RoadType rt)

    46

{

    47

	return rt == ROADTYPE_ROAD || rt == ROADTYPE_TRAM;

    48

}

    49

    50

/**

    51

 * Are the given bits pointing to valid roadtypes?

    52

 * @param rts the roadtypes to check for validness

    53

 * @return true if and only if valid

    54

 */

    55

static inline bool AreValidRoadTypes(RoadTypes rts)

    56

{

    57

	return HASBIT(rts, ROADTYPE_ROAD) || HASBIT(rts, ROADTYPE_TRAM);

    58

}

    59

    60

/**

    61

 * Maps a RoadType to the corresponding RoadTypes value

    62

 *

    63

 * @param rt the roadtype to get the roadtypes from

    64

 * @return the roadtypes with the given roadtype

    65

 */

    66

static inline RoadTypes RoadTypeToRoadTypes(RoadType rt)

    67

{

    68

	return (RoadTypes)(1 << rt);

    69

}

    70

    71

/**

    72

 * Returns the RoadTypes which are not present in the given RoadTypes

    73

 *

    74

 * This function returns the complement of a given RoadTypes.

    75

 *

    76

 * @param r The given RoadTypes

    77

 * @return The complement of the given RoadTypes

    78

 * @note The unused value ROADTYPES_HWAY will be used, too.

    79

 */

    80

static inline RoadTypes ComplementRoadTypes(RoadTypes r)

    81

{

    82

	return (RoadTypes)(ROADTYPES_ALL ^ r);

    83

}

    84

    85

/**

    86

 * Enumeration for the road parts on a tile.

    87

 *

    88

 * This enumeration defines the possible road parts which

    89

 * can be build on a tile.

    90

 */

    91

enum RoadBits {

    92

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

    93

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

    94

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

    95

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

    96

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

    97

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

    98

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

    99

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

   100

};

   101

   102

DECLARE_ENUM_AS_BIT_SET(RoadBits);

   103

   104

/**

   105

 * Calculate the complement of a RoadBits value

   106

 *

   107

 * Simply flips all bits in the RoadBits value to get the complement

   108

 * of the RoadBits.

   109

 *

   110

 * @param r The given RoadBits value

   111

 * @return the complement

   112

 */

   113

static inline RoadBits ComplementRoadBits(RoadBits r)

   114

{

   115

	return (RoadBits)(ROAD_ALL ^ r);

   116

}

   117

   118

/**

   119

 * Create the road-part which belongs to the given DiagDirection

   120

 *

   121

 * This function returns a RoadBits value which belongs to

   122

 * the given DiagDirection.

   123

 *

   124

 * @param d The DiagDirection

   125

 * @return The result RoadBits which the selected road-part set

   126

 */

   127

static inline RoadBits DiagDirToRoadBits(DiagDirection d)

   128

{

   130

}

   131

   132

/**

   133

 * Checks whether the trackdir means that we are reversing.

   134

 * @param dir the trackdir to check

   135

 * @return true if it is a reversing road trackdir

   136

 */

   137

static inline bool IsReversingRoadTrackdir(Trackdir dir)

   138

{

   139

	return (dir & 0x07) >= 6;

   140

}

   141

   142

/**

   143

 * Checks whether the given trackdir is a straight road

   144

 * @param dir the trackdir to check

   145

 * @return true if it is a straight road trackdir

   146

 */

   147

static inline bool IsStraightRoadTrackdir(Trackdir dir)

   148

{

   149

	return (dir & 0x06) == 0;

   150

}

   151

   152

/**

   153

 * Is it allowed to remove the given road bits from the given tile?

   154

 * @param tile      the tile to remove the road from

   155

 * @param remove    the roadbits that are going to be removed

   156

 * @param owner     the actual owner of the roadbits of the tile

   157

 * @param edge_road are the removed bits from a town?

   158

 * @param rt        the road type to remove the bits from

   159

 * @return true when it is allowed to remove the road bits

   160

 */

   161

bool CheckAllowRemoveRoad(TileIndex tile, RoadBits remove, Owner owner, bool *edge_road, RoadType rt);

   162

   163

/**

   164

 * Draw the catenary for tram road bits

   165

 * @param ti   information about the tile (position, slope)

   166

 * @param tram the roadbits to draw the catenary for

   167

 */

   168

void DrawTramCatenary(TileInfo *ti, RoadBits tram);

   169

   170

#endif /* ROAD_H */