1

/* $Id$ */

     2

     3

/** @file ai_tile.hpp Everything to query and manipulate tiles. */

     4

     5

#ifndef AI_TILE_HPP

     6

#define AI_TILE_HPP

     7

     8

#include "ai_abstractlist.hpp"

     9

#include "ai_error.hpp"

    11

    12

/**

    13

 * Class that handles all tile related functions.

    14

 */

    15

class AITile : public AIObject {

    16

public:

    17

	static const char *GetClassName() { return "AITile"; }

    18

    19

	/**

    20

	 * Error messages related to modifying tiles.

    21

	 */

    22

	enum ErrorMessages {

    23

    24

		/** Base for tile related errors */

    25

		ERR_TILE_BASE = AIError::ERR_CAT_TILE << AIError::ERR_CAT_BIT_SIZE,

    26

    27

		/** Tile can't be raised any higher */

    28

		ERR_TILE_TOO_HIGH,                     // [STR_1003_ALREADY_AT_SEA_LEVEL]

    29

    30

		/** Tile can't be lowered any lower */

    31

		ERR_TILE_TOO_LOW,                      // [STR_1003_ALREADY_AT_SEA_LEVEL]

    32

	};

    33

    34

	/**

    35

	 * Enumeration for the slope-type (from slopes.h).

    36

	 *

    37

	 * This enumeration use the chars N, E, S, W corresponding the

    38

	 *  direction North, East, South and West. The top corner of a tile

    39

	 *  is the north-part of the tile.

    40

	 */

    41

	enum Slope {

    42

		SLOPE_FLAT     = 0x00,                                  //!< A flat tile

    43

		SLOPE_W        = 0x01,                                  //!< The west corner of the tile is raised

    44

		SLOPE_S        = 0x02,                                  //!< The south corner of the tile is raised

    45

		SLOPE_E        = 0x04,                                  //!< The east corner of the tile is raised

    46

		SLOPE_N        = 0x08,                                  //!< The north corner of the tile is raised

    47

		SLOPE_STEEP    = 0x10,                                  //!< Indicates the slope is steep

    48

		SLOPE_NW       = SLOPE_N | SLOPE_W,                     //!< North and west corner are raised

    49

		SLOPE_SW       = SLOPE_S | SLOPE_W,                     //!< South and west corner are raised

    50

		SLOPE_SE       = SLOPE_S | SLOPE_E,                     //!< South and east corner are raised

    51

		SLOPE_NE       = SLOPE_N | SLOPE_E,                     //!< North and east corner are raised

    52

		SLOPE_EW       = SLOPE_E | SLOPE_W,                     //!< East and west corner are raised

    53

		SLOPE_NS       = SLOPE_N | SLOPE_S,                     //!< North and south corner are raised

    54

		SLOPE_ELEVATED = SLOPE_N | SLOPE_E | SLOPE_S | SLOPE_W, //!< All corner are raised, similar to SLOPE_FLAT

    55

		SLOPE_NWS      = SLOPE_N | SLOPE_W | SLOPE_S,           //!< North, west and south corner are raised

    56

		SLOPE_WSE      = SLOPE_W | SLOPE_S | SLOPE_E,           //!< West, south and east corner are raised

    57

		SLOPE_SEN      = SLOPE_S | SLOPE_E | SLOPE_N,           //!< South, east and north corner are raised

    58

		SLOPE_ENW      = SLOPE_E | SLOPE_N | SLOPE_W,           //!< East, north and west corner are raised

    59

		SLOPE_STEEP_W  = SLOPE_STEEP | SLOPE_NWS,               //!< A steep slope falling to east (from west)

    60

		SLOPE_STEEP_S  = SLOPE_STEEP | SLOPE_WSE,               //!< A steep slope falling to north (from south)

    61

		SLOPE_STEEP_E  = SLOPE_STEEP | SLOPE_SEN,               //!< A steep slope falling to west (from east)

    62

		SLOPE_STEEP_N  = SLOPE_STEEP | SLOPE_ENW,               //!< A steep slope falling to south (from north)

    63

    64

		SLOPE_INVALID  = 0xFF,                                  //!< An invalid slope

    65

	};

    66

    67

	/**

    68

	 * Check if this tile is buildable, i.e. no things on it that needs

    69

	 *  demolishing.

    70

	 * @param tile The tile to check on.

    71

	 * @pre AIMap::IsValidTile(tile).

    72

	 * @return True if it is buildable, false if not.

    73

	 * @note Road and rail are considered buildable.

    74

	 */

    75

	static bool IsBuildable(TileIndex tile);

    76

    77

	/**

    78

	 * Check if this tile is buildable in a rectangle around a tile, with the

    79

	 *  entry in the list as top-left.

    80

	 * @param tile The tile to check on.

    81

	 * @param width The width of the rectangle.

    82

	 * @param height The height of the rectangle.

    83

	 * @pre AIMap::IsValidTile(tile).

    84

	 * @return True if it is buildable, false if not.

    85

	 * @note Road and rail are considered buildable.

    86

	 */

    87

	static bool IsBuildableRectangle(TileIndex tile, uint width, uint height);

    88

    89

	/**

    90

	 * Check if a tile is water.

    91

	 * @param tile The tile to check on.

    92

	 * @pre AIMap::IsValidTile(tile).

    93

	 * @return True if it is water, false if not.

    94

	 */

    95

	static bool IsWater(TileIndex tile);

    96

    97

	/**

    98

	 * Check if a tile has a steep slope.

    99

	 * @param slope The slope to check on.

   100

	 * @pre slope != SLOPE_INVALID.

   101

	 * @return True if the slope is a steep slope.

   102

	 */

