1

/* $Id$ */

     2

     3

/** @file road_func.h Functions related to roads. */

     4

     5

#ifndef ROAD_FUNC_H

     6

#define ROAD_FUNC_H

     7

     8

#include "core/bitmath_func.hpp"

     9

#include "road_type.h"

    10

    11

/**

    12

 * Whether the given roadtype is valid.

    13

 * @param rt the roadtype to check for validness

    14

 * @return true if and only if valid

    15

 */

    16

static inline bool IsValidRoadType(RoadType rt)

    17

{

    18

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

    19

}

    20

    21

/**

    22

 * Are the given bits pointing to valid roadtypes?

    23

 * @param rts the roadtypes to check for validness

    24

 * @return true if and only if valid

    25

 */

    26

static inline bool AreValidRoadTypes(RoadTypes rts)

    27

{

    28

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

    29

}

    30

    31

/**

    32

 * Maps a RoadType to the corresponding RoadTypes value

    33

 *

    34

 * @param rt the roadtype to get the roadtypes from

    35

 * @return the roadtypes with the given roadtype

    36

 */

    37

static inline RoadTypes RoadTypeToRoadTypes(RoadType rt)

    38

{

    39

	return (RoadTypes)(1 << rt);

    40

}

    41

    42

/**

    43

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

    44

 *

    45

 * This function returns the complement of a given RoadTypes.

    46

 *

    47

 * @param r The given RoadTypes

    48

 * @return The complement of the given RoadTypes

    49

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

    50

 */

    51

static inline RoadTypes ComplementRoadTypes(RoadTypes r)

    52

{

    53

	return (RoadTypes)(ROADTYPES_ALL ^ r);

    54

}

    55

    56

    57

/**

    58

 * Calculate the complement of a RoadBits value

    59

 *

    60

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

    61

 * of the RoadBits.

    62

 *

    63

 * @param r The given RoadBits value

    64

 * @return the complement

    65

 */

    66

static inline RoadBits ComplementRoadBits(RoadBits r)

    67

{

    68

	return (RoadBits)(ROAD_ALL ^ r);

    69

}

    70

    71

/**

    72

 * Calculate the mirrored RoadBits

    73

 *

    74

 * Simply move the bits to their new position.

    75

 *

    76

 * @param r The given RoadBits value

    77

 * @return the mirrored

    78

 */

    79

static inline RoadBits MirrorRoadBits(RoadBits r)

    80

{

    81

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

    82

}

    83

    84

/**

    85

 * Calculate rotated RoadBits

    86

 *

    87

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

    88

 *

    89

 * @param r The given RoadBits value

    90

 * @param rot The given Rotation angle

    91

 * @return the rotated

    92

 */

    93

static inline RoadBits RotateRoadBits(RoadBits r, DiagDirDiff rot)

    94

{

    95

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

    96

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

    97

	}

    98

	return r;

    99

}

   100

   101

/**

   102

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

   103

 *

   104

 * This function returns a RoadBits value which belongs to

   105

 * the given DiagDirection.

   106

 *

   107

 * @param d The DiagDirection

   108

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

   109

 */

   110

static inline RoadBits DiagDirToRoadBits(DiagDirection d)

   111

{

   112

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

   113

}

   114

   115

#endif /* ROAD_FUNC_H */