1

/* $Id$ */

     2

     3

#ifndef BRIDGE_MAP_H

     4

#define BRIDGE_MAP_H

     5

     6

#include "direction.h"

     7

#include "macros.h"

     8

#include "map.h"

     9

#include "rail.h"

    10

#include "road_map.h"

    11

#include "tile.h"

    12

    13

    14

static inline bool IsBridge(TileIndex t)

    15

{

    16

	assert(IsTileType(t, MP_TUNNELBRIDGE));

    17

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

    18

}

    19

    20

static inline bool IsBridgeTile(TileIndex t)

    21

{

    22

	return IsTileType(t, MP_TUNNELBRIDGE) && IsBridge(t);

    23

}

    24

    25

    26

static inline bool IsBridgeRamp(TileIndex t)

    27

{

    28

	assert(IsBridgeTile(t));

    29

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

    30

}

    31

    32

static inline bool IsBridgeMiddle(TileIndex t)

    33

{

    34

	assert(IsBridgeTile(t));

    35

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

    36

}

    37

    38

    39

/**

    40

 * Determines which piece of a bridge is contained in the current tile

    41

 * @param tile The tile to analyze

    42

 * @return the piece

    43

 */

    44

static inline uint GetBridgePiece(TileIndex t)

    45

{

    46

	assert(IsBridgeMiddle(t));

    47

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

    48

}

    49

    50

    51

/**

    52

 * Determines the type of bridge on a tile

    53

 * @param tile The tile to analyze

    54

 * @return The bridge type

    55

 */

    56

static inline uint GetBridgeType(TileIndex t)

    57

{

    58

	assert(IsBridgeTile(t));

    59

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

    60

}

    61

    62

    63

/**

    64

 * Get the direction pointing onto the bridge

    65

 */

    66

static inline DiagDirection GetBridgeRampDirection(TileIndex t)

    67

{

    68

	assert(IsBridgeRamp(t));

    69

	/* Heavy wizardry to convert the X/Y (bit 0) + N/S (bit 5) encoding of

    70

	 * bridges to a DiagDirection

    71

	 */

    72

	return (DiagDirection)((6 - (_m[t].m5 >> 4 & 2) - (_m[t].m5 & 1)) % 4);

    73

}

    74

    75

    76

static inline Axis GetBridgeAxis(TileIndex t)

    77

{

    78

	assert(IsBridgeMiddle(t));

    79

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

    80

}

    81

    82

    83

static inline TransportType GetBridgeTransportType(TileIndex t)

    84

{

    85

	assert(IsBridgeTile(t));

    86

	return (TransportType)GB(_m[t].m5, 1, 2);

    87

}

    88

    89

    90

static inline bool IsClearUnderBridge(TileIndex t)

    91

{

    92

	assert(IsBridgeMiddle(t));

    93

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

    94

}

    95

    96

static inline bool IsWaterUnderBridge(TileIndex t)

    97

{

    98

	assert(IsBridgeMiddle(t));

    99

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

   100

}

   101

   102

   103

static inline bool IsTransportUnderBridge(TileIndex t)

   104

{

   105

	assert(IsBridgeMiddle(t));

   106

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

   107

}

   108

   109

static inline TransportType GetTransportTypeUnderBridge(TileIndex t)

   110

{

   111

	assert(IsTransportUnderBridge(t));

   112

	return (TransportType)GB(_m[t].m5, 3, 2);

   113

}

   114

   115

static inline RoadBits GetRoadBitsUnderBridge(TileIndex t)

   116

{

   117

	assert(GetTransportTypeUnderBridge(t) == TRANSPORT_ROAD);

   118

	return GetBridgeAxis(t) == AXIS_X ? ROAD_Y : ROAD_X;

   119

}

   120

   121

static inline TrackBits GetRailBitsUnderBridge(TileIndex t)

   122

{

   123

	assert(GetTransportTypeUnderBridge(t) == TRANSPORT_RAIL);

   124

	return GetBridgeAxis(t) == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X;

   125

}

   126

   127

   128

/**

   129

 * Finds the end of a bridge in the specified direction starting at a middle tile

   130

 */

   131

