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

#define M(x) (1 << (x))

    17

enum {

    18

	// foundation, whole tile is leveled up --> 3 corners raised

    19

	BRIDGE_FULL_LEVELED_FOUNDATION = M(SLOPE_WSE) | M(SLOPE_NWS) | M(SLOPE_ENW) | M(SLOPE_SEN),

    20

	// foundation, tile is partly leveled up --> 1 corner raised

    21

	BRIDGE_PARTLY_LEVELED_FOUNDATION = M(SLOPE_W) | M(SLOPE_S) | M(SLOPE_E) | M(SLOPE_N),

    22

	// no foundations (X,Y direction)

    23

	BRIDGE_NO_FOUNDATION = M(SLOPE_FLAT) | M(SLOPE_SW) | M(SLOPE_SE) | M(SLOPE_NW) | M(SLOPE_NE),

    24

	BRIDGE_HORZ_RAMP = (BRIDGE_PARTLY_LEVELED_FOUNDATION | BRIDGE_NO_FOUNDATION) & ~M(SLOPE_FLAT)

    25

};

    26

#undef M

    27

    28

    29

static inline bool IsBridgeTile(TileIndex t)

    30

{

    31

	return IsTileType(t, MP_STREET_BRIDGE) || IsTileType(t, MP_RAILWAY_BRIDGE);

    32

}

    33

    34

static inline bool MayHaveBridgeAbove(TileIndex t)

    35

{

    36

	return

    37

		IsTileType(t, MP_CLEAR) ||

    38

		IsTileType(t, MP_RAILWAY) ||

    39

		IsTileType(t, MP_STREET) ||

    40

		IsTileType(t, MP_WATER) ||

    41

		IsTileType(t, MP_TUNNEL) ||

    42

		IsTileType(t, MP_STREET_BRIDGE) ||

    43

		IsTileType(t, MP_RAILWAY_BRIDGE) ||

    44

		IsTileType(t, MP_UNMOVABLE);

    45

}

    46

    47

    48

static inline bool IsBridgeAbove(TileIndex t)

    49

{

    50

	assert(MayHaveBridgeAbove(t));

    51

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

    52

}

    53

    54

    55

/**

    56

 * Determines the type of bridge on a tile

    57

 * @param tile The tile to analyze

    58

 * @return The bridge type

    59

 */

    60

static inline uint GetBridgeType(TileIndex t)

    61

{

    62

	assert(IsBridgeTile(t));

    63

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

    64

}

    65

    66

    67

/**

    68

 * Get the direction pointing onto the bridge

    69

 */

    70

static inline DiagDirection GetBridgeRampDirection(TileIndex t)

    71

{

    72

	assert(IsBridgeTile(t));

    73

	return (DiagDirection)GB(_m[t].m4, 5, 2);

    74

}

    75

    76

    77

static inline Axis GetBridgeAxis(TileIndex t)

    78

{

    79

	assert(IsBridgeAbove(t));

    80

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

    81

}

    82

    83

    84

static inline TransportType GetBridgeTransportType(TileIndex t)

    85

{

    86

	assert(IsBridgeTile(t));

    87

	if (IsTileType(t, MP_STREET_BRIDGE)) return TRANSPORT_ROAD;

    88

    89

	return TRANSPORT_RAIL;

    90

}

    91

    92

    93

static inline bool HasBridgeSnowOrDesert(TileIndex t)

    94

{

    95

	assert(IsBridgeTile(t));

    96

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

    97

}

    98

    99

   100

static inline void SetBridgeSnowOrDesert(TileIndex t, bool snow_or_desert)

   101

{

   102

	assert(IsBridgeTile(t));

   103

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

   104

}

   105

   106

/**

   107

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

   108

 */

   109

TileIndex GetBridgeEnd(TileIndex, DiagDirection);

   110

   111

/**

   112

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

   113

 */

   114

TileIndex GetNorthernBridgeEnd(TileIndex t);

   115

   116

/**

   117

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

   118

 */

   119

TileIndex GetSouthernBridgeEnd(TileIndex t);

   120

   121

   122

/**

   123

 * Starting at one bridge end finds the other bridge end

   124

 */

   125

TileIndex GetOtherBridgeEnd(TileIndex);

   126

   127

uint GetBridgeHeight(TileIndex tile);

   128

uint GetBridgeFoundation(Slope tileh, Axis axis);

   129

   130

static inline void ClearSingleBridgeMiddle(TileIndex t, Axis a)

   131

{

   132

	assert(MayHaveBridgeAbove(t));

   133

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

   134

}

   135

   136

   137

static inline void ClearBridgeMiddle(TileIndex t)

   138

{

   139

	ClearSingleBridgeMiddle(t, AXIS_X);

   140

	ClearSingleBridgeMiddle(t, AXIS_Y);

   141

}

   142

   143

static inline void SetBridgeMiddle(TileIndex t, Axis a)

   144

{

   145

	assert(MayHaveBridgeAbove(t));

   146

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

   147

}

   148

   149

   150

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

   151

{

   152

	SetTileOwner(t, o);

   153

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

   154

	_m[t].m4 = d << 5;

   155

	_m[t].m5 = 0;

   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

	SetTileType(t, MP_STREET_BRIDGE);

   162

	_m[t].m3 = 0;

   163

}

   164

   165

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

   166

{

   167

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

   168

	SetTileType(t, MP_RAILWAY_BRIDGE);

   169

	_m[t].m3 = r;

   170

	_m[t].m5 = DiagDirToAxis(d) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y;

   171

}

   172

   173

   174

#endif /* BRIDGE_MAP_H */