1

/* $Id$ */

     2

     3

/** @file bridge_map.h Map accessor functions for bridges. */

     4

     5

#ifndef BRIDGE_MAP_H

     6

#define BRIDGE_MAP_H

     7

     8

#include "direction_func.h"

     9

#include "rail_type.h"

    10

#include "transport_type.h"

    11

#include "road_map.h"

    12

#include "bridge.h"

    13

    14

/**

    15

 * Checks if this is a bridge, instead of a tunnel

    16

 * @param t The tile to analyze

    17

 * @pre IsTileType(t, MP_TUNNELBRIDGE)

    18

 * @return true if the structure is a bridge one

    19

 */

    20

static inline bool IsBridge(TileIndex t)

    21

{

    22

	assert(IsTileType(t, MP_TUNNELBRIDGE));

    23

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

    24

}

    25

    26

/**

    27

 * checks if there is a bridge on this tile

    28

 * @param t The tile to analyze

    29

 * @return true if a bridge is present

    30

 */

    31

static inline bool IsBridgeTile(TileIndex t)

    32

{

    33

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

    34

}

    35

    36

/**

    37

 * checks for the possibility that a bridge may be on this tile

    38

 * These are in fact all the tile types on which a bridge can be found

    39

 * @param t The tile to analyze

    40

 * @return true if a bridge migh be present

    41

 */

    42

static inline bool MayHaveBridgeAbove(TileIndex t)

    43

{

    44

	return

    45

		IsTileType(t, MP_CLEAR) ||

    46

		IsTileType(t, MP_RAILWAY) ||

    47

		IsTileType(t, MP_ROAD) ||

    48

		IsTileType(t, MP_WATER) ||

    49

		IsTileType(t, MP_TUNNELBRIDGE) ||

    50

		IsTileType(t, MP_UNMOVABLE);

    51

}

    52

    53

/**

    54

 * checks if a bridge is set above the ground of this tile

    55

 * @param t The tile to analyze

    56

 * @pre MayHaveBridgeAbove(t)

    57

 * @return true if a bridge is detected above

    58

 */

    59

static inline bool IsBridgeAbove(TileIndex t)

    60

{

    61

	assert(MayHaveBridgeAbove(t));

    62

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

    63

}

    64

    65

/**

    66

 * Determines the type of bridge on a tile

    67

 * @param t The tile to analyze

    68

 * @pre IsBridgeTile(t)

    69

 * @return The bridge type

    70

 */

    71

static inline BridgeType GetBridgeType(TileIndex t)

    72

{

    73

	assert(IsBridgeTile(t));

    74

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

    75

}

    76

    77

/**

    78

 * Get the axis of the bridge that goes over the tile. Not the axis or the ramp.

    79

 * @param t The tile to analyze

    80

 * @pre IsBridgeAbove(t)

    81

 * @return the above mentioned axis

    82

 */

    83

static inline Axis GetBridgeAxis(TileIndex t)

    84

{

    85

	assert(IsBridgeAbove(t));

    86

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

    87

}

    88

    89

/**

    90

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

    91

 * @param t the bridge tile to find the bridge ramp for

    92

 * @param d the direction to search in

    93

 */

    94

TileIndex GetBridgeEnd(TileIndex t, DiagDirection d);

    95

    96

/**

    97

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

    98

 * @param t the bridge tile to find the bridge ramp for

    99

 */

   100

TileIndex GetNorthernBridgeEnd(TileIndex t);

   101

   102

/**

   103

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

   104

 * @param t the bridge tile to find the bridge ramp for

   105

 */

   106

TileIndex GetSouthernBridgeEnd(TileIndex t);

   107

   108

   109

/**

   110

 * Starting at one bridge end finds the other bridge end

   111

 * @param t the bridge ramp tile to find the other bridge ramp for

   112

 */

   113

TileIndex GetOtherBridgeEnd(TileIndex t);

   114

   115

