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

#define IsOnDesert IsOnSnow

   106

static inline bool IsOnSnow(TileIndex t)

   107

{

   108

	return HASBIT(_m[t].m4, 7);

   109

}

   110

   111

#define ToggleDesert ToggleSnow

   112

static inline void ToggleSnow(TileIndex t)

   113

{

   114

	TOGGLEBIT(_m[t].m4, 7);

   115

}

   116

   117

typedef enum RoadGroundType {

   118

	RGT_BARREN,

   119

	RGT_GRASS,

   120

	RGT_PAVED,

   121

	RGT_LIGHT,

   122

	RGT_NOT_IN_USE, /* Has something to do with fund buildings */

   123

	RGT_ALLEY,

   124

	RGT_ROADWORK_GRASS,

   125

	RGT_ROADWORK_PAVED,

   126

   127

	RGT_ROADWORK_OFFSET = RGT_ROADWORK_GRASS - RGT_GRASS

   128

} RoadGroundType;

   129

   130

static inline RoadGroundType GetGroundType(TileIndex t)

   131

{

   132

	return (RoadGroundType)GB(_m[t].m4, 4, 3);

   133

}

   134

   135

static inline void SetGroundType(TileIndex t, RoadGroundType rgt)

   136

{

   137

	SB(_m[t].m4, 4, 3, rgt);

   138

}

   139

   140

static inline bool HasRoadWorks(TileIndex t)

   141

{

   142

	return GetGroundType(t) >= RGT_ROADWORK_GRASS;

   143

}

   144

   145

static inline bool IncreaseRoadWorksCounter(TileIndex t)

   146

{

   147

	AB(_m[t].m4, 0, 4, 1);

   148

   149

	return GB(_m[t].m4, 0, 4) == 15;

   150

}

   151

   152

static inline void StartRoadWorks(TileIndex t)

   153

{

   154

	assert(!HasRoadWorks(t));

   155

	/* Remove any trees or lamps in case or roadwork */

   156

	SetGroundType(t, min(GetGroundType(t), RGT_PAVED) + RGT_ROADWORK_OFFSET);

   157

}

   158

   159

static inline void TerminateRoadWorks(TileIndex t)

   160

{

   161

	assert(HasRoadWorks(t));

   162

	SetGroundType(t, GetGroundType(t) - RGT_ROADWORK_OFFSET);

   163

	/* Stop the counter */

   164

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

   165

}

   166

   167

static inline bool HasPavement(TileIndex t)

   168

{

   169

	return GetGroundType(t) >= RGT_PAVED && GetGroundType(t) != RGT_ROADWORK_GRASS;

   170

}

   171

   172

static inline DiagDirection GetRoadDepotDirection(TileIndex t)

   173

{

   174

	assert(GetRoadType(t) == ROAD_DEPOT);

   175

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

   176

}

   177

   178

   179

/**

   180

 * Returns the RoadBits on an arbitrary tile

   181

 * Special behavior:

   182

 * - road depots: entrance is treated as road piece

   183

 * - road tunnels: entrance is treated as road piece

   184

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

   185

 * - bridge middle parts: bridge itself is ignored

   186

 */

   187

RoadBits GetAnyRoadBits(TileIndex);

   188

   189

   190

TrackBits GetAnyRoadTrackBits(TileIndex tile);

   191

   192

   193

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

   194

{

   195

	SetTileType(t, MP_STREET);

   196

	SetTileOwner(t, owner);

   197

	_m[t].m2 = town;

   198

	_m[t].m3 = 0;

   199

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

   200

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

   201

}

   202

   203

   204

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

   205

{

   206

	SetTileType(t, MP_STREET);

   207

	SetTileOwner(t, rail);

   208

	_m[t].m2 = town;

   209

	_m[t].m3 = road;

   210

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

   211

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

   212

}

   213

   214

   215

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

   216

{

   217

	SetTileType(t, MP_STREET);

   218

	SetTileOwner(t, owner);

   219

	_m[t].m2 = 0;

   220

	_m[t].m3 = 0;

   221

	_m[t].m4 = 0;

   222

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

   223

}

   224

   225

#endif