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

		IsTileType(t, MP_UNMOVABLE);

    38

}

    39

    40

    41

static inline bool IsBridgeAbove(TileIndex t)

    42

{

    43

	assert(MayHaveBridgeAbove(t));

    44

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

    45

}

    46

    47

    48

/**

    49

 * Determines the type of bridge on a tile

    50

 * @param tile The tile to analyze

    51

 * @return The bridge type

    52

 */

    53

static inline uint GetBridgeType(TileIndex t)

    54

{

    55

	assert(IsBridgeTile(t));

    56

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

    57

}

    58

    59

    60

/**

    61

 * Get the direction pointing onto the bridge

    62

 */

    63

static inline DiagDirection GetBridgeRampDirection(TileIndex t)

    64

{

    65

	assert(IsBridgeTile(t));

    66

	return (DiagDirection)GB(_m[t].m5, 0, 2);

    67

}

    68

    69

    70

static inline Axis GetBridgeAxis(TileIndex t)

    71

{

    72

	assert(IsBridgeAbove(t));

    73

	return (Axis)(GB(_m[t].extra, 6, 2) - 1);

    74

}

    75

    76

    77

static inline TransportType GetBridgeTransportType(TileIndex t)

    78

{

    79

	assert(IsBridgeTile(t));

    80

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

    81

}

    82

    83

    84

static inline bool HasBridgeSnowOrDesert(TileIndex t)

    85

{

    86

	assert(IsBridgeTile(t));

    87

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

    88

}

    89

    90

    91

static inline void SetBridgeSnowOrDesert(TileIndex t, bool snow_or_desert)

    92

{

    93

	assert(IsBridgeTile(t));

    94

	SB(_m[t].m4, 7, 1, snow_or_desert);

    95

}

    96

    97

/**

    98

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

    99

 */

   100

TileIndex GetBridgeEnd(TileIndex, DiagDirection);

   101

   102

/**

   103

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

   104

 */

   105

TileIndex GetNorthernBridgeEnd(TileIndex t);

   106

   107

/**

   108

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

   109

 */

   110

TileIndex GetSouthernBridgeEnd(TileIndex t);

   111

   112

   113

/**

   114

 * Starting at one bridge end finds the other bridge end

   115

 */

   116

TileIndex GetOtherBridgeEnd(TileIndex);

   117

   118

uint GetBridgeHeight(TileIndex tile);

   119

uint GetBridgeFoundation(Slope tileh, Axis axis);

   120

   121

static inline void ClearSingleBridgeMiddle(TileIndex t, Axis a)

   122

{

   123

	assert(MayHaveBridgeAbove(t));

   124

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

   125

}

   126

   127

   128

static inline void ClearBridgeMiddle(TileIndex t)

   129

{

   130

	ClearSingleBridgeMiddle(t, AXIS_X);

   131

	ClearSingleBridgeMiddle(t, AXIS_Y);

   132

}

   133

   134

static inline void SetBridgeMiddle(TileIndex t, Axis a)

   135

{

   136

	assert(MayHaveBridgeAbove(t));

   137

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

   138

}

   139

   140

   141

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

   142

{

   143

	SetTileType(t, MP_TUNNELBRIDGE);

   144

	SetTileOwner(t, o);

   145

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

   146

	_m[t].m4 = 0;

   147

	_m[t].m5 = 1 << 7 | tt << 2 | d;

   148

}

   149

   150

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

   151

{

   152

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

   153

	_m[t].m3 = 0;

   154

}

   155

   156

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

   157

{

   158

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

   159

	_m[t].m3 = r;

   160

}

   161

   162

   163

#endif /* BRIDGE_MAP_H */