/**

   116

 * Get the height ('z') of a bridge in pixels.

   117

 * @param tile the bridge ramp tile to get the bridge height from

   118

 * @return the height of the bridge in pixels

   119

 */

   120

uint GetBridgeHeight(TileIndex tile);

   121

   122

/**

   123

 * Remove the bridge over the given axis.

   124

 * @param t the tile to remove the bridge from

   125

 * @param a the axis of the bridge to remove

   126

 * @pre MayHaveBridgeAbove(t)

   127

 */

   128

static inline void ClearSingleBridgeMiddle(TileIndex t, Axis a)

   129

{

   130

	assert(MayHaveBridgeAbove(t));

   131

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

   132

}

   133

   134

/**

   135

 * Removes bridges from the given, that is bridges along the X and Y axis.

   136

 * @param t the tile to remove the bridge from

   137

 * @pre MayHaveBridgeAbove(t)

   138

 */

   139

static inline void ClearBridgeMiddle(TileIndex t)

   140

{

   141

	ClearSingleBridgeMiddle(t, AXIS_X);

   142

	ClearSingleBridgeMiddle(t, AXIS_Y);

   143

}

   144

   145

/**

   146

 * Set that there is a bridge over the given axis.

   147

 * @param t the tile to add the bridge to

   148

 * @param a the axis of the bridge to add

   149

 * @pre MayHaveBridgeAbove(t)

   150

 */

   151

static inline void SetBridgeMiddle(TileIndex t, Axis a)

   152

{

   153

	assert(MayHaveBridgeAbove(t));

   154

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

   155

}

   156

   157

/**

   158

 * Generic part to make a bridge ramp for both roads and rails.

   159

 * @param t          the tile to make a bridge ramp

   160

 * @param o          the new owner of the bridge ramp

   161

 * @param bridgetype the type of bridge this bridge ramp belongs to

   162

 * @param d          the direction this ramp must be facing

   163

 * @param tt         the transport type of the bridge

   164

 * @param rt         the road or rail type

   165

 * @note this function should not be called directly.

   166

 */

   167

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

   168

{

   169

	SetTileType(t, MP_TUNNELBRIDGE);

   170

	SetTileOwner(t, o);

   171

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

   172

	_m[t].m3 = rt;

   173

	_m[t].m4 = 0;

   174

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

   175

}

   176

   177

/**

   178

 * Make a bridge ramp for roads.

   179

 * @param t          the tile to make a bridge ramp

   180

 * @param o          the new owner of the bridge ramp

   181

 * @param bridgetype the type of bridge this bridge ramp belongs to

   182

 * @param d          the direction this ramp must be facing

   183

 * @param r          the road type of the bridge

   184

 */

   185

static inline void MakeRoadBridgeRamp(TileIndex t, Owner o, BridgeType bridgetype, DiagDirection d, RoadTypes r)

   186

{

   187

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

   188

}

   189

   190

/**

   191

 * Make a bridge ramp for rails.

   192

 * @param t          the tile to make a bridge ramp

   193

 * @param o          the new owner of the bridge ramp

   194

 * @param bridgetype the type of bridge this bridge ramp belongs to

   195

 * @param d          the direction this ramp must be facing

   196

 * @param r          the rail type of the bridge

   197

 */

   198

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

   199

{

   200

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

   201

}

   202

   203

/**

   204

 * Make a bridge ramp for aqueducts.

   205

 * @param t          the tile to make a bridge ramp

   206

 * @param o          the new owner of the bridge ramp

   207

 * @param d          the direction this ramp must be facing

   208

 */

   209

static inline void MakeAqueductBridgeRamp(TileIndex t, Owner o, DiagDirection d)

   210

{

   211

	MakeBridgeRamp(t, o, 0, d, TRANSPORT_WATER, 0);

   212

}

   213

   214

#endif /* BRIDGE_MAP_H */