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 RoadTileType {

    13

	ROAD_TILE_NORMAL,

    14

	ROAD_TILE_CROSSING,

    15

	ROAD_TILE_DEPOT

    16

} RoadTileType;

    17

    18

static inline RoadTileType GetRoadTileType(TileIndex t)

    19

{

    20

	assert(IsTileType(t, MP_STREET));

    21

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

    22

}

    23

    24

static inline bool IsLevelCrossing(TileIndex t)

    25

{

    26

	return GetRoadTileType(t) == ROAD_TILE_CROSSING;

    27

}

    28

    29

static inline bool IsLevelCrossingTile(TileIndex t)

    30

{

    31

	return IsTileType(t, MP_STREET) && IsLevelCrossing(t);

    32

}

    33

    34

static inline RoadBits GetRoadBits(TileIndex t)

    35

{

    36

	assert(GetRoadTileType(t) == ROAD_TILE_NORMAL);

    37

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

    38

}

    39

    40

static inline void SetRoadBits(TileIndex t, RoadBits r)

    41

{

    42

	assert(GetRoadTileType(t) == ROAD_TILE_NORMAL); // XXX incomplete

    43

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

    44

}

    45

    46

    47

static inline Axis GetCrossingRoadAxis(TileIndex t)

    48

{

    49

	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);

    50

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

    51

}

    52

    53

static inline RoadBits GetCrossingRoadBits(TileIndex tile)

    54

{

    55

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

    56

}

    57

    58

static inline TrackBits GetCrossingRailBits(TileIndex tile)

    59

{

    60

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

    61

}

    62

    63

    64

// TODO swap owner of road and rail

    65

static inline Owner GetCrossingRoadOwner(TileIndex t)

    66

{

    67

	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);

    68

	return (Owner)_m[t].m3;

    69

}

    70

    71

static inline void SetCrossingRoadOwner(TileIndex t, Owner o)

    72

{

    73

	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);

    74

	_m[t].m3 = o;

    75

}

    76

    77

static inline void UnbarCrossing(TileIndex t)

    78

{

    79

	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);

    80

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

    81

}

    82

    83

static inline void BarCrossing(TileIndex t)

    84

{

    85

	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);

    86

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

    87

}

    88

    89

static inline bool IsCrossingBarred(TileIndex t)

    90

{

    91

	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);

    92

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

    93

}

    94

    95

#define IsOnDesert IsOnSnow

    96

static inline bool IsOnSnow(TileIndex t)

    97

{

    98

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

    99

}

   100

   101

#define ToggleDesert ToggleSnow

   102

static inline void ToggleSnow(TileIndex t)

   103

{

   104

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

   105

}

   106

   107

typedef enum RoadGroundType {

   108

	RGT_BARREN,

   109

	RGT_GRASS,

   110

	RGT_PAVED,

   111

	RGT_LIGHT,

   112

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

   113

	RGT_ALLEY,

   114

	RGT_ROADWORK_GRASS,

   115

	RGT_ROADWORK_PAVED,

   116

   117

	RGT_ROADWORK_OFFSET = RGT_ROADWORK_GRASS - RGT_GRASS

   118

} RoadGroundType;

   119

   120

static inline RoadGroundType GetGroundType(TileIndex t)

   121

{

   122

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

   123

}

   124

   125

static inline void SetGroundType(TileIndex t, RoadGroundType rgt)

   126

{

   127

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

   128

}

   129

   130

static inline bool HasRoadWorks(TileIndex t)

   131

{

   132

	return GetGroundType(t) >= RGT_ROADWORK_GRASS;

   133

}

   134

   135

static inline bool IncreaseRoadWorksCounter(TileIndex t)

   136

{

   137

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

   138

   139

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

   140

}

   141

   142

static inline void StartRoadWorks(TileIndex t)

   143

{

   144

	assert(!HasRoadWorks(t));

   145

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

   146

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

   147

}

   148

   149

static inline void TerminateRoadWorks(TileIndex t)

   150

{

   151

	assert(HasRoadWorks(t));

   152

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

   153

	/* Stop the counter */

   154

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

   155

}

   156

   157

static inline bool HasPavement(TileIndex t)

   158

{

   159

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

   160

}

   161

   162

static inline DiagDirection GetRoadDepotDirection(TileIndex t)

   163

{

   164

	assert(GetRoadTileType(t) == ROAD_TILE_DEPOT);

   165

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

   166

}

   167

   168

   169

/**

   170

 * Returns the RoadBits on an arbitrary tile

   171

 * Special behavior:

   172

 * - road depots: entrance is treated as road piece

   173

 * - road tunnels: entrance is treated as road piece

   174

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

   175

 * - bridge middle parts: bridge itself is ignored

   176

 */

   177

RoadBits GetAnyRoadBits(TileIndex);

   178

   179

   180

TrackBits GetAnyRoadTrackBits(TileIndex tile);

   181

   182

   183

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

   184

{

   185

	SetTileType(t, MP_STREET);

   186

	SetTileOwner(t, owner);

   187

	_m[t].m2 = town;

   188

	_m[t].m3 = 0;

   189

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

   190

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

   191

}

   192

   193

   194

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

   195

{

   196

	SetTileType(t, MP_STREET);

   197

	SetTileOwner(t, rail);

   198

	_m[t].m2 = town;

   199

	_m[t].m3 = road;

   200

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

   201

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

   202

}

   203

   204

   205

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

   206

{

   207

	SetTileType(t, MP_STREET);

   208

	SetTileOwner(t, owner);

   209

	_m[t].m2 = 0;

   210

	_m[t].m3 = 0;

   211

	_m[t].m4 = 0;

   212

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

   213

}

   214

   215

#endif