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_STREET) ||

    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

/**

    69

 * Determines the type of bridge on a tile

    70

 * @param t The tile to analyze

    71

 * @pre IsBridgeTile(t)

    72

 * @return The bridge type

    73

 */

    74

static inline uint GetBridgeType(TileIndex t)

    75

{

    76

	assert(IsBridgeTile(t));

    77

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

    78

}

    79

    80

    81

/**

    82

 * Get the direction pointing onto the bridge

    83

 * @param t The tile to analyze

    84

 * @pre IsBridgeTile(t)

    85

 * @return the above mentionned direction

    86

 */

    87

static inline DiagDirection GetBridgeRampDirection(TileIndex t)

    88

{

    89

	assert(IsBridgeTile(t));

    90

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

    91

}

    92

    93

    94

/**

    95

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

    96

 * @param t The tile to analyze

    97

 * @pre IsBridgeAbove(t)

    98

 * @return the above mentioned axis

    99

 */

   100

static inline Axis GetBridgeAxis(TileIndex t)

   101

{

   102

	assert(IsBridgeAbove(t));

   103

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

   104

}

   105

   106

   107

/**

   108

 * Get the transport type of the bridge's ramp.

   109

 * @param t The ramp tile to analyze

   110

 * @pre IsBridgeTile(t)

   111

 * @return the transport type of the bridge

   112

 */

   113

static inline TransportType GetBridgeTransportType(TileIndex t)

   114

{

   115

	assert(IsBridgeTile(t));

   116

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

   117

}

   118

   119

   120

/**

   121

 * Does the bridge ramp lie in a snow or desert area?

   122

 * @param t The ramp tile to analyze

   123

 * @pre IsBridgeTile(t)

   124

 * @return true if and only if in a snow or desert area

   125

 */

   126

static inline bool HasBridgeSnowOrDesert(TileIndex t)

   127

{

   128

	assert(IsBridgeTile(t));

   129

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

   130

}

   131

   132

   133

/**

   134

 * Sets whether the bridge ramp lies in a snow or desert area.

   135

 * @param t              The ramp tile to set (un)make a snow/desert area

   136

 * @param snow_or_desert Make (true) or unmake the tile a snow/desert area

   137

 * @pre IsBridgeTile(t)

   138

 */

   139

static inline void SetBridgeSnowOrDesert(TileIndex t, bool snow_or_desert)

   140

{

   141

	assert(IsBridgeTile(t));

   142

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

   143

}

   144

   145

/**

   146

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

   147

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

   148

 * @param d the direction to search in

   149

 */

   150

TileIndex GetBridgeEnd(TileIndex t, DiagDirection d);

   151

   152

/**

   153

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

   154

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

   155

 */

   156

TileIndex GetNorthernBridgeEnd(TileIndex t);

   157

   158

/**

   159

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

   160

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

   161

 */

   162

TileIndex GetSouthernBridgeEnd(TileIndex t);

   163

   164

   165

/**

   166

 * Starting at one bridge end finds the other bridge end

   167

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

   168

 */

   169

TileIndex GetOtherBridgeEnd(TileIndex t);

   170

   171

/**

   172

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

   173

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

   174

 * @return the height of the bridge in pixels

   175

 */

   176

uint GetBridgeHeight(TileIndex tile);

   177

   178

/**

   179

 * Remove the bridge over the given axis.

   180

 * @param t the tile to remove the bridge from

   181

 * @param a the axis of the bridge to remove

   182

 * @pre MayHaveBridgeAbove(t)

   183

 */

   184

static inline void ClearSingleBridgeMiddle(TileIndex t, Axis a)

   185

{

   186

	assert(MayHaveBridgeAbove(t));

   187

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

   188

}

   189

   190

   191

/**

   192

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

   193

 * @param t the tile to remove the bridge from

   194

 * @pre MayHaveBridgeAbove(t)

   195

 */

   196

static inline void ClearBridgeMiddle(TileIndex t)

   197

{

   198

	ClearSingleBridgeMiddle(t, AXIS_X);

   199

	ClearSingleBridgeMiddle(t, AXIS_Y);

   200

}

   201

   202

/**

   203

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

   204

 * @param t the tile to add the bridge to

   205

 * @param a the axis of the bridge to add

   206

 * @pre MayHaveBridgeAbove(t)

   207

 */

   208

static inline void SetBridgeMiddle(TileIndex t, Axis a)

   209

{

   210

	assert(MayHaveBridgeAbove(t));

   211

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

   212

}

   213

   214

   215

/**

   216

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

   217

 * @param t          the tile to make a bridge ramp

   218

 * @param o          the new owner of the bridge ramp

   219

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

   220

 * @param d          the direction this ramp must be facing

   221

 * @param tt         the transport type of the bridge

   222

 * @note this function should not be called directly.

   223

 */

   224

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

   225

{

   226

	SetTileType(t, MP_TUNNELBRIDGE);

   227

	SetTileOwner(t, o);

   228

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

   229

	_m[t].m4 = 0;

   230

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

   231

}

   232

   233

/**

   234

 * Make a bridge ramp for roads.

   235

 * @param t          the tile to make a bridge ramp

   236

 * @param o          the new owner of the bridge ramp

   237

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

   238

 * @param d          the direction this ramp must be facing

   239

 */

   240

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

   241

{

   242

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

   243

	_m[t].m3 = 0;

   244

}

   245

   246

/**

   247

 * Make a bridge ramp for rails.

   248

 * @param t          the tile to make a bridge ramp

   249

 * @param o          the new owner of the bridge ramp

   250

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

   251

 * @param d          the direction this ramp must be facing

   252

 * @param r          the rail type of the bridge

   253

 */

   254

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

   255

{

   256

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

   257

	_m[t].m3 = r;

   258

}

   259

   260

   261

#endif /* BRIDGE_MAP_H */