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

 * Calculate the mirrored RoadBits

   120

 *

   121

 * Simply move the bits to their new position.

   122

 *

   123

 * @param r The given RoadBits value

   124

 * @return the mirrored

   125

 */

   126

static inline RoadBits MirrorRoadBits(RoadBits r)

   127

{

   128

	return (RoadBits)(GB(r, 0, 2) << 2 | GB(r, 2, 2));

   129

}

   130

   131

/**

   132

 * Calculate rotated RoadBits

   133

 *

   134

 * Move the Roadbits clockwise til they are in their final position.

   135

 *

   136

 * @param r The given RoadBits value

   137

 * @param rot The given Rotation angle

   138

 * @return the rotated

   139

 */

   140

static inline RoadBits RotateRoadBits(RoadBits r, DiagDirDiff rot)

   141

{

   142

	for (; rot > (DiagDirDiff)0; rot--){

   143

		r = (RoadBits)(GB(r, 0, 1) << 3 | GB(r, 1, 3));

   144

	}

   145

	return r;

   146

}

   147

   148

/**

   149

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

   150

 *

   151

 * This function returns a RoadBits value which belongs to

   152

 * the given DiagDirection.

   153

 *

   154

 * @param d The DiagDirection

   155

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

   156

 */

   157

static inline RoadBits DiagDirToRoadBits(DiagDirection d)

   158

{

   159

	return (RoadBits)(ROAD_NW << (3 ^ d));

   160

}

   161

   162

/**

   163

 * Return if the tile is a valid tile for a crossing.

   164

 *

   165

 * @note function is overloaded

   166

 * @param tile the curent tile

   167

 * @param ax the axis of the road over the rail

   168

 * @return true if it is a valid tile

   169

 */

   170

bool IsPossibleCrossing(const TileIndex tile, Axis ax);

   171

   172

/**

   173

 * Checks whether the trackdir means that we are reversing.

   174

 * @param dir the trackdir to check

   175

 * @return true if it is a reversing road trackdir

   176

 */

   177

static inline bool IsReversingRoadTrackdir(Trackdir dir)

   178

{

   179

	return (dir & 0x07) >= 6;

   180

}

   181

   182

/**

   183

 * Checks whether the given trackdir is a straight road

   184

 * @param dir the trackdir to check

   185

 * @return true if it is a straight road trackdir

   186

 */

   187

static inline bool IsStraightRoadTrackdir(Trackdir dir)

   188

{

   189

	return (dir & 0x06) == 0;

   190

}

   191

   192

/**

   193

 * Clean up unneccesary RoadBits of a planed tile.

   194

 * @param tile current tile

   195

 * @param org_rb planed RoadBits

   196

 * @return optimised RoadBits

   197

 */

   198

RoadBits CleanUpRoadBits(const TileIndex tile, RoadBits org_rb);

   199

   200

/**

   201

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

   202

 * @param tile      the tile to remove the road from

   203

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

   204

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

   205

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

   206

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

   207

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

   208

 */

   209

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

   210

   211

/**

   212

 * Draw the catenary for tram road bits

   213

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

   214

 * @param tram the roadbits to draw the catenary for

   215

 */

   216

void DrawTramCatenary(TileInfo *ti, RoadBits tram);

   217

   218

#endif /* ROAD_H */