1

/* $Id$ */

     2

     3

#ifndef ROAD_MAP_H

     4

#define ROAD_MAP_H

     5

     6

#include "macros.h"

     7

#include "rail.h"

     8

#include "tile.h"

     9

    10

typedef enum RoadBits {

    11

	ROAD_NW  = 1,

    12

	ROAD_SW  = 2,

    13

	ROAD_SE  = 4,

    14

	ROAD_NE  = 8,

    15

	ROAD_X   = ROAD_SW | ROAD_NE,

    16

	ROAD_Y   = ROAD_NW | ROAD_SE,

    17

	ROAD_ALL = ROAD_X  | ROAD_Y

    18

} RoadBits;

    19

    20

static inline RoadBits ComplementRoadBits(RoadBits r)

    21

{

    22

	return ROAD_ALL ^ r;

    23

}

    24

    25

static inline RoadBits DiagDirToRoadBits(DiagDirection d)

    26

{

    27

	return 1 << (3 ^ d);

    28

}

    29

    30

    31

static inline RoadBits GetRoadBits(TileIndex tile)

    32

{

    33

	return GB(_m[tile].m5, 0, 4);

    34

}

    35

    36

static inline void SetRoadBits(TileIndex tile, RoadBits r)

    37

{

    38

	SB(_m[tile].m5, 0, 4, r);

    39

}

    40

    41

    42

static inline Axis GetCrossingRoadAxis(TileIndex tile)

    43

{

    44

	return (Axis)GB(_m[tile].m5, 3, 1);

    45

}

    46

    47

static inline RoadBits GetCrossingRoadBits(TileIndex tile)

    48

{

    49

	return GetCrossingRoadAxis(tile) == AXIS_X ? ROAD_X : ROAD_Y;

    50

}

    51

    52

static inline TrackBits GetCrossingRailBits(TileIndex tile)

    53

{

    54

	return GetCrossingRoadAxis(tile) == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X;

    55

}

    56

    57

    58

// TODO swap owner of road and rail

    59

static inline Owner GetCrossingRoadOwner(TileIndex t)

    60

{

    61

	return (Owner)_m[t].m3;

    62

}

    63

    64

static inline void SetCrossingRoadOwner(TileIndex t, Owner o)

    65

{

    66

	_m[t].m3 = o;

    67

}

    68

    69

static inline void UnbarCrossing(TileIndex t)

    70

{

    71

	CLRBIT(_m[t].m5, 2);

    72

}

    73

    74

static inline void BarCrossing(TileIndex t)

    75

{

    76

	SETBIT(_m[t].m5, 2);

    77

}

    78

    79

static inline bool IsCrossingBarred(TileIndex t)

    80

{

    81

	return HASBIT(_m[t].m5, 2);

    82

}

    83

    84

typedef enum RoadType {

    85

	ROAD_NORMAL,

    86

	ROAD_CROSSING,

    87

	ROAD_DEPOT

    88

} RoadType;

    89

    90

static inline RoadType GetRoadType(TileIndex tile)

    91

{

    92

	return GB(_m[tile].m5, 4, 4);

    93

}

    94

    95

    96

static inline DiagDirection GetRoadDepotDirection(TileIndex tile)

    97

{

    98

	return (DiagDirection)GB(_m[tile].m5, 0, 2);

    99

}

   100

   101

   102

/**

   103

 * Returns the RoadBits on an arbitrary tile

   104

 * Special behavior:

   105

 * - road depots: entrance is treated as road piece

   106

 * - road tunnels: entrance is treated as road piece

   107

 * - bridge ramps: start of the ramp is treated as road piece

   108

 * - bridge middle parts: bridge itself is ignored

   109

 */

   110

RoadBits GetAnyRoadBits(TileIndex);

   111

   112

   113

TrackBits GetAnyRoadTrackBits(TileIndex tile);

   114

   115

   116

static inline void MakeRoadNormal(TileIndex t, Owner owner, RoadBits bits, uint town)

   117

{

   118

	SetTileType(t, MP_STREET);

   119

	SetTileOwner(t, owner);

   120

	_m[t].m2 = town;

   121

	_m[t].m3 = 0;

   122

	_m[t].m4 = 0 << 7 | 0 << 4 | 0;

   123

	_m[t].m5 = ROAD_NORMAL << 4 | bits;

   124

}

   125

   126

   127

static inline void MakeRoadCrossing(TileIndex t, Owner road, Owner rail, Axis roaddir, RailType rt, uint town)

   128

{

   129

	SetTileType(t, MP_STREET);

   130

	SetTileOwner(t, rail);

   131

	_m[t].m2 = town;

   132

	_m[t].m3 = road;

   133

	_m[t].m4 = 0 << 7 | 0 << 4 | rt;

   134

	_m[t].m5 = ROAD_CROSSING << 4 | roaddir << 3 | 0 << 2;

   135

}

   136

   137

   138

static inline void MakeRoadDepot(TileIndex t, Owner owner, DiagDirection dir)

   139

{

   140

	SetTileType(t, MP_STREET);

   141

	SetTileOwner(t, owner);

   142

	_m[t].m2 = 0;

   143

	_m[t].m3 = 0;

   144

	_m[t].m4 = 0;

   145

	_m[t].m5 = ROAD_DEPOT << 4 | dir;

   146

}

   147

   148

#endif