1

/* $Id$ */

     2

     5

#ifndef ROAD_MAP_H

     6

#define ROAD_MAP_H

     7

     8

#include "macros.h"

     9

#include "rail.h"

    10

#include "road.h"

    11

#include "tile.h"

    12

    13

    14

enum RoadTileType {

    15

	ROAD_TILE_NORMAL,

    16

	ROAD_TILE_CROSSING,

    17

	ROAD_TILE_DEPOT

    18

};

    19

    20

static inline RoadTileType GetRoadTileType(TileIndex t)

    21

{

    22

	assert(IsTileType(t, MP_STREET));

    23

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

    24

}

    25

    26

static inline bool IsLevelCrossing(TileIndex t)

    27

{

    28

	return GetRoadTileType(t) == ROAD_TILE_CROSSING;

    29

}

    30

    31

static inline bool IsLevelCrossingTile(TileIndex t)

    32

{

    33

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

    34

}

    35

    36

static inline RoadBits GetRoadBits(TileIndex t)

    37

{

    38

	assert(GetRoadTileType(t) == ROAD_TILE_NORMAL);

    39

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

    40

}

    41

    42

static inline void SetRoadBits(TileIndex t, RoadBits r)

    43

{

    44

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

    45

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

    46

}

    47

    48

    49

static inline Axis GetCrossingRoadAxis(TileIndex t)

    50

{

    51

	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);

    52

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

    53

}

    54

    55

static inline RoadBits GetCrossingRoadBits(TileIndex tile)

    56

{

    57

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

    58

}

    59

    60

static inline TrackBits GetCrossingRailBits(TileIndex tile)

    61

{

    62

	return AxisToTrackBits(OtherAxis(GetCrossingRoadAxis(tile)));

    63

}

    64

    65

    66

// TODO swap owner of road and rail

    67

static inline Owner GetCrossingRoadOwner(TileIndex t)

    68

{

    69

	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);

    70

	return (Owner)_m[t].m4;

    71

}

    72

    73

static inline void SetCrossingRoadOwner(TileIndex t, Owner o)

    74

{

    75

	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);

    76

	_m[t].m4 = o;

    77

}

    78

    79

static inline void UnbarCrossing(TileIndex t)

    80

{

    81

	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);

    82

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

    83

}

    84

    85

static inline void BarCrossing(TileIndex t)

    86

{

    87

	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);

    88

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

    89

}

    90

    91

static inline bool IsCrossingBarred(TileIndex t)

    92

{

    93

	assert(GetRoadTileType(t) == ROAD_TILE_CROSSING);

    94

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

    95

}

    96

    97

#define IsOnDesert IsOnSnow

    98

static inline bool IsOnSnow(TileIndex t)

    99

{

   100

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

   101

}

   102

   103

#define ToggleDesert ToggleSnow

   104

static inline void ToggleSnow(TileIndex t)

   105

{

   106

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

   107

}

   108

   109

   110

enum Roadside {

   111

	ROADSIDE_BARREN           = 0,

   112

	ROADSIDE_GRASS            = 1,

   113

	ROADSIDE_PAVED            = 2,

   114

	ROADSIDE_STREET_LIGHTS    = 3,

   115

	ROADSIDE_TREES            = 5,

   116

	ROADSIDE_GRASS_ROAD_WORKS = 6,

   117

	ROADSIDE_PAVED_ROAD_WORKS = 7

   118

};

   119

   120

static inline Roadside GetRoadside(TileIndex tile)

   121

{

   122

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

   123

}

   124

   125

static inline void SetRoadside(TileIndex tile, Roadside s)

   126

{

   127

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

   128

}

   129

   130

static inline bool HasRoadWorks(TileIndex t)

   131

{

   132

	return GetRoadside(t) >= ROADSIDE_GRASS_ROAD_WORKS;

   133

}

   134

   135

static inline bool IncreaseRoadWorksCounter(TileIndex t)

   136

{

   137

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

   138

   139

	return GB(_m[t].m3, 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

	switch (GetRoadside(t)) {

   147

		case ROADSIDE_BARREN:

   148

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

   149

		default:              SetRoadside(t, ROADSIDE_PAVED_ROAD_WORKS); break;

   150

	}

   151

}

   152

   153

static inline void TerminateRoadWorks(TileIndex t)

   154

{

   155

	assert(HasRoadWorks(t));

   156

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

   157

	/* Stop the counter */

   158

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

   159

}

   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 behaviour:

   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

   178

 */

   180

   189

TrackBits GetAnyRoadTrackBits(TileIndex tile);

   190

   191

   192

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

   193

{

   194

	SetTileType(t, MP_STREET);

   195

	SetTileOwner(t, owner);

   196

	_m[t].m2 = town;

   197

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

   198

	_m[t].m4 = 0;

   199

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

   200

}

   201

   202

   203

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

   204

{

   205

	SetTileType(t, MP_STREET);

   206

	SetTileOwner(t, rail);

   207

	_m[t].m2 = town;

   208

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

   209

	_m[t].m4 = road;

   210

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

   211

}

   212

   213

   214

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

   215

{

   216

	SetTileType(t, MP_STREET);

   217

	SetTileOwner(t, owner);

   218

	_m[t].m2 = 0;

   219

	_m[t].m3 = 0;

   220

	_m[t].m4 = 0;

   221

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

   222

}

   223

   224

#endif /* ROAD_MAP_H */