TileIndex GetBridgeEnd(TileIndex, DiagDirection);

   132

   133

/**

   134

 * Finds the southern end of a bridge starting at a middle tile

   135

 */

   136

TileIndex GetSouthernBridgeEnd(TileIndex t);

   137

   138

   139

/**

   140

 * Starting at one bridge end finds the other bridge end

   141

 */

   142

TileIndex GetOtherBridgeEnd(TileIndex);

   143

   144

uint GetBridgeHeight(TileIndex t);

   145

   146

static inline void SetClearUnderBridge(TileIndex t)

   147

{

   148

	assert(IsBridgeMiddle(t));

   149

	SetTileOwner(t, OWNER_NONE);

   150

	SB(_m[t].m5, 3, 3, 0 << 2 | 0);

   151

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

   152

}

   153

   154

static inline void SetWaterUnderBridge(TileIndex t)

   155

{

   156

	assert(IsBridgeMiddle(t));

   157

	SetTileOwner(t, OWNER_WATER);

   158

	SB(_m[t].m5, 3, 3, 0 << 2 | 1);

   159

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

   160

}

   161

   162

static inline void SetRailUnderBridge(TileIndex t, Owner o, RailType r)

   163

{

   164

	assert(IsBridgeMiddle(t));

   165

	SetTileOwner(t, o);

   166

	SB(_m[t].m5, 3, 3, 1 << 2 | TRANSPORT_RAIL);

   167

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

   168

}

   169

   170

static inline void SetRoadUnderBridge(TileIndex t, Owner o)

   171

{

   172

	assert(IsBridgeMiddle(t));

   173

	SetTileOwner(t, o);

   174

	SB(_m[t].m5, 3, 3, 1 << 2 | TRANSPORT_ROAD);

   175

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

   176

}

   177

   178

   179

static inline void MakeBridgeRamp(TileIndex t, Owner o, uint bridgetype, DiagDirection d, TransportType tt)

   180

{

   181

	uint northsouth = (d == DIAGDIR_NE || d == DIAGDIR_NW);

   182

   183

	SetTileType(t, MP_TUNNELBRIDGE);

   184

	SetTileOwner(t, o);

   185

	_m[t].m2 = bridgetype << 4;

   186

	_m[t].m4 = 0;

   187

	_m[t].m5 = 1 << 7 | 0 << 6 | northsouth << 5 | tt << 1 | DiagDirToAxis(d);

   188

}

   189

   190

static inline void MakeRoadBridgeRamp(TileIndex t, Owner o, uint bridgetype, DiagDirection d)

   191

{

   192

	MakeBridgeRamp(t, o, bridgetype, d, TRANSPORT_ROAD);

   193

	_m[t].m3 = 0;

   194

}

   195

   196

static inline void MakeRailBridgeRamp(TileIndex t, Owner o, uint bridgetype, DiagDirection d, RailType r)

   197

{

   198

	MakeBridgeRamp(t, o, bridgetype, d, TRANSPORT_RAIL);

   199

	_m[t].m3 = r;

   200

}

   201

   202

   203

static inline void MakeBridgeMiddle(TileIndex t, uint bridgetype, uint piece, Axis a, TransportType tt)

   204

{

   205

	SetTileType(t, MP_TUNNELBRIDGE);

   206

	SetTileOwner(t, OWNER_NONE);

   207

	_m[t].m2 = bridgetype << 4 | piece;

   208

	_m[t].m3 = 0;

   209

	_m[t].m4 = 0;

   210

	_m[t].m5 = 1 << 7 | 1 << 6 | 0 << 5 | 0 << 3 | tt << 1 | a;

   211

}

   212

   213

static inline void MakeRoadBridgeMiddle(TileIndex t, uint bridgetype, uint piece, Axis a)

   214

{

   215

	MakeBridgeMiddle(t, bridgetype, piece, a, TRANSPORT_ROAD);

   216

}

   217

   218

static inline void MakeRailBridgeMiddle(TileIndex t, uint bridgetype, uint piece, Axis a, RailType r)

   219

{

   220

	MakeBridgeMiddle(t, bridgetype, piece, a, TRANSPORT_RAIL);

   221

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

   222

}

   223

   224

   225

#endif