1

/* $Id$ */

     2

     3

/** @file ai_tile.hpp tile related functions */

     4

     5

#ifndef AI_TILE_HPP

     6

#define AI_TILE_HPP

     7

     8

#include "ai_abstractlist.hpp"

     9

    10

/**

    11

 * Class that handles all tile related functions.

    12

 */

    13

class AITile : public AIObject {

    14

public:

    15

	/**

    16

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

    17

	 *

    18

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

    19

	 * direction north, east, south and west. The top corner of a tile

    20

	 * is the north-part of the tile. The whole slope is encoded with

    21

	 * 5 bits, 4 bits for each corner and 1 bit for a steep-flag.

    22

	 */

    23

	enum Slope {

    24

		SLOPE_FLAT     = 0x00,                                  ///< a flat tile

    25

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

    26

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

    27

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

    28

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

    29

		SLOPE_STEEP    = 0x10,                                  ///< indicates the slope is steep

    30

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

    31

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

    32

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

    33

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

    34

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

    35

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

    36

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

    37

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

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

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

    45

	};

    46

    47

	/**

    48

	 * The name of the class, needed by several sub-processes.

    49

	 */

    50

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

    51

    52

	/**

    53

	 * Check if this tile is buildable (e.g.: no things on it that needs removing).

    54

	 * @note Road and rail are considered buildable.

    55

	 * @param tile the tile to check on.

    56

	 * @pre AIMap::IsValidTile(tile).

    57

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

    58

	 */

    59

	static bool IsBuildable(TileIndex tile);

    60

    61

	/**

    62

	 	 * Check if this tile is buildable in a rectangle around a tile, with the entry in the list as top-left.

    63

	 * @note Road and rail are considered buildable.

    64

	 * @param tile the tile to check on.

    65

	 * @param width the width of the rectangle.

    66

	 * @param height the height of the rectangle.

    67

	 * @pre AIMap::IsValidTile(tile).

    68

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

    69

	 */

    70

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

    71

    72

	/**

    73

	 * Check if a tile is water.

    74

	 * @param tile the tile to check on.

    75

	 * @pre AIMap::IsValidTile(tile).

    76

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

    77

	 */

    78

	static bool IsWater(TileIndex tile);

    79

    80

	/**

    81

	 * Get the slope of a tile.

    82

	 * @param tile the tile to check on.

    83

	 * @pre AIMap::IsValidTile(tile).

    84

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

    85

	 */

    86

	static int32 GetSlope(TileIndex tile);

    87

    88

	/**

    89

	 * Get the height of the tile.

    90

	 * @param tile the tile to check on.

    91

	 * @pre AIMap::IsValidTile(tile).

    92

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

    93

	 */

    94

	static int32 GetHeight(TileIndex tile);

    95

    96

	/**

    97

	 * Check how much cargo this tile accepts.

    98

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

    99

	 *   cargo.

   100

	 * @param tile the tile to check on.

   101

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

   102

	 * @param width the width of the station.

   103

	 * @param height the height of the station.

   104

	 * @param radius the radius of the station.

   105

	 * @pre AIMap::IsValidTile(tile).

   106

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

   107

	 */

   108

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

   109

   110

	/**

   111

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

   112

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

   113

	 *  this cargo.

   114

	 * @param tile the tile to check on.

   115

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

   116

	 * @param width the width of the station.

   117

	 * @param height the height of the station.

   118

	 * @param radius the radius of the station.

   119

	 * @pre AIMap::IsValidTile(tile).

   120

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

   121

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

   122

	 */

   123

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

   124

   125

	/**

   126

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

   127

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

   128

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

   129

	 * @return The distance between the two tiles.

   130

	 */

   131

	static int32 GetDistanceManhattanToTile(TileIndex tile_from, TileIndex tile_to);

   132

   133

	/**

   134

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

   135

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

   136

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

   137

	 * @return The distance between the two tiles.

   138

	 */

   139

	static int32 GetDistanceSquareToTile(TileIndex tile_from, TileIndex tile_to);

   140

   141

	/**

   142

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

   143

	 *  for example: SLOPE_N | SLOPE_W (= SLOPE_NW)

   144

	 * @param tile the tile to raise.

   145

	 * @param slope corners to raise (SLOPE_xxx).

   146

	 * @pre AIMap::IsValidTile(tile).

   147

	 * @return 0 means failed, 1 means success.

   148

	 */

   149

	static bool RaiseTile(TileIndex tile, int32 slope);

   150

   151

	/**

   152

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

   153

	 *  for example: SLOPE_N | SLOPE_W (= SLOPE_NW)

   154

	 * @param tile the tile to lower.

   155

	 * @param slope corners to lower (SLOPE_xxx).

   156

	 * @pre AIMap::IsValidTile(tile).

   157

	 * @return 0 means failed, 1 means success.

   158

	 */

   159

	static bool LowerTile(TileIndex tile, int32 slope);

   160

   161

};

   162

   163

#endif /* AI_TILE_HPP */