1

/* $Id$ */

     2

     3

#ifndef ROAD_MAP_H

     4

#define ROAD_MAP_H

     5

     6

#include "macros.h"

     7

#include "rail.h"

     8

#include "road.h"

     9

#include "tile.h"

    10

    11

    12

typedef enum RoadType {

    13

	ROAD_NORMAL,

    14

	ROAD_CROSSING,

    15

	ROAD_DEPOT

    16

} RoadType;

    17

    18

static inline RoadType GetRoadType(TileIndex t)

    19

{

    20

	assert(IsTileType(t, MP_STREET));

    21

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

    22

}

    23

    24

static inline bool IsLevelCrossing(TileIndex t)

    25

{

    26

	return GetRoadType(t) == ROAD_CROSSING;

    27

}

    28

    29

    30

static inline RoadBits GetRoadBits(TileIndex t)

    31

{

    32

	assert(GetRoadType(t) == ROAD_NORMAL);

    33

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

    34

}

    35

    36

static inline void SetRoadBits(TileIndex t, RoadBits r)

    37

{

    38

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

    39

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

    40

}

    41

    42

    43

static inline Axis GetCrossingRoadAxis(TileIndex t)

    44

{

    45

	assert(GetRoadType(t) == ROAD_CROSSING);

    46

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

    47

}

    48

    49

static inline RoadBits GetCrossingRoadBits(TileIndex tile)

    50

{

    51

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

    52

}

    53

    54

static inline TrackBits GetCrossingRailBits(TileIndex tile)

    55

{

    56

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

    57

}

    58

    59

    60

// TODO swap owner of road and rail

    61

static inline Owner GetCrossingRoadOwner(TileIndex t)

    62

{

    63

	assert(GetRoadType(t) == ROAD_CROSSING);

    64

	return (Owner)_m[t].m3;

    65

}

    66

    67

static inline void SetCrossingRoadOwner(TileIndex t, Owner o)

    68

{

    69

	assert(GetRoadType(t) == ROAD_CROSSING);

    70

	_m[t].m3 = o;

    71

}

    72

    73

static inline void UnbarCrossing(TileIndex t)

    74

{

    75

	assert(GetRoadType(t) == ROAD_CROSSING);

    76

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

    77

}

    78

    79

static inline void BarCrossing(TileIndex t)

    80

{

    81

	assert(GetRoadType(t) == ROAD_CROSSING);

    82

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

    83

}

    84

    85

static inline bool IsCrossingBarred(TileIndex t)

    86

{

    87

	assert(GetRoadType(t) == ROAD_CROSSING);

    88

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

    89

}

    90

    91

#define IsOnDesert IsOnSnow

    92

static inline bool IsOnSnow(TileIndex t)

    93

{

    94

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

    95

}

    96

    97

#define ToggleDesert ToggleSnow

    98

static inline void ToggleSnow(TileIndex t)

    99

{

   100

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

   101

}

   102

   103

typedef enum RoadGroundType {

   104

	RGT_BARREN,

   105

	RGT_GRASS,

   106

	RGT_PAVED,

   107

	RGT_LIGHT,

   108

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

   109

	RGT_ALLEY,

   110

	RGT_ROADWORK_GRASS,

   111

	RGT_ROADWORK_PAVED,

   112

   113

	RGT_ROADWORK_OFFSET = RGT_ROADWORK_GRASS - RGT_GRASS

   114

} RoadGroundType;

   115

   116

static inline RoadGroundType GetGroundType(TileIndex t)

   117

{

   118

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

   119

}

   120

   121

static inline void SetGroundType(TileIndex t, RoadGroundType rgt)

   122

{

   123

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

   124

}

   125

   126

static inline bool HasRoadWorks(TileIndex t)

   127

{

   128

	return GetGroundType(t) >= RGT_ROADWORK_GRASS;

   129

}

   130

   131

static inline bool IncreaseRoadWorksCounter(TileIndex t)

   132

{

   133

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

   134

   135

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

   136

}

   137

   138

static inline void StartRoadWorks(TileIndex t)

   139

{

   140

	assert(!HasRoadWorks(t));

   141

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

   142

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

   143

}

   144

   145

static inline void TerminateRoadWorks(TileIndex t)

   146

{

   147

	assert(HasRoadWorks(t));

   148

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

   149

	/* Stop the counter */

   150

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

   151

}

   152

   153

static inline bool HasPavement(TileIndex t)

   154

{

   155

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

   156

}

   157

   158

static inline DiagDirection GetRoadDepotDirection(TileIndex t)

   159

{

   160

	assert(GetRoadType(t) == ROAD_DEPOT);

   161

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

   162

}

   163

   164

   165

/**

   166

 * Returns the RoadBits on an arbitrary tile

   167

 * Special behavior:

   168

 * - road depots: entrance is treated as road piece

   169

 * - road tunnels: entrance is treated as road piece

   170

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

   171

 * - bridge middle parts: bridge itself is ignored

   172

 */

   173

RoadBits GetAnyRoadBits(TileIndex);

   174

   175

   176

TrackBits GetAnyRoadTrackBits(TileIndex tile);

   177

   178

   179

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

   180

{

   181

	SetTileType(t, MP_STREET);

   182

	SetTileOwner(t, owner);

   183

	_m[t].m2 = town;

   184

	_m[t].m3 = 0;

   185

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

   186

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

   187

}

   188

   189

   190

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

   191

{

   192

	SetTileType(t, MP_STREET);

   193

	SetTileOwner(t, rail);

   194

	_m[t].m2 = town;

   195

	_m[t].m3 = road;

   196

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

   197

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

   198

}

   199

   200

   201

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

   202

{

   203

	SetTileType(t, MP_STREET);

   204

	SetTileOwner(t, owner);

   205

	_m[t].m2 = 0;

   206

	_m[t].m3 = 0;

   207

	_m[t].m4 = 0;

   208

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

   209

}

   210

   211

#endif