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 IsBridgeTile(TileIndex t)

    18

{

    19

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

    20

}

    21

    22

static inline bool MayHaveBridgeAbove(TileIndex t)

    23

{

    24

	return

    25

		IsTileType(t, MP_CLEAR) ||

    26

		IsTileType(t, MP_RAILWAY) ||

    27

		IsTileType(t, MP_STREET) ||

    28

		IsTileType(t, MP_WATER) ||

    29

		IsTileType(t, MP_TUNNEL) ||

    30

		IsTileType(t, MP_STREET_BRIDGE) ||

    31

		IsTileType(t, MP_RAILWAY_BRIDGE) ||

    32

		IsTileType(t, MP_UNMOVABLE);

    33

}

    34

    35

    36

static inline bool IsBridgeAbove(TileIndex t)

    37

{

    38

	assert(MayHaveBridgeAbove(t));

    39

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

    40

}

    41

    42

    43

/**

    44

 * Determines the type of bridge on a tile

    45

 * @param tile The tile to analyze

    46

 * @return The bridge type

    47

 */

    48

static inline uint GetBridgeType(TileIndex t)

    49

{

    50

	assert(IsBridgeTile(t));

    51

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

    52

}

    53

    54

    55

/**

    56

 * Get the direction pointing onto the bridge

    57

 */

    58

static inline DiagDirection GetBridgeRampDirection(TileIndex t)

    59

{

    60

	assert(IsBridgeTile(t));

    61

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

    62

}

    63

    64

    65

static inline Axis GetBridgeAxis(TileIndex t)

    66

{

    67

	assert(IsBridgeAbove(t));

    68

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

    69

}

    70

    71

    72

static inline TransportType GetBridgeTransportType(TileIndex t)

    73

{

    74

	assert(IsBridgeTile(t));

    75

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

    76

    77

	return TRANSPORT_RAIL;

    78

}

    79

    80

    94

/**

    95

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

    96

 */

    97

TileIndex GetBridgeEnd(TileIndex, DiagDirection);

    98

    99

/**

   100

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

   101

 */

   102

TileIndex GetNorthernBridgeEnd(TileIndex t);

   103

   104

/**

   105

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

   106

 */

   107

TileIndex GetSouthernBridgeEnd(TileIndex t);

   108

   109

   110

/**

   111

 * Starting at one bridge end finds the other bridge end

   112

 */

   113

TileIndex GetOtherBridgeEnd(TileIndex);

   114

   115

uint GetBridgeHeight(TileIndex tile);

   116

uint GetBridgeFoundation(Slope tileh, Axis axis);

   117

   118

static inline void ClearSingleBridgeMiddle(TileIndex t, Axis a)

   119

{

   120

	assert(MayHaveBridgeAbove(t));

   121

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

   122

}

   123

   124

   125

static inline void ClearBridgeMiddle(TileIndex t)

   126

{

   127

	ClearSingleBridgeMiddle(t, AXIS_X);

   128

	ClearSingleBridgeMiddle(t, AXIS_Y);

   129

}

   130

   131

static inline void SetBridgeMiddle(TileIndex t, Axis a)

   132

{

   133

	assert(MayHaveBridgeAbove(t));

   134

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

   135

}

   136

   137

   138

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

   139

{

   140

	SetTileOwner(t, o);

   141

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

   142

	_m[t].m4 = 0;

   143

	_m[t].m5 = d;

   144

}

   145

   146

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

   147

{

   148

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

   149

	SetTileType(t, MP_STREET_BRIDGE);

   150

	_m[t].m3 = 0;

   151

}

   152

   153

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

   154

{

   155

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

   156

	SetTileType(t, MP_RAILWAY_BRIDGE);

   157

	_m[t].m3 = r;

   158

}

   159

   160

   161

#endif /* BRIDGE_MAP_H */