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

}

   152

   153

static inline void SetWaterUnderBridge(TileIndex t)

   154

{

   155

	assert(IsBridgeMiddle(t));

   156

	SetTileOwner(t, OWNER_WATER);

   157

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

   158

}

   159

   160

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

   161

{

   162

	assert(IsBridgeMiddle(t));

   163

	SetTileOwner(t, o);

   164

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

   165

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

   166

}

   167

   168

static inline void SetRoadUnderBridge(TileIndex t, Owner o)

   169

{

   170

	assert(IsBridgeMiddle(t));

   171

	SetTileOwner(t, o);

   172

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

   173

}

   174

   175

   176

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

   177

{

   178

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

   179

   180

	SetTileType(t, MP_TUNNELBRIDGE);

   181

	SetTileOwner(t, o);

   182

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

   183

	_m[t].m4 = 0;

   184

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

   185

}

   186

   187

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

   188

{

   189

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

   190

	_m[t].m3 = 0;

   191

}

   192

   193

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

   194

{

   195

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

   196

	_m[t].m3 = r;

   197

}

   198

   199

   200

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

   201

{

   202

	SetTileType(t, MP_TUNNELBRIDGE);

   203

	SetTileOwner(t, OWNER_NONE);

   204

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

   205

	_m[t].m3 = 0;

   206

	_m[t].m4 = 0;

   207

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

   208

}

   209

   210

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

   211

{

   212

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

   213

}

   214

   215

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

   216

{

   217

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

   218

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

   219

}

   220

   221

   222

#endif