1

/* $Id$ */

     2

     3

/** @file tunnel_map.h */

     4

     5

#ifndef TUNNEL_MAP_H

     6

#define TUNNEL_MAP_H

     7

     8

#include "direction.h"

     9

#include "macros.h"

    10

#include "map.h"

    11

#include "rail.h"

    12

#include "road.h"

    13

    14

/**

    15

 * Is this a tunnel (entrance)?

    16

 * @param t the tile that might be a tunnel

    17

 * @pre IsTileType(t, MP_TUNNELBRIDGE)

    18

 * @return true if and only if this tile is a tunnel (entrance)

    19

 */

    20

static inline bool IsTunnel(TileIndex t)

    21

{

    22

	assert(IsTileType(t, MP_TUNNELBRIDGE));

    23

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

    24

}

    25

    26

    27

/**

    28

 * Is this a tunnel (entrance)?

    29

 * @param t the tile that might be a tunnel

    30

 * @return true if and only if this tile is a tunnel (entrance)

    31

 */

    32

static inline bool IsTunnelTile(TileIndex t)

    33

{

    34

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

    35

}

    36

    37

/**

    38

 * Gets the direction facing out of the tunnel

    39

 * @param t the tile to get the tunnel facing direction of

    40

 * @pre IsTunnelTile(t)

    41

 * @return the direction the tunnel is facing

    42

 */

    43

static inline DiagDirection GetTunnelDirection(TileIndex t)

    44

{

    45

	assert(IsTunnelTile(t));

    46

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

    47

}

    48

    49

/**

    50

 * Gets the transport type of the tunnel (road or rail)

    51

 * @param t the tunnel entrance tile to get the type of

    52

 * @pre IsTunnelTile(t)

    53

 * @return the transport type in the tunnel

    54

 */

    55

static inline TransportType GetTunnelTransportType(TileIndex t)

    56

{

    57

	assert(IsTunnelTile(t));

    58

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

    59

}

    60

    61

/**

    62

 * Is this tunnel entrance in a snowy or desert area?

    63

 * @param t the tunnel entrance tile

    64

 * @pre IsTunnelTile(t)

    65

 * @return true if and only if the tunnel entrance is in a snowy/desert area

    66

 */

    67

static inline bool HasTunnelSnowOrDesert(TileIndex t)

    68

{

    69

	assert(IsTunnelTile(t));

    70

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

    71

}

    72

    73

/**

    74

 * Places this tunnel entrance in a snowy or desert area,

    75

 * or takes it out of there.

    76

 * @param t the tunnel entrance tile

    77

 * @param snow_or_desert is the entrance in snow or desert (true), when

    78

 *                       not in snow and not in desert false

    79

 * @pre IsTunnelTile(t)

    80

 */

    81

static inline void SetTunnelSnowOrDesert(TileIndex t, bool snow_or_desert)

    82

{

    83

	assert(IsTunnelTile(t));

    84

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

    85

}

    86

    87

    88

TileIndex GetOtherTunnelEnd(TileIndex);

    89

bool IsTunnelInWay(TileIndex, uint z);

    90

    91

    92

/**

    93

 * Makes a road tunnel entrance

    94

 * @param t the entrance of the tunnel

    95

 * @param o the owner of the entrance

    96

 * @param d the direction facing out of the tunnel

    97

 * @param r the road type used in the tunnel

    98

 */

    99

static inline void MakeRoadTunnel(TileIndex t, Owner o, DiagDirection d, RoadTypes r)

   100

{

   101

	SetTileType(t, MP_TUNNELBRIDGE);

   102

	SetTileOwner(t, o);

   103

	_m[t].m2 = 0;

   104

	_m[t].m3 = r;

   105

	_m[t].m4 = 0;

   106

	_m[t].m5 = TRANSPORT_ROAD << 2 | d;

   107

}

   108

   109

/**

   110

 * Makes a rail tunnel entrance

   111

 * @param t the entrance of the tunnel

   112

 * @param o the owner of the entrance

   113

 * @param d the direction facing out of the tunnel

   114

 * @param r the rail type used in the tunnel

   115

 */

   116

static inline void MakeRailTunnel(TileIndex t, Owner o, DiagDirection d, RailType r)

   117

{

   118

	SetTileType(t, MP_TUNNELBRIDGE);

   119

	SetTileOwner(t, o);

   120

	_m[t].m2 = 0;

   121

	_m[t].m3 = r;

   122

	_m[t].m4 = 0;

   123

	_m[t].m5 = TRANSPORT_RAIL << 2 | d;

   124

}

   125

   126

#endif /* TUNNEL_MAP_H */