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

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

    70

}

    71

    72

    73

static inline Axis GetBridgeAxis(TileIndex t)

    74

{

    75

	assert(IsBridgeMiddle(t));

    76

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

    77

}

    78

    79

    80

static inline TransportType GetBridgeTransportType(TileIndex t)

    81

{

    82

	assert(IsBridgeTile(t));

    83

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

    84

}

    85

    86

    87

static inline bool IsClearUnderBridge(TileIndex t)

    88

{

    89

	assert(IsBridgeMiddle(t));

    90

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

    91

}

    92

    93

static inline bool IsWaterUnderBridge(TileIndex t)

    94

{

    95

	assert(IsBridgeMiddle(t));

    96

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

    97

}

    98

    99

   100

static inline bool IsTransportUnderBridge(TileIndex t)

   101

{

   102

	assert(IsBridgeMiddle(t));

   103

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

   104

}

   105

   106

static inline TransportType GetTransportTypeUnderBridge(TileIndex t)

   107

{

   108

	assert(IsTransportUnderBridge(t));

   109

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

   110

}

   111

   112

static inline RoadBits GetRoadBitsUnderBridge(TileIndex t)

   113

{

   114

	assert(GetTransportTypeUnderBridge(t) == TRANSPORT_ROAD);

   115

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

   116

}

   117

   118

static inline TrackBits GetRailBitsUnderBridge(TileIndex t)

   119

{

   120

	assert(GetTransportTypeUnderBridge(t) == TRANSPORT_RAIL);

   121

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

   122

}

   123

   124

   125

/**

   126

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

   127

 */

   128

TileIndex GetBridgeEnd(TileIndex, DiagDirection);

   129

   130

/**

   131

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

   132

 */

   133

TileIndex GetSouthernBridgeEnd(TileIndex t);

   134

   135

   136

/**

   137

 * Starting at one bridge end finds the other bridge end

   138

 */

   139

TileIndex GetOtherBridgeEnd(TileIndex);

   140

   141

uint GetBridgeHeight(TileIndex t);

   142

   143

static inline void SetClearUnderBridge(TileIndex t)

   144

{

   145

	assert(IsBridgeMiddle(t));

   146

	SetTileOwner(t, OWNER_NONE);

   147

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

   148

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

   149

}

   150

   151

static inline void SetWaterUnderBridge(TileIndex t)

   152

{

   153

	assert(IsBridgeMiddle(t));

   154

	SetTileOwner(t, OWNER_WATER);

   155

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

   156

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

   157

}

   158

   159

static inline void SetCanalUnderBridge(TileIndex t, Owner o)

   160

{

   161

	assert(IsBridgeMiddle(t));

   162

	SetTileOwner(t, o);

   163

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

   164

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

   165

}

   166

   167

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

   168

{

   169

	assert(IsBridgeMiddle(t));

   170

	SetTileOwner(t, o);

   171

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

   172

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

   173

}

   174

   175

static inline void SetRoadUnderBridge(TileIndex t, Owner o)

   176

{

   177

	assert(IsBridgeMiddle(t));

   178

	SetTileOwner(t, o);

   179

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

   180

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

   181

}

   182

   183

   184

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

   185

{

   186

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

   187

   188

	SetTileType(t, MP_TUNNELBRIDGE);

   189

	SetTileOwner(t, o);

   190

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

   191

	_m[t].m4 = 0;

   192

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

   193

}

   194

   195

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

   196

{

   197

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

   198

	_m[t].m3 = 0;

   199

}

   200

   201

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

   202

{

   203

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

   204

	_m[t].m3 = r;

   205

}

   206

   207

   208

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

   209

{

   210

	SetTileType(t, MP_TUNNELBRIDGE);

   211

	SetTileOwner(t, OWNER_NONE);

   212

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

   213

	_m[t].m3 = 0;

   214

	_m[t].m4 = 0;

   215

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

   216

}

   217

   218

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

   219

{

   220

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

   221

}

   222

   223

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

   224

{

   225

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

   226

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

   227

}

   228

   229

   230

#endif