1

/* $Id$ */

     2

     3

/** @file bridge_map.h */

     4

     5

#ifndef BRIDGE_MAP_H

     6

#define BRIDGE_MAP_H

     7

     8

#include "direction.h"

     9

#include "macros.h"

    10

#include "map.h"

    11

#include "rail.h"

    12

#include "road_map.h"

    13

#include "tile.h"

    14

    15

    16

static inline bool IsBridge(TileIndex t)

    17

{

    18

	assert(IsTileType(t, MP_TUNNELBRIDGE));

    19

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

    20

}

    21

    22

static inline bool IsBridgeTile(TileIndex t)

    23

{

    24

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

    25

}

    26

    27

    28

static inline bool MayHaveBridgeAbove(TileIndex t)

    29

{

    30

	return

    31

		IsTileType(t, MP_CLEAR) ||

    32

		IsTileType(t, MP_RAILWAY) ||

    33

		IsTileType(t, MP_STREET) ||

    34

		IsTileType(t, MP_WATER) ||

    35

		IsTileType(t, MP_TUNNELBRIDGE) ||

    36

		IsTileType(t, MP_UNMOVABLE);

    37

}

    38

    39

    40

static inline bool IsBridgeAbove(TileIndex t)

    41

{

    42

	assert(MayHaveBridgeAbove(t));

    43

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

    44

}

    45

    46

    47

/**

    48

 * Determines the type of bridge on a tile

    49

 * @param tile The tile to analyze

    50

 * @return The bridge type

    51

 */

    52

static inline uint GetBridgeType(TileIndex t)

    53

{

    54

	assert(IsBridgeTile(t));

    55

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

    56

}

    57

    58

    59

/**

    60

 * Get the direction pointing onto the bridge

    61

 * @param tile The tile to analyze

    62

 * @return the above mentionned direction

    63

 */

    64

static inline DiagDirection GetBridgeRampDirection(TileIndex t)

    65

{

    66

	assert(IsBridgeTile(t));

    67

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

    68

}

    69

    70

    71

static inline Axis GetBridgeAxis(TileIndex t)

    72

{

    73

	assert(IsBridgeAbove(t));

    74

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

    75

}

    76

    77

    78

static inline TransportType GetBridgeTransportType(TileIndex t)

    79

{

    80

	assert(IsBridgeTile(t));

    81

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

    82

}

    83

    84

    85

static inline bool HasBridgeSnowOrDesert(TileIndex t)

    86

{

    87

	assert(IsBridgeTile(t));

    88

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

    89

}

    90

    91

    92

static inline void SetBridgeSnowOrDesert(TileIndex t, bool snow_or_desert)

    93

{

    94

	assert(IsBridgeTile(t));

    95

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

    96

}

    97

    98

/**

    99

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

   100

 */

   101

TileIndex GetBridgeEnd(TileIndex, DiagDirection);

   102

   103

/**

   104

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

   105

 */

   106

TileIndex GetNorthernBridgeEnd(TileIndex t);

   107

   108

/**

   109

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

   110

 */

   111

TileIndex GetSouthernBridgeEnd(TileIndex t);

   112

   113

   114

/**

   115

 * Starting at one bridge end finds the other bridge end

   116

 */

   117

TileIndex GetOtherBridgeEnd(TileIndex);

   118

   119

uint GetBridgeHeight(TileIndex tile);

   120

uint GetBridgeFoundation(Slope tileh, Axis axis);

   121

   122

static inline void ClearSingleBridgeMiddle(TileIndex t, Axis a)

   123

{

   124

	assert(MayHaveBridgeAbove(t));

   125

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

   126

}

   127

   128

   129

static inline void ClearBridgeMiddle(TileIndex t)

   130

{

   131

	ClearSingleBridgeMiddle(t, AXIS_X);

   132

	ClearSingleBridgeMiddle(t, AXIS_Y);

   133

}

   134

   135

static inline void SetBridgeMiddle(TileIndex t, Axis a)

   136

{

   137

	assert(MayHaveBridgeAbove(t));

   138

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

   139

}

   140

   141

   142

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

   143

{

   144

	SetTileType(t, MP_TUNNELBRIDGE);

   145

	SetTileOwner(t, o);

   146

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

   147

	_m[t].m4 = 0;

   148

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

   149

}

   150

   151

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

   152

{

   153

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

   154

	_m[t].m3 = 0;

   155

}

   156

   157

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

   158

{

   159

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

   160

	_m[t].m3 = r;

   161

}

   162

   163

   164

#endif /* BRIDGE_MAP_H */