   103

	static bool IsSteepSlope(Slope slope);

   104

   105

	/**

   106

	 * Check if a tile has a halftile slope.

   107

	 * @param slope The slope to check on.

   108

	 * @pre slope != SLOPE_INVALID.

   109

	 * @return True if the slope is a halftile slope.

   110

	 */

   111

	static bool IsHalftileSlope(Slope slope);

   112

   113

	/**

   114

	 * Get the slope of a tile.

   115

	 * @param tile The tile to check on.

   116

	 * @pre AIMap::IsValidTile(tile).

   117

	 * @return 0 means flat, others indicate internal state of slope.

   118

	 */

   119

	static Slope GetSlope(TileIndex tile);

   120

   121

	/**

   122

	 * Get the complement of the slope.

   123

	 * @param slope The slope to get the complement of.

   124

	 * @pre slope != SLOPE_INVALID.

   125

	 * @pre !IsSteepSlope(slope).

   126

	 * @pre !IsHalftileSlope(slope).

   127

	 * @return The complement of a slope. This means that all corners that

   128

	 *  weren't raised, are raised, and visa versa.

   129

	 */

   130

	static Slope GetComplementSlope(Slope slope);

   131

   132

	/**

   133

	 * Get the height of the tile.

   134

	 * @param tile The tile to check on.

   135

	 * @pre AIMap::IsValidTile(tile).

   136

	 * @return The height of the tile, ranging from 0 to 15.

   137

	 */

   138

	static int32 GetHeight(TileIndex tile);

   139

   140

	/**

   150

	 * Check how much cargo this tile accepts.

   151

	 *  It creates a radius around the tile, and adds up all acceptance of this

   152

	 *   cargo.

   153

	 * @param tile The tile to check on.

   154

	 * @param cargo_type The cargo to check the acceptance of.

   155

	 * @param width The width of the station.

   156

	 * @param height The height of the station.

   157

	 * @param radius The radius of the station.

   158

	 * @pre AIMap::IsValidTile(tile).

   159

	 * @return Value below 8 means no acceptance; the more the better.

   160

	 */

   161

	static int32 GetCargoAcceptance(TileIndex tile, CargoID cargo_type, uint width, uint height, uint radius);

   162

   163

	/**

   164

	 * Checks how many tiles in the radius produces this cargo.

   165

	 *  It creates a radius around the tile, and adds up all tiles that produce

   166

	 *  this cargo.

   167

	 * @param tile The tile to check on.

   168

	 * @param cargo_type The cargo to check the production of.

   169

	 * @param width The width of the station.

   170

	 * @param height The height of the station.

   171

	 * @param radius The radius of the station.

   172

	 * @pre AIMap::IsValidTile(tile).

   173

	 * @return The tiles that produce this cargo within radius of the tile.

   174

	 * @note Town(houses) are not included in the value.

   175

	 */

   176

	static int32 GetCargoProduction(TileIndex tile, CargoID cargo_type, uint width, uint height, uint radius);

   177

   178

	/**

   179

	 * Get the manhattan distance from the tile to the tile.

   180

	 * @param tile_from The tile to get the distance to.

   181

	 * @param tile_to The tile to get the distance to.

   182

	 * @return The distance between the two tiles.

   183

	 */

   184

	static int32 GetDistanceManhattanToTile(TileIndex tile_from, TileIndex tile_to);

   185

   186

	/**

   187

	 * Get the square distance from the tile to the tile.

   188

	 * @param tile_from The tile to get the distance to.

   189

	 * @param tile_to The tile to get the distance to.

   190

	 * @return The distance between the two tiles.

   191

	 */

   192

	static int32 GetDistanceSquareToTile(TileIndex tile_from, TileIndex tile_to);

   193

   194

	/**

   195

	 * Raise the given corners of the tile. The corners can be combined,

   196

	 *  for example: SLOPE_N | SLOPE_W (= SLOPE_NW)

   197

	 * @param tile The tile to raise.

   198

	 * @param slope Corners to raise (SLOPE_xxx).

   199

	 * @pre AIMap::IsValidTile(tile).

   200

	 * @exception AIError::ERR_AREA_NOT_CLEAR

   201

	 * @exception AIError::ERR_TOO_CLOSE_TO_EDGE

   202

	 * @exception AITile::ERR_TILE_TOO_HIGH

   203

	 * @return 0 means failed, 1 means success.

   204

	 */

   205

	static bool RaiseTile(TileIndex tile, int32 slope);

   206

   207

	/**

   208

	 * Lower the given corners of the tile. The corners can be combined,

   209

	 *  for example: SLOPE_N | SLOPE_W (= SLOPE_NW)

   210

	 * @param tile The tile to lower.

   211

	 * @param slope Corners to lower (SLOPE_xxx).

   212

	 * @pre AIMap::IsValidTile(tile).

   213

	 * @exception AIError::ERR_AREA_NOT_CLEAR

   214

	 * @exception AIError::ERR_TOO_CLOSE_TO_EDGE

   215

	 * @exception AITile::ERR_TILE_TOO_LOW

   216

	 * @return 0 means failed, 1 means success.

   217

	 */

   218

	static bool LowerTile(TileIndex tile, int32 slope);

   219

   220

	/**

   221

	 * Destroy everything on the given tile.

   222

	 * @param tile The tile to demolish.

   223

	 * @pre AIMap::IsValidTile(tile).

   224

	 * @exception AIError::ERR_AREA_NOT_CLEAR

   225

	 * @return True if and only if the tile was demolished.

   226

	 */

   227

	static bool DemolishTile(TileIndex tile);

   228

};

   229

   230

#endif /* AI_TILE_HPP */