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 AxisToTrackBits(OtherAxis(GetCrossingRoadAxis(tile)));

    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

   108

typedef enum Roadside {

   109

	ROADSIDE_BARREN           = 0,

   110

	ROADSIDE_GRASS            = 1,

   111

	ROADSIDE_PAVED            = 2,

   112

	ROADSIDE_STREET_LIGHTS    = 3,

   113

	ROADSIDE_TREES            = 5,

   114

	ROADSIDE_GRASS_ROAD_WORKS = 6,

   115

	ROADSIDE_PAVED_ROAD_WORKS = 7

   116

} Roadside;

   117

   118

static inline Roadside GetRoadside(TileIndex tile)

   119

{

   120

	return (Roadside)GB(_m[tile].m4, 4, 3);

   121

}

   122

   123

static inline void SetRoadside(TileIndex tile, Roadside s)

   124

{

   125

	SB(_m[tile].m4, 4, 3, s);

   126

}

   127

   128

static inline bool HasRoadWorks(TileIndex t)

   129

{

   130

	return GetRoadside(t) >= ROADSIDE_GRASS_ROAD_WORKS;

   131

}

   132

   133

static inline bool IncreaseRoadWorksCounter(TileIndex t)

   134

{

   135

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

   136

   137

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

   138

}

   139

   140

static inline void StartRoadWorks(TileIndex t)

   141

{

   142

	assert(!HasRoadWorks(t));

   143

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

   144

	switch (GetRoadside(t)) {

   145

		case ROADSIDE_BARREN:

   146

		case ROADSIDE_GRASS:  SetRoadside(t, ROADSIDE_GRASS_ROAD_WORKS); break;

   147

		default:              SetRoadside(t, ROADSIDE_PAVED_ROAD_WORKS); break;

   148

	}

   149

}

   150

   151

static inline void TerminateRoadWorks(TileIndex t)

   152

{

   153

	assert(HasRoadWorks(t));

   154

	SetRoadside(t, (Roadside)(GetRoadside(t) - ROADSIDE_GRASS_ROAD_WORKS + ROADSIDE_GRASS));

   155

	/* Stop the counter */

   156

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

   157

}

   158

   159

   160

static inline DiagDirection GetRoadDepotDirection(TileIndex t)

   161

{

   162

	assert(GetRoadTileType(t) == ROAD_TILE_DEPOT);

   163

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

   164

}

   165

   166

   167

/**

   168

 * Returns the RoadBits on an arbitrary tile

   169

 * Special behavior:

   170

 * - road depots: entrance is treated as road piece

   171

 * - road tunnels: entrance is treated as road piece

   172

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

   173

 * - bridge middle parts: bridge itself is ignored

   174

 */

   175

RoadBits GetAnyRoadBits(TileIndex);

   176

   177

   178

TrackBits GetAnyRoadTrackBits(TileIndex tile);

   179

   180

   181

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

   182

{

   183

	SetTileType(t, MP_STREET);

   184

	SetTileOwner(t, owner);

   185

	_m[t].m2 = town;

   186

	_m[t].m3 = 0;

   187

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

   188

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

   189

}

   190

   191

   192

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

   193

{

   194

	SetTileType(t, MP_STREET);

   195

	SetTileOwner(t, rail);

   196

	_m[t].m2 = town;

   197

	_m[t].m3 = road;

   198

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

   199

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

   200

}

   201

   202

   203

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

   204

{

   205

	SetTileType(t, MP_STREET);

   206

	SetTileOwner(t, owner);

   207

	_m[t].m2 = 0;

   208

	_m[t].m3 = 0;

   209

	_m[t].m4 = 0;

   210

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

   211

}

   212

   213

#endif /* ROAD_MAP_H */