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

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

    17

}

    18

    19

static inline bool IsBridgeTile(TileIndex t)

    20

{

    21

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

    22

}

    23

    24

    25

static inline bool IsBridgeRamp(TileIndex t)

    26

{

    27

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

    28

}

    29

    30

static inline bool IsBridgeMiddle(TileIndex t)

    31

{

    32

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

    33

}

    34

    35

    36

/**

    37

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

    38

 * @param tile The tile to analyze

    39

 * @return the piece

    40

 */

    41

static inline uint GetBridgePiece(TileIndex tile)

    42

{

    43

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

    44

}

    45

    46

    47

/**

    48

 * Determines the type of bridge on a tile

    49

 * @param tile The tile to analyze

    50

 * @return The bridge type

    51

 */

    52

static inline uint GetBridgeType(TileIndex tile)

    53

{

    54

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

    55

}

    56

    57

    58

/**

    59

 * Get the direction pointing onto the bridge

    60

 */

    61

static inline DiagDirection GetBridgeRampDirection(TileIndex t)

    62

{

    63

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

    64

	 * bridges to a DiagDirection

    65

	 */

    66

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

    67

}

    68

    69

    70

static inline Axis GetBridgeAxis(TileIndex t)

    71

{

    72

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

    73

}

    74

    75

    76

static inline TransportType GetBridgeTransportType(TileIndex t)

    77

{

    78

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

    79

}

    80

    81

    82

static inline bool IsClearUnderBridge(TileIndex t)

    83

{

    84

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

    85

}

    86

    87

static inline bool IsWaterUnderBridge(TileIndex t)

    88

{

    89

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

    90

}

    91

    92

    93

static inline bool IsTransportUnderBridge(TileIndex t)

    94

{

    95

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

    96

}

    97

    98

static inline TransportType GetTransportTypeUnderBridge(TileIndex t)

    99

{

   100

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

   101

}

   102

   103

static inline RoadBits GetRoadBitsUnderBridge(TileIndex t)

   104

{

   105

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

   106

}

   107

   108

static inline TrackBits GetRailBitsUnderBridge(TileIndex t)

   109

{

   110

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

   111

}

   112

   113

   114

/**

   115

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

   116

 */

   117

TileIndex GetBridgeEnd(TileIndex, DiagDirection);

   118

   119

/**

   120

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

   121

 */

   122

TileIndex GetSouthernBridgeEnd(TileIndex t);

   123

   124

   125

/**

   126

 * Starting at one bridge end finds the other bridge end

   127

 */

   128

TileIndex GetOtherBridgeEnd(TileIndex);

   129

   130

   131

static inline void SetClearUnderBridge(TileIndex t)

   132

{

   133

	SetTileOwner(t, OWNER_NONE);

   134

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

   135

}

   136

   137

static inline void SetWaterUnderBridge(TileIndex t)

   138

{

   139

	SetTileOwner(t, OWNER_WATER);

   140

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

   141

}

   142

   143

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

   144

{

   145

	SetTileOwner(t, o);

   146

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

   147

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

   148

}

   149

   150

static inline void SetRoadUnderBridge(TileIndex t, Owner o)

   151

{

   152

	SetTileOwner(t, o);

   153

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

   154

}

   155

   156

   157

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

   158

{

   159

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

   160

   161

	SetTileType(t, MP_TUNNELBRIDGE);

   162

	SetTileOwner(t, o);

   163

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

   164

	_m[t].m4 = 0;

   165

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

   166

}

   167

   168

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

   169

{

   170

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

   171

	_m[t].m3 = 0;

   172

}

   173

   174

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

   175

{

   176

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

   177

	_m[t].m3 = r;

   178

}

   179

   180

   181

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

   182

{

   183

	SetTileType(t, MP_TUNNELBRIDGE);

   184

	SetTileOwner(t, OWNER_NONE);

   185

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

   186

	_m[t].m3 = 0;

   187

	_m[t].m4 = 0;

   188

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

   189

}

   190

   191

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

   192

{

   193

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

   194

}

   195

   196

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

   197

{

   198

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

   199

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

   200

}

   201

   202

   203

#endif