1

/* $Id$ */

     2

     3

/** @file tile.h */

     4

     5

#ifndef TILE_H

     6

#define TILE_H

     7

     8

#include "macros.h"

     9

#include "openttd.h"

    10

#include "map.h"

    11

#include "slope.h"

    12

    13

/** Maximum allowed tile height */

    14

#define MAX_TILE_HEIGHT 15

    15

    16

/** Maximum allowed snowline height */

    17

#define MAX_SNOWLINE_HEIGHT (MAX_TILE_HEIGHT - 2)

    18

    19

/**

    20

 * The different type of a tile.

    21

 *

    22

 * Each tile belongs to one type, according whatever is build on it.

    23

 *

    24

 * @note A railway with a crossing street is marked as MP_ROAD.

    25

 */

    26

enum TileType {

    27

	MP_CLEAR,               ///< A tile without any structures, i.e. grass, rocks, farm fields etc.

    28

	MP_RAILWAY,             ///< A railway

    29

	MP_ROAD,                ///< A tile with road (or tram tracks)

    30

	MP_HOUSE,               ///< A house by a town

    31

	MP_TREES,               ///< Tile got trees

    32

	MP_STATION,             ///< A tile of a station

    33

	MP_WATER,               ///< Water tile

    34

	MP_VOID,                ///< Invisible tiles at the SW and SE border

    35

	MP_INDUSTRY,            ///< Part of an industry

    36

	MP_TUNNELBRIDGE,        ///< Tunnel entry/exit and bridge heads

    37

	MP_UNMOVABLE,           ///< Contains an object with cannot be removed like transmitters

    38

};

    39

    40

/**

    41

 * Additional infos of a tile on a tropic game.

    42

 *

    43

 * Each non-water tile in a tropic game is either a rainforest tile or a

    44

 * desert one.

    45

 */

    46

enum TropicZone {

    47

	TROPICZONE_INVALID    = 0,      ///< Invalid tropiczone-type

    48

	TROPICZONE_DESERT     = 1,      ///< Tile is desert

    49

	TROPICZONE_RAINFOREST = 2,      ///< Rainforest tile

    50

};

    51

    52

Slope GetTileSlope(TileIndex tile, uint *h);

    53

uint GetTileZ(TileIndex tile);

    54

uint GetTileMaxZ(TileIndex tile);

    55

    56

/**

    57

 * Returns the height of a tile

    58

 *

    59

 * This function returns the height of the northern corner of a tile.

    60

 * This is saved in the global map-array. It does not take affect by

    61

 * any slope-data of the tile.

    62

 *

    63

 * @param tile The tile to get the height from

    64

 * @return the height of the tile

    65

 * @pre tile < MapSize()

    66

 */

    67

static inline uint TileHeight(TileIndex tile)

    68

{

    69

	assert(tile < MapSize());

    70

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

    71

}

    72

    73

/**

    74

 * Sets the height of a tile.

    75

 *

    76

 * This function sets the height of the northern corner of a tile.

    77

 *

    78

 * @param tile The tile to change the height

    79

 * @param height The new height value of the tile

    80

 * @pre tile < MapSize()

    81

 * @pre heigth <= MAX_TILE_HEIGHT

    82

 */

    83

static inline void SetTileHeight(TileIndex tile, uint height)

    84

{

    85

	assert(tile < MapSize());

    86

	assert(height <= MAX_TILE_HEIGHT);

    87

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

    88

}

    89

    90

/**

    91

 * Returns the height of a tile in pixels.

    92

 *

    93

 * This function returns the height of the northern corner of a tile in pixels.

    94

 *

    95

 * @param tile The tile to get the height

    96

 * @return The height of the tile in pixel

    97

 */

    98

static inline uint TilePixelHeight(TileIndex tile)

    99

{

   100

	return TileHeight(tile) * TILE_HEIGHT;

   101

}

   102

   103

/**

   104

 * Get the tiletype of a given tile.

   105

 *

   106

 * @param tile The tile to get the TileType

   107

 * @return The tiletype of the tile

   108

 * @pre tile < MapSize()

   109

 */

   110

static inline TileType GetTileType(TileIndex tile)

   111

{

   112

	assert(tile < MapSize());

   113

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

   114

}

   115

   116

