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 "road_map.h"

    11

    12

    13

/**

    14

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

    15

 * @param t The tile to analyze

    16

 * @pre IsTileType(t, MP_TUNNELBRIDGE)

    17

 * @return true if the structure is a bridge one

    18

 */

    19

static inline bool IsBridge(TileIndex t)

    20

{

    21

	assert(IsTileType(t, MP_TUNNELBRIDGE));

    22

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

    23

}

    24

    25

/**

    26

 * checks if there is a bridge on this tile

    27

 * @param t The tile to analyze

    28

 * @return true if a bridge is present

    29

 */

    30

static inline bool IsBridgeTile(TileIndex t)

    31

{

    32

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

    33

}

    34

    35

/**

    36

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

    37

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

    38

 * @param t The tile to analyze

    39

 * @return true if a bridge migh be present

    40

 */

    41

static inline bool MayHaveBridgeAbove(TileIndex t)

    42

{

    43

	return

    44

		IsTileType(t, MP_CLEAR) ||

    45

		IsTileType(t, MP_RAILWAY) ||

    46

		IsTileType(t, MP_ROAD) ||

    47

		IsTileType(t, MP_WATER) ||

    48

		IsTileType(t, MP_TUNNELBRIDGE) ||

    49

		IsTileType(t, MP_UNMOVABLE);

    50

}

    51

    52

/**

    53

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

    54

 * @param t The tile to analyze

    55

 * @pre MayHaveBridgeAbove(t)

    56

 * @return true if a bridge is detected above

    57

 */

    58

static inline bool IsBridgeAbove(TileIndex t)

    59

{

    60

	assert(MayHaveBridgeAbove(t));

    61

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

    62

}

    63

    64

/**

    65

 * Determines the type of bridge on a tile

    66

 * @param t The tile to analyze

    67

 * @pre IsBridgeTile(t)

    68

 * @return The bridge type

    69

 */

    70

static inline uint GetBridgeType(TileIndex t)

    71

{

    72

	assert(IsBridgeTile(t));

    73

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

    74

}

    75

    76

/**

    77

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

    78

 * @param t The tile to analyze

    79

 * @pre IsBridgeAbove(t)

    80

 * @return the above mentioned axis

    81

 */

    82

static inline Axis GetBridgeAxis(TileIndex t)

    83

{

    84

	assert(IsBridgeAbove(t));

    85

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

    86

}

    87

    88

/**

    89

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

    90

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

    91

 * @param d the direction to search in

    92

 */

    93

TileIndex GetBridgeEnd(TileIndex t, DiagDirection d);

    94

    95

/**

    96

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

    97

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

    98

 */

    99

TileIndex GetNorthernBridgeEnd(TileIndex t);

   100

   101

/**

   102

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

   103

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

   104

 */

   105

TileIndex GetSouthernBridgeEnd(TileIndex t);

   106

   107

   108

/**

   109

 * Starting at one bridge end finds the other bridge end

   110

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

   111

 */

   112

TileIndex GetOtherBridgeEnd(TileIndex t);

   113

   114

/**

   115

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

   116

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

   117

 * @return the height of the bridge in pixels

   118

 */

   119

uint GetBridgeHeight(TileIndex tile);

   120

   121

/**

   122

 * Remove the bridge over the given axis.

   123

 * @param t the tile to remove the bridge from

   124

 * @param a the axis of the bridge to remove

   125

 * @pre MayHaveBridgeAbove(t)

   126

 */

   127

static inline void ClearSingleBridgeMiddle(TileIndex t, Axis a)

   128

{

   129

	assert(MayHaveBridgeAbove(t));

   130

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

   131

}

   132

   133

/**

   134

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

   135

 * @param t the tile to remove the bridge from

   136

 * @pre MayHaveBridgeAbove(t)

   137

 */

   138

static inline void ClearBridgeMiddle(TileIndex t)

   139

{

   140

	ClearSingleBridgeMiddle(t, AXIS_X);

   141

	ClearSingleBridgeMiddle(t, AXIS_Y);

   142

}

   143

   144

/**

   145

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

   146

 * @param t the tile to add the bridge to

   147

 * @param a the axis of the bridge to add

   148

 * @pre MayHaveBridgeAbove(t)

   149

 */

   150

static inline void SetBridgeMiddle(TileIndex t, Axis a)

   151

{

   152

	assert(MayHaveBridgeAbove(t));

   153

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

   154

}

   155

   156

/**

   157

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

   158

 * @param t          the tile to make a bridge ramp

   159

 * @param o          the new owner of the bridge ramp

   160

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

   161

 * @param d          the direction this ramp must be facing

   162

 * @param tt         the transport type of the bridge

   163

 * @param rt         the road or rail type

   164

 * @note this function should not be called directly.

   165

 */

   166

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

   167

{

   168

	SetTileType(t, MP_TUNNELBRIDGE);

   169

	SetTileOwner(t, o);

   170

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

   171

	_m[t].m3 = rt;

   172

	_m[t].m4 = 0;

   173

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

   174

}

   175

   176

/**

   177

 * Make a bridge ramp for roads.

   178

 * @param t          the tile to make a bridge ramp

   179

 * @param o          the new owner of the bridge ramp

   180

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

   181

 * @param d          the direction this ramp must be facing

   182

 * @param r          the road type of the bridge

   183

 */

   184

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

   185

{

   186

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

   187

}

   188

   189

/**

   190

 * Make a bridge ramp for rails.

   191

 * @param t          the tile to make a bridge ramp

   192

 * @param o          the new owner of the bridge ramp

   193

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

   194

 * @param d          the direction this ramp must be facing

   195

 * @param r          the rail type of the bridge

   196

 */

   197

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

   198

{

   199

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

   200

}

   201

   202

   203

#endif /* BRIDGE_MAP_H */