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(_map_type_and_height[tile], 0, 4);

    62

}

    63

    64

static inline void SetTileHeight(TileIndex tile, uint height)

    65

{

    66

	assert(tile < MapSize());

    67

	assert(height < 16);

    68

	SB(_map_type_and_height[tile], 0, 4, height);

    69

}

    70

    71

static inline uint TilePixelHeight(TileIndex tile)

    72

{

    73

	return TileHeight(tile) * 8;

    74

}

    75

    76

static inline TileType GetTileType(TileIndex tile)

    77

{

    78

	assert(tile < MapSize());

    79

	return GB(_map_type_and_height[tile], 4, 4);

    80

}

    81

    82

static inline void SetTileType(TileIndex tile, TileType type)

    83

{

    84

	assert(tile < MapSize());

    85

	SB(_map_type_and_height[tile], 4, 4, type);

    86

}

    87

    88

static inline bool IsTileType(TileIndex tile, TileType type)

    89

{

    90

	return GetTileType(tile) == type;

    91

}

    92

    93

static inline Owner GetTileOwner(TileIndex tile)

    94

{

    95

	assert(tile < MapSize());

    96

	assert(!IsTileType(tile, MP_HOUSE));

    97

	assert(!IsTileType(tile, MP_VOID));

    98

	assert(!IsTileType(tile, MP_INDUSTRY));

    99

   100

	return _map_owner[tile];

   101

}

   102

   103

static inline void SetTileOwner(TileIndex tile, Owner owner)

   104

{

   105

	assert(tile < MapSize());

   106

	assert(!IsTileType(tile, MP_HOUSE));

   107

	assert(!IsTileType(tile, MP_VOID));

   108

	assert(!IsTileType(tile, MP_INDUSTRY));

   109

   110

	_map_owner[tile] = owner;

   111

}

   112

   113

static inline bool IsTileOwner(TileIndex tile, Owner owner)

   114

{

   115

	return GetTileOwner(tile) == owner;

   116

}

   117

   118

#endif