/**

   117

 * Set the type of a tile

   118

 *

   119

 * This functions sets the type of a tile. If the type

   120

 * MP_VOID is selected the tile must be at the south-west or

   121

 * south-east edges of the map and vice versa.

   122

 *

   123

 * @param tile The tile to save the new type

   124

 * @param type The type to save

   125

 * @pre tile < MapSize()

   126

 * @pre type MP_VOID <=> tile is on the south-east or south-west edge.

   127

 */

   128

static inline void SetTileType(TileIndex tile, TileType type)

   129

{

   130

	assert(tile < MapSize());

   131

	/* VOID tiles (and no others) are exactly allowed at the lower left and right

   132

	 * edges of the map */

   133

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

   134

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

   135

}

   136

   137

/**

   138

 * Checks if a tile is a give tiletype.

   139

 *

   140

 * This function checks if a tile got the given tiletype.

   141

 *

   142

 * @param tile The tile to check

   143

 * @param type The type to check agains

   144

 * @return true If the type matches agains the type of the tile

   145

 */

   146

static inline bool IsTileType(TileIndex tile, TileType type)

   147

{

   148

	return GetTileType(tile) == type;

   149

}

   150

   151

/**

   152

 * Returns the owner of a tile

   153

 *

   154

 * This function returns the owner of a tile. This cannot used

   155

 * for tiles which type is one of MP_HOUSE, MP_VOID and MP_INDUSTRY

   156

 * as no player owned any of these buildings.

   157

 *

   158

 * @param tile The tile to check

   159

 * @return The owner of the tile

   160

 * @pre tile < MapSize()

   161

 * @pre The type of the tile must not be MP_HOUSE, MP_VOID and MP_INDUSTRY

   162

 */

   163

static inline Owner GetTileOwner(TileIndex tile)

   164

{

   165

	assert(tile < MapSize());

   166

	assert(!IsTileType(tile, MP_HOUSE));

   167

	assert(!IsTileType(tile, MP_VOID));

   168

	assert(!IsTileType(tile, MP_INDUSTRY));

   169

   170

	return (Owner)_m[tile].m1;

   171

}

   172

   173

/**

   174

 * Sets the owner of a tile

   175

 *

   176

 * This function sets the owner status of a tile. Note that you cannot

   177

 * set a owner for tiles of type MP_HOUSE, MP_VOID and MP_INDUSTRY.

   178

 *

   179

 * @param tile The tile to change the owner status.

   180

 * @param owner The new owner.

   181

 * @pre tile < MapSize()

   182

 * @pre The type of the tile must not be MP_HOUSE, MP_VOID and MP_INDUSTRY

   183

 */

   184

static inline void SetTileOwner(TileIndex tile, Owner owner)

   185

{

   186

	assert(tile < MapSize());

   187

	assert(!IsTileType(tile, MP_HOUSE));

   188

	assert(!IsTileType(tile, MP_VOID));

   189

	assert(!IsTileType(tile, MP_INDUSTRY));

   190

   191

	_m[tile].m1 = owner;

   192

}

   193

   194

/**

   195

 * Checks if a tile belongs to the given owner

   196

 *

   197

 * @param tile The tile to check

   198

 * @param owner The owner to check agains

   199

 * @return True if a tile belongs the the given owner

   200

 */

   201

static inline bool IsTileOwner(TileIndex tile, Owner owner)

   202

{

   203

	return GetTileOwner(tile) == owner;

   204

}

   205

   206

/**

   207

 * Set the tropic zone

   208

 * @param tile the tile to set the zone of

   209

 * @param type the new type

   210

 * @pre assert(tile < MapSize());

   211

 */

   212

static inline void SetTropicZone(TileIndex tile, TropicZone type)

   213

{

   214

	assert(tile < MapSize());

   215

	SB(_m[tile].m6, 0, 2, type);

   216

}

   217

   218

/**

   219

 * Get the tropic zone

   220

 * @param tile the tile to get the zone of

   221

 * @pre assert(tile < MapSize());

   222

 * @return the zone type

   223

 */

   224

static inline TropicZone GetTropicZone(TileIndex tile)

   225

{

   226

	assert(tile < MapSize());

   227

	return (TropicZone)GB(_m[tile].m6, 0, 2);

   228

}

   229

#endif /* TILE_H */