1

#ifndef TILE_H

     2

#define TILE_H

     3

     4

#include "macros.h"

     5

#include "map.h"

     6

     7

typedef enum TileTypes {

     8

	MP_CLEAR,

     9

	MP_RAILWAY,

    10

	MP_STREET,

    11

	MP_HOUSE,

    12

	MP_TREES,

    13

	MP_STATION,

    14

	MP_WATER,

    15

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

    16

	MP_INDUSTRY,

    17

	MP_TUNNELBRIDGE,

    18

	MP_UNMOVABLE

    19

} TileType;

    20

    21

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

    22

typedef enum Directions {

    23

	DIR_N   = 0,

    24

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

    25

	DIR_E   = 2,

    26

	DIR_SE  = 3,

    27

	DIR_S   = 4,

    28

	DIR_SW  = 5,

    29

	DIR_W   = 6,

    30

	DIR_NW  = 7,

    31

	DIR_END,

    32

	INVALID_DIR = 0xFF,

    33

} Direction;

    34

    35

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

    36

typedef enum DiagonalDirections {

    37

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

    38

	DIAGDIR_SE  = 1,

    39

	DIAGDIR_SW  = 2,

    40

	DIAGDIR_NW  = 3,

    41

	DIAGDIR_END,

    42

	INVALID_DIAGDIR = 0xFF,

    43

} DiagDirection;

    44

    45

void SetMapExtraBits(TileIndex tile, byte flags);

    46

uint GetMapExtraBits(TileIndex tile);

    47

    48

uint GetTileSlope(TileIndex tile, uint *h);

    49

uint GetTileZ(TileIndex tile);

    50

    51

static inline bool CorrectZ(uint tileh)

    52

{

    53

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

    54

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

    55

	return IS_INT_INSIDE(tileh, 1, 8);

    56

}

    57

    58

static inline uint TileHeight(TileIndex tile)

    59

{

    60

	assert(tile < MapSize());

    61

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

    62

}

    63

    64

static inline bool IsSteepTileh(uint tileh)

    65

{

    66

	return (tileh & 0x10);

    67

}

    68

    69

static inline void SetTileHeight(TileIndex tile, uint height)

    70

{

    71

	assert(tile < MapSize());

    72

	assert(height < 16);

    73

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

    74

}

    75

    76

static inline uint TilePixelHeight(TileIndex tile)

    77

{

    78

	return TileHeight(tile) * 8;

    79

}

    80

    81

static inline TileType GetTileType(TileIndex tile)

    82

{

    83

	assert(tile < MapSize());

    84

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

    85

}

    86

    87

static inline void SetTileType(TileIndex tile, TileType type)

    88

{

    89

	assert(tile < MapSize());

    90

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

    91

}

    92

    93

static inline bool IsTileType(TileIndex tile, TileType type)

    94

{

    95

	return GetTileType(tile) == type;

    96

}

    97

    98

static inline Owner GetTileOwner(TileIndex tile)

    99

{

   100

	assert(tile < MapSize());

   101

	assert(!IsTileType(tile, MP_HOUSE));

   102

	assert(!IsTileType(tile, MP_VOID));

   103

	assert(!IsTileType(tile, MP_INDUSTRY));

   104

   105

	return _m[tile].owner;

   106

}

   107

   108

static inline void SetTileOwner(TileIndex tile, Owner owner)

   109

{

   110

	assert(tile < MapSize());

   111

	assert(!IsTileType(tile, MP_HOUSE));

   112

	assert(!IsTileType(tile, MP_VOID));

   113

	assert(!IsTileType(tile, MP_INDUSTRY));

   114

   115

	_m[tile].owner = owner;

   116

}

   117

   118

static inline bool IsTileOwner(TileIndex tile, Owner owner)

   119

{

   120

	return GetTileOwner(tile) == owner;

   121

}

   122

   123

#endif