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 Track GetRailUnderBridge(TileIndex t)

   119

{

   120

	assert(GetTransportTypeUnderBridge(t) == TRANSPORT_RAIL);

   121

	return AxisToTrack(OtherAxis(GetBridgeAxis(t)));

   122

}

   123

   124

static inline TrackBits GetRailBitsUnderBridge(TileIndex t)

   125

{

   126

	return TrackToTrackBits(GetRailUnderBridge(t));

   127

}

   128

   129

   130

/**

   131

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

   132

 */

   133

TileIndex GetBridgeEnd(TileIndex, DiagDirection);

   134

   135

/**

   136

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

   137

 */

   138

TileIndex GetSouthernBridgeEnd(TileIndex t);

   139

   140

   141

/**

   142

 * Starting at one bridge end finds the other bridge end

   143

 */

   144

TileIndex GetOtherBridgeEnd(TileIndex);

   145

   146

uint GetBridgeHeight(TileIndex t);

   147

   148

static inline void SetClearUnderBridge(TileIndex t)

   149

{

   150

	assert(IsBridgeMiddle(t));

   151

	SetTileOwner(t, OWNER_NONE);

   152

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

   153

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

   154

}

   155

   156

static inline void SetWaterUnderBridge(TileIndex t)

   157

{

   158

	assert(IsBridgeMiddle(t));

   159

	SetTileOwner(t, OWNER_WATER);

   160

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

   161

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

   162

}

   163

   164

static inline void SetCanalUnderBridge(TileIndex t, Owner o)

   165

{

   166

	assert(IsBridgeMiddle(t));

   167

	SetTileOwner(t, o);

   168

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

   169

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

   170

}

   171

   172

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

   173

{

   174

	assert(IsBridgeMiddle(t));

   175

	SetTileOwner(t, o);

   176

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

   177

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

   178

}

   179

   180

static inline void SetRoadUnderBridge(TileIndex t, Owner o)

   181

{

   182

	assert(IsBridgeMiddle(t));

   183

	SetTileOwner(t, o);

   184

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

   185

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

   186

}

   187

   188

   189

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

   190

{

   191

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

   192

   193

	SetTileType(t, MP_TUNNELBRIDGE);

   194

	SetTileOwner(t, o);

   195

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

   196

	_m[t].m4 = 0;

   197

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

   198

}

   199

   200

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

   201

{

   202

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

   203

	_m[t].m3 = 0;

   204

}

   205

   206

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

   207

{

   208

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

   209

	_m[t].m3 = r;

   210

}

   211

   212

   213

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

   214

{

   215

	SetTileType(t, MP_TUNNELBRIDGE);

   216

	SetTileOwner(t, OWNER_NONE);

   217

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

   218

	_m[t].m3 = 0;

   219

	_m[t].m4 = 0;

   220

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

   221

}

   222

   223

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

   224

{

   225

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

   226

}

   227

   228

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

   229

{

   230

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

   231

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

   232

}

   233

   234

   235

#endif /* BRIDGE_MAP_H */