1

/* $Id$ */

     2

     3

#ifndef TILE_H

     4

#define TILE_H

     5

     6

#include "macros.h"

     7

#include "map.h"

     8

     9

typedef enum TileTypes {

    10

	MP_CLEAR,

    11

	MP_RAILWAY,

    12

	MP_STREET,

    13

	MP_HOUSE,

    14

	MP_TREES,

    15

	MP_STATION,

    16

	MP_WATER,

    17

	MP_VOID, // invisible tiles at the SW and SE border

    18

	MP_INDUSTRY,

    19

	MP_TUNNELBRIDGE,

    20

	MP_UNMOVABLE,

    21

} TileType;

    22

    23

/* Direction as commonly used in v->direction, 8 way. */

    24

typedef enum Directions {

    25

	DIR_N   = 0,

    26

	DIR_NE  = 1,      /* Northeast, upper right on your monitor */

    27

	DIR_E   = 2,

    28

	DIR_SE  = 3,

    29

	DIR_S   = 4,

    30

	DIR_SW  = 5,

    31

	DIR_W   = 6,

    32

	DIR_NW  = 7,

    33

	DIR_END,

    34

	INVALID_DIR = 0xFF,

    35

} Direction;

    36

    37

/* Direction commonly used as the direction of entering and leaving tiles, 4-way */

    38

typedef enum DiagonalDirections {

    39

	DIAGDIR_NE  = 0,      /* Northeast, upper right on your monitor */

    40

	DIAGDIR_SE  = 1,

    41

	DIAGDIR_SW  = 2,

    42

	DIAGDIR_NW  = 3,

    43

	DIAGDIR_END,

    44

	INVALID_DIAGDIR = 0xFF,

    45

} DiagDirection;

    46

    47

void SetMapExtraBits(TileIndex tile, byte flags);

    48

uint GetMapExtraBits(TileIndex tile);

    49

    50

uint GetTileh(uint n, uint w, uint e, uint s, uint *h);

    51

uint GetTileSlope(TileIndex tile, uint *h);

    52

uint GetTileZ(TileIndex tile);

    53

    54

static inline bool CorrectZ(uint tileh)

    55

{

    56

	/* tile height must be corrected if the north corner is not raised, but

    57

	 * any other corner is. These are the cases 1 till 7 */

    58

	return IS_INT_INSIDE(tileh, 1, 8);

    59

}

    60

    61

static inline uint TileHeight(TileIndex tile)

    62

{

    63

	assert(tile < MapSize());

    64

	return GB(_m[tile].type_height, 0, 4);

    65

}

    66

    67

static inline bool IsSteepTileh(uint tileh)

    68

{

    69

	return (tileh & 0x10);

    70

}

    71

    72

static inline void SetTileHeight(TileIndex tile, uint height)

    73

{

    74

	assert(tile < MapSize());

    75

	assert(height < 16);

    76

	SB(_m[tile].type_height, 0, 4, height);

    77

}

    78

    79

static inline uint TilePixelHeight(TileIndex tile)

    80

{

    81

	return TileHeight(tile) * 8;

    82

}

    83

    84

static inline TileType GetTileType(TileIndex tile)

    85

{

    86

	assert(tile < MapSize());

    87

	return GB(_m[tile].type_height, 4, 4);

    88

}

    89

    90

static inline void SetTileType(TileIndex tile, TileType type)

    91

{

    92

	assert(tile < MapSize());

    93

	/* Allow only MP_VOID to be set to border tiles. This code is put here since

    94

	 * it seems there is a bug that violates this somewhere. (Formely know as

    95

	 * the "old ship pf" bug, which presented a case in which this broke). It

    96

	 * can be removed as soon as  the bug is squashed. */

    97

	assert((TileX(tile) < MapMaxX() && TileY(tile) < MapMaxY()) || type == MP_VOID);

    98

	SB(_m[tile].type_height, 4, 4, type);

    99

}

   100

   101

static inline bool IsTileType(TileIndex tile, TileType type)

   102

{

   103

	return GetTileType(tile) == type;

   104

}

   105

   106

static inline bool IsTunnelTile(TileIndex tile)

   107

{

   108

	return IsTileType(tile, MP_TUNNELBRIDGE) && GB(_m[tile].m5, 4, 4) == 0;

   109

}

   110

   111

static inline Owner GetTileOwner(TileIndex tile)

   112

{

   113

	assert(tile < MapSize());

   114

	assert(!IsTileType(tile, MP_HOUSE));

   115

	assert(!IsTileType(tile, MP_VOID));

   116

	assert(!IsTileType(tile, MP_INDUSTRY));

   117

   118

	return _m[tile].m1;

   119

}

   120

   121

static inline void SetTileOwner(TileIndex tile, Owner owner)

   122

{

   123

	assert(tile < MapSize());

   124

	assert(!IsTileType(tile, MP_HOUSE));

   125

	assert(!IsTileType(tile, MP_VOID));

   126

	assert(!IsTileType(tile, MP_INDUSTRY));

   127

   128

	_m[tile].m1 = owner;

   129

}

   130

   131

static inline bool IsTileOwner(TileIndex tile, Owner owner)

   132

{

   133

	return GetTileOwner(tile) == owner;

   134

}

   135

   136

#endif /* TILE_H */