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

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

    82

}

    83

    84

    85

static inline Axis GetBridgeAxis(TileIndex t)

    86

{

    87

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

    88

	assert(IsBridgeAbove(t));

    89

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

    90

}

    91

    92

    93

static inline TransportType GetBridgeTransportType(TileIndex t)

    94

{

    95

	assert(IsBridgeTile(t));

    96

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

    97

}

    98

    99

   100

/**

   101

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

   102

 */

   103

TileIndex GetBridgeEnd(TileIndex, DiagDirection);

   104

   105

/**

   106

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

   107

 */

   108

TileIndex GetNorthernBridgeEnd(TileIndex t);

   109

   110

/**

   111

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

   112

 */

   113

TileIndex GetSouthernBridgeEnd(TileIndex t);

   114

   115

   116

/**

   117

 * Starting at one bridge end finds the other bridge end

   118

 */

   119

TileIndex GetOtherBridgeEnd(TileIndex);

   120

   121

uint GetBridgeHeight(TileIndex tile, Axis a);

   122

uint GetBridgeFoundation(Slope tileh, Axis axis);

   123

   124

static inline void ClearSingleBridgeMiddle(TileIndex t, Axis a)

   125

{

   126

	assert(MayHaveBridgeAbove(t));

   127

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

   128

}

   129

   130

   131

static inline void ClearBridgeMiddle(TileIndex t)

   132

{

   133

	ClearSingleBridgeMiddle(t, AXIS_X);

   134

	ClearSingleBridgeMiddle(t, AXIS_Y);

   135

}

   136

   137

static inline void SetBridgeMiddle(TileIndex t, Axis a)

   138

{

   139

	assert(MayHaveBridgeAbove(t));

   140

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

   141

}

   142

   143

   144

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

   145

{

   146

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

   147

   148

	SetTileType(t, MP_TUNNELBRIDGE);

   149

	SetTileOwner(t, o);

   150

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

   151

	_m[t].m4 = 0;

   152

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

   153

}

   154

   155

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

   156

{

   157

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

   158

	_m[t].m3 = 0;

   159

}

   160

   161

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

   162

{

   163

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

   164

	_m[t].m3 = r;

   165

}

   166

   167

   168

#endif