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

    48

    49

static inline RoadBits GetRoadBits(TileIndex t)

    50

{

    51

	assert(GetRoadType(t) == ROAD_NORMAL);

    52

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

    53

}

    54

    55

static inline void SetRoadBits(TileIndex t, RoadBits r)

    56

{

    57

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

    58

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

    59

}

    60

    61

    62

static inline Axis GetCrossingRoadAxis(TileIndex t)

    63

{

    64

	assert(GetRoadType(t) == ROAD_CROSSING);

    65

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

    66

}

    67

    68

static inline RoadBits GetCrossingRoadBits(TileIndex tile)

    69

{

    70

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

    71

}

    72

    73

static inline TrackBits GetCrossingRailBits(TileIndex tile)

    74

{

    75

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

    76

}

    77

    78

    79

// TODO swap owner of road and rail

    80

static inline Owner GetCrossingRoadOwner(TileIndex t)

    81

{

    82

	assert(GetRoadType(t) == ROAD_CROSSING);

    83

	return (Owner)_m[t].m3;

    84

}

    85

    86

static inline void SetCrossingRoadOwner(TileIndex t, Owner o)

    87

{

    88

	assert(GetRoadType(t) == ROAD_CROSSING);

    89

	_m[t].m3 = o;

    90

}

    91

    92

static inline void UnbarCrossing(TileIndex t)

    93

{

    94

	assert(GetRoadType(t) == ROAD_CROSSING);

    95

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

    96

}

    97

    98

static inline void BarCrossing(TileIndex t)

    99

{

   100

	assert(GetRoadType(t) == ROAD_CROSSING);

   101

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

   102

}

   103

   104

static inline bool IsCrossingBarred(TileIndex t)

   105

{

   106

	assert(GetRoadType(t) == ROAD_CROSSING);

   107

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

   108

}

   109

   110

#define IsOnDesert IsOnSnow

   111

static inline bool IsOnSnow(TileIndex t)

   112

{

   113

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

   114

}

   115

   116

#define ToggleDesert ToggleSnow

   117

static inline void ToggleSnow(TileIndex t)

   118

{

   119

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

   120

}

   121

   122

typedef enum RoadGroundType {

   123

	RGT_BARREN,

   124

	RGT_GRASS,

   125

	RGT_PAVED,

   126

	RGT_LIGHT,

   127

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

   128

	RGT_ALLEY,

   129

	RGT_ROADWORK_GRASS,

   130

	RGT_ROADWORK_PAVED,

   131

   132

	RGT_ROADWORK_OFFSET = RGT_ROADWORK_GRASS - RGT_GRASS

   133

} RoadGroundType;

   134

   135

static inline RoadGroundType GetGroundType(TileIndex t)

   136

{

   137

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

   138

}

   139

   140

static inline void SetGroundType(TileIndex t, RoadGroundType rgt)

   141

{

   142

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

   143

}

   144

   145

static inline bool HasRoadWorks(TileIndex t)

   146

{

   147

	return GetGroundType(t) >= RGT_ROADWORK_GRASS;

   148

}

   149

   150

static inline bool IncreaseRoadWorksCounter(TileIndex t)

   151

{

   152

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

   153

   154

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

   155

}

   156

   157

static inline void StartRoadWorks(TileIndex t)

   158

{

   159

	assert(!HasRoadWorks(t));

   160

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

   161

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

   162

}

   163

   164

static inline void TerminateRoadWorks(TileIndex t)

   165

{

   166

	assert(HasRoadWorks(t));

   167

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

   168

	/* Stop the counter */

   169

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

   170

}

   171

   172

static inline bool HasPavement(TileIndex t)

   173

{

   174

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

   175

}

   176

   177

static inline DiagDirection GetRoadDepotDirection(TileIndex t)

   178

{

   179

	assert(GetRoadType(t) == ROAD_DEPOT);

   180

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

   181

}

   182

   183

   184

/**

   185

 * Returns the RoadBits on an arbitrary tile

   186

 * Special behavior:

   187

 * - road depots: entrance is treated as road piece

   188

 * - road tunnels: entrance is treated as road piece

   189

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

   190

 * - bridge middle parts: bridge itself is ignored

   191

 */

   192

RoadBits GetAnyRoadBits(TileIndex);

   193

   194

   195

TrackBits GetAnyRoadTrackBits(TileIndex tile);

   196

   197

   198

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

   199

{

   200

	SetTileType(t, MP_STREET);

   201

	SetTileOwner(t, owner);

   202

	_m[t].m2 = town;

   203

	_m[t].m3 = 0;

   204

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

   205

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

   206

}

   207

   208

   209

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

   210

{

   211

	SetTileType(t, MP_STREET);

   212

	SetTileOwner(t, rail);

   213

	_m[t].m2 = town;

   214

	_m[t].m3 = road;

   215

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

   216

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

   217

}

   218

   219

   220

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

   221

{

   222

	SetTileType(t, MP_STREET);

   223

	SetTileOwner(t, owner);

   224

	_m[t].m2 = 0;

   225

	_m[t].m3 = 0;

   226

	_m[t].m4 = 0;

   227

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

   228

}

   229

   230

#endif