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

void DrawBridgeMiddle(const TileInfo* ti); // XXX

    15

    16

    17

static inline bool IsBridge(TileIndex t)

    18

{

    19

	assert(IsTileType(t, MP_TUNNELBRIDGE));

    20

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

    21

}

    22

    23

static inline bool IsBridgeTile(TileIndex t)

    24

{

    25

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

    26

}

    27

    28

    29

static inline bool MayHaveBridgeAbove(TileIndex t)

    30

{

    31

	return

    32

		IsTileType(t, MP_CLEAR) ||

    33

		IsTileType(t, MP_RAILWAY) ||

    34

		IsTileType(t, MP_STREET) ||

    35

		IsTileType(t, MP_WATER) ||

    36

		IsTileType(t, MP_TUNNELBRIDGE);

    37

}

    38

    39

    40

static inline bool IsXBridgeAbove(TileIndex t)

    41

{

    42

	assert(MayHaveBridgeAbove(t));

    43

	return GB(_m[t].extra, 6, 1) != 0;

    44

}

    45

    46

static inline bool IsYBridgeAbove(TileIndex t)

    47

{

    48

	assert(MayHaveBridgeAbove(t));

    49

	return GB(_m[t].extra, 7, 1) != 0;

    50

}

    51

    52

static inline bool IsBridgeOfAxis(TileIndex t, Axis a)

    53

{

    54

	if (a == AXIS_X) return IsXBridgeAbove(t);

    55

	return IsYBridgeAbove(t);

    56

}

    57

    58

static inline bool IsBridgeAbove(TileIndex t)

    59

{

    60

	return (IsXBridgeAbove(t) || IsYBridgeAbove(t));

    61

}

    62

    63

    64

/**

    65

 * Determines the type of bridge on a tile

    66

 * @param tile The tile to analyze

    67

 * @return The bridge type

    68

 */

    69

static inline uint GetBridgeType(TileIndex t)

    70

{

    71

	assert(IsBridgeTile(t));

    72

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

    73

}

    74

    75

    76

/**

    77

 * Get the direction pointing onto the bridge

    78

 */

    79

static inline DiagDirection GetBridgeRampDirection(TileIndex t)

    80

{

    81

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

    82

	 * bridges to a DiagDirection

    83

	 */

    84

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

    85

}

    86

    87

    88

static inline Axis GetBridgeAxis(TileIndex t)

    89

{

    90

	static const Axis BridgeAxis[] = {AXIS_END, AXIS_X, AXIS_Y, AXIS_END};

    91

	assert(IsBridgeAbove(t));

    92

	return BridgeAxis[GB(_m[t].extra, 6, 2)];

    93

}

    94

    95

    96

static inline TransportType GetBridgeTransportType(TileIndex t)

    97

{

    98

	assert(IsBridgeTile(t));

    99

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

   100

}

   101

   102

   103

/**

   104

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

   105

 */

   106

TileIndex GetBridgeEnd(TileIndex, DiagDirection);

   107

   108

/**

   109

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

   110

 */

   111

TileIndex GetNorthernBridgeEnd(TileIndex t);

   112

   113

/**

   114

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

   115

 */

   116

TileIndex GetSouthernBridgeEnd(TileIndex t);

   117

   118

   119

/**

   120

 * Starting at one bridge end finds the other bridge end

   121

 */

   122

TileIndex GetOtherBridgeEnd(TileIndex);

   123

   124

uint GetBridgeHeight(TileIndex tile, Axis a);

   125

uint GetBridgeFoundation(Slope tileh, Axis axis);

   126

   127

static inline void ClearSingleBridgeMiddle(TileIndex t, Axis a)

   128

{

   129

	assert(MayHaveBridgeAbove(t));

   130

	CLRBIT(_m[t].extra, 6 + a);

   131

}

   132

   133

   134

static inline void ClearBridgeMiddle(TileIndex t)

   135

{

   136

	ClearSingleBridgeMiddle(t, AXIS_X);

   137

	ClearSingleBridgeMiddle(t, AXIS_Y);

   138

}

   139

   140

static inline void SetBridgeMiddle(TileIndex t, Axis a)

   141

{

   142

	assert(MayHaveBridgeAbove(t));

   143

	SETBIT(_m[t].extra, 6 + a);

   144

}

   145

   146

   147

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

   148

{

   149

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

   150

   151

	SetTileType(t, MP_TUNNELBRIDGE);

   152

	SetTileOwner(t, o);

   153

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

   154

	_m[t].m4 = 0;

   155

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

   156

}

   157

   158

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

   159

{

   160

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

   161

	_m[t].m3 = 0;

   162

}

   163

   164

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

   165

{

   166

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

   167

	_m[t].m3 = r;

   168

}

   169

   170

   171

#endif