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.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

/**

    17

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

    18

 * @param t The tile to analyze

    19

 * @pre IsTileType(t, MP_TUNNELBRIDGE)

    20

 * @return true if the structure is a bridge one

    21

 */

    22

static inline bool IsBridge(TileIndex t)

    23

{

    24

	assert(IsTileType(t, MP_TUNNELBRIDGE));

    25

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

    26

}

    27

    28

/**

    29

 * checks if there is a bridge on this tile

    30

 * @param t The tile to analyze

    31

 * @return true if a bridge is present

    32

 */

    33

static inline bool IsBridgeTile(TileIndex t)

    34

{

    35

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

    36

}

    37

    38

/**

    39

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

    40

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

    41

 * @param t The tile to analyze

    42

 * @return true if a bridge migh be present

    43

 */

    44

static inline bool MayHaveBridgeAbove(TileIndex t)

    45

{

    46

	return

    47

		IsTileType(t, MP_CLEAR) ||

    48

		IsTileType(t, MP_RAILWAY) ||

    49

		IsTileType(t, MP_ROAD) ||

    50

		IsTileType(t, MP_WATER) ||

    51

		IsTileType(t, MP_TUNNELBRIDGE) ||

    52

		IsTileType(t, MP_UNMOVABLE);

    53

}

    54

    55

/**

    56

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

    57

 * @param t The tile to analyze

    58

 * @pre MayHaveBridgeAbove(t)

    59

 * @return true if a bridge is detected above

    60

 */

    61

static inline bool IsBridgeAbove(TileIndex t)

    62

{

    63

	assert(MayHaveBridgeAbove(t));

    64

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

    65

}

    66

    67

/**

    68

 * Determines the type of bridge on a tile

    69

 * @param t The tile to analyze

    70

 * @pre IsBridgeTile(t)

    71

 * @return The bridge type

    72

 */

    73

static inline uint GetBridgeType(TileIndex t)

    74

{

    75

	assert(IsBridgeTile(t));

    76

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

    77

}

    78

    79

/**

    80

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

    81

 * @param t The tile to analyze

    82

 * @pre IsBridgeAbove(t)

    83

 * @return the above mentioned axis

    84

 */

    85

static inline Axis GetBridgeAxis(TileIndex t)

    86

{

    87

	assert(IsBridgeAbove(t));

    88

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

    89

}

    90

    91

/**

    92

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

    93

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

    94

 * @param d the direction to search in

    95

 */

    96

TileIndex GetBridgeEnd(TileIndex t, DiagDirection d);

    97

    98

/**

    99

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

   100

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

   101

 */

   102

TileIndex GetNorthernBridgeEnd(TileIndex t);

   103

   104

/**

   105

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

   106

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

   107

 */

   108

TileIndex GetSouthernBridgeEnd(TileIndex t);

   109

   110

   111

/**

   112

 * Starting at one bridge end finds the other bridge end

   113

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

   114

 */

   115

TileIndex GetOtherBridgeEnd(TileIndex t);

   116

   117

/**

   118

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

   119

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

   120

 * @return the height of the bridge in pixels

   121

 */

   122

uint GetBridgeHeight(TileIndex tile);

   123

   124

/**

   125

 * Remove the bridge over the given axis.

   126

 * @param t the tile to remove the bridge from

   127

 * @param a the axis of the bridge to remove

   128

 * @pre MayHaveBridgeAbove(t)

   129

 */

   130

static inline void ClearSingleBridgeMiddle(TileIndex t, Axis a)

   131

{

   132

	assert(MayHaveBridgeAbove(t));

   133

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

   134

}

   135

   136

/**

   137

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

   138

 * @param t the tile to remove the bridge from

   139

 * @pre MayHaveBridgeAbove(t)

   140

 */

   141

static inline void ClearBridgeMiddle(TileIndex t)

   142

{

   143

	ClearSingleBridgeMiddle(t, AXIS_X);

   144

	ClearSingleBridgeMiddle(t, AXIS_Y);

   145

}

   146

   147

/**

   148

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

   149

 * @param t the tile to add the bridge to

   150

 * @param a the axis of the bridge to add

   151

 * @pre MayHaveBridgeAbove(t)

   152

 */

   153

static inline void SetBridgeMiddle(TileIndex t, Axis a)

   154

{

   155

	assert(MayHaveBridgeAbove(t));

   156

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

   157

}

   158

   159

/**

   160

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

   161

 * @param t          the tile to make a bridge ramp

   162

 * @param o          the new owner of the bridge ramp

   163

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

   164

 * @param d          the direction this ramp must be facing

   165

 * @param tt         the transport type of the bridge

   166

 * @param rt         the road or rail type

   167

 * @note this function should not be called directly.

   168

 */

   169

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

   170

{

   171

	SetTileType(t, MP_TUNNELBRIDGE);

   172

	SetTileOwner(t, o);

   173

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

   174

	_m[t].m3 = rt;

   175

	_m[t].m4 = 0;

   176

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

   177

}

   178

   179

/**

   180

 * Make a bridge ramp for roads.

   181

 * @param t          the tile to make a bridge ramp

   182

 * @param o          the new owner of the bridge ramp

   183

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

   184

 * @param d          the direction this ramp must be facing

   185

 * @param r          the road type of the bridge

   186

 */

   187

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

   188

{

   189

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

   190

}

   191

   192

/**

   193

 * Make a bridge ramp for rails.

   194

 * @param t          the tile to make a bridge ramp

   195

 * @param o          the new owner of the bridge ramp

   196

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

   197

 * @param d          the direction this ramp must be facing

   198

 * @param r          the rail type of the bridge

   199

 */

   200

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

   201

{

   202

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

   203

}

   204

   205

   206

#endif /* BRIDGE_MAP_H */