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

typedef enum RoadType {

    32

	ROAD_NORMAL,

    33

	ROAD_CROSSING,

    34

	ROAD_DEPOT

    35

} RoadType;

    36

    37

static inline RoadType GetRoadType(TileIndex t)

    38

{

    39

	assert(IsTileType(t, MP_STREET));

    40

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

    41

}

    42

    43

    44

static inline RoadBits GetRoadBits(TileIndex t)

    45

{

    46

	assert(GetRoadType(t) == ROAD_NORMAL);

    47

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

    48

}

    49

    50

static inline void SetRoadBits(TileIndex t, RoadBits r)

    51

{

    52

	assert(GetRoadType(t) == ROAD_NORMAL); // XXX incomplete

    53

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

    54

}

    55

    56

    57

static inline Axis GetCrossingRoadAxis(TileIndex t)

    58

{

    59

	assert(GetRoadType(t) == ROAD_CROSSING);

    60

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

    61

}

    62

    63

static inline RoadBits GetCrossingRoadBits(TileIndex tile)

    64

{

    65

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

    66

}

    67

    68

static inline TrackBits GetCrossingRailBits(TileIndex tile)

    69

{

    70

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

    71

}

    72

    73

    74

// TODO swap owner of road and rail

    75

static inline Owner GetCrossingRoadOwner(TileIndex t)

    76

{

    77

	assert(GetRoadType(t) == ROAD_CROSSING);

    78

	return (Owner)_m[t].m3;

    79

}

    80

    81

static inline void SetCrossingRoadOwner(TileIndex t, Owner o)

    82

{

    83

	assert(GetRoadType(t) == ROAD_CROSSING);

    84

	_m[t].m3 = o;

    85

}

    86

    87

static inline void UnbarCrossing(TileIndex t)

    88

{

    89

	assert(GetRoadType(t) == ROAD_CROSSING);

    90

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

    91

}

    92

    93

static inline void BarCrossing(TileIndex t)

    94

{

    95

	assert(GetRoadType(t) == ROAD_CROSSING);

    96

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

    97

}

    98

    99

static inline bool IsCrossingBarred(TileIndex t)

   100

{

   101

	assert(GetRoadType(t) == ROAD_CROSSING);

   102

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

   103

}

   104

   105

   106

static inline DiagDirection GetRoadDepotDirection(TileIndex t)

   107

{

   108

	assert(GetRoadType(t) == ROAD_DEPOT);

   109

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

   110

}

   111

   112

   113

/**

   114

 * Returns the RoadBits on an arbitrary tile

   115

 * Special behavior:

   116

 * - road depots: entrance is treated as road piece

   117

 * - road tunnels: entrance is treated as road piece

   118

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

   119

 * - bridge middle parts: bridge itself is ignored

   120

 */

   121

RoadBits GetAnyRoadBits(TileIndex);

   122

   123

   124

TrackBits GetAnyRoadTrackBits(TileIndex tile);

   125

   126

   127

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

   128

{

   129

	SetTileType(t, MP_STREET);

   130

	SetTileOwner(t, owner);

   131

	_m[t].m2 = town;

   132

	_m[t].m3 = 0;

   133

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

   134

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

   135

}

   136

   137

   138

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

   139

{

   140

	SetTileType(t, MP_STREET);

   141

	SetTileOwner(t, rail);

   142

	_m[t].m2 = town;

   143

	_m[t].m3 = road;

   144

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

   145

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

   146

}

   147

   148

   149

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

   150

{

   151

	SetTileType(t, MP_STREET);

   152

	SetTileOwner(t, owner);

   153

	_m[t].m2 = 0;

   154

	_m[t].m3 = 0;

   155

	_m[t].m4 = 0;

   156

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

   157

}

   158

   159

#endif