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

static inline RoadBits GetRoadBits(TileIndex tile)

    32

{

    33

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

    34

}

    35

    36

static inline void SetRoadBits(TileIndex tile, RoadBits r)

    37

{

    38

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

    39

}

    40

    41

    42

static inline Axis GetCrossingRoadAxis(TileIndex tile)

    43

{

    44

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

    45

}

    46

    47

static inline RoadBits GetCrossingRoadBits(TileIndex tile)

    48

{

    49

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

    50

}

    51

    52

static inline TrackBits GetCrossingRailBits(TileIndex tile)

    53

{

    54

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

    55

}

    56

    57

    58

// TODO swap owner of road and rail

    59

static inline Owner GetCrossingRoadOwner(TileIndex t)

    60

{

    61

	return (Owner)_m[t].m3;

    62

}

    63

    64

static inline void SetCrossingRoadOwner(TileIndex t, Owner o)

    65

{

    66

	_m[t].m3 = o;

    67

}

    68

    69

    70

typedef enum RoadType {

    71

	ROAD_NORMAL,

    72

	ROAD_CROSSING,

    73

	ROAD_DEPOT

    74

} RoadType;

    75

    76

static inline RoadType GetRoadType(TileIndex tile)

    77

{

    78

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

    79

}

    80

    81

    82

static inline DiagDirection GetRoadDepotDirection(TileIndex tile)

    83

{

    84

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

    85

}

    86

    87

    88

/**

    89

 * Returns the RoadBits on an arbitrary tile

    90

 * Special behavior:

    91

 * - road depots: entrance is treated as road piece

    92

 * - road tunnels: entrance is treated as road piece

    93

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

    94

 * - bridge middle parts: bridge itself is ignored

    95

 */

    96

RoadBits GetAnyRoadBits(TileIndex);

    97

    98

    99

TrackBits GetAnyRoadTrackBits(TileIndex tile);

   100

   101

   102

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

   103

{

   104

	SetTileType(t, MP_STREET);

   105

	SetTileOwner(t, owner);

   106

	_m[t].m2 = town;

   107

	_m[t].m3 = 0;

   108

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

   109

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

   110

}

   111

   112

   113

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

   114

{

   115

	SetTileType(t, MP_STREET);

   116

	SetTileOwner(t, rail);

   117

	_m[t].m2 = town;

   118

	_m[t].m3 = road;

   119

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

   120

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

   121

}

   122

   123

   124

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

   125

{

   126

	SetTileType(t, MP_STREET);

   127

	SetTileOwner(t, owner);

   128

	_m[t].m2 = 0;

   129

	_m[t].m3 = 0;

   130

	_m[t].m4 = 0;

   131

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

   132

}

   133

   134

#endif