1

/* $Id$ */

     2

     3

/** @file ai_tile.cpp handles the functions of the AITile class */

     4

     5

#include "ai_tile.hpp"

     6

#include "ai_map.hpp"

     7

#include "../../tile_map.h"

     8

#include "../../map_func.h"

     9

#include "../../variables.h"

    10

#include "../../station.h"

    11

#include "../../command_type.h"

    12

#include "../../settings_type.h"

    13

#include "../../road_map.h"

    14

    15

/* static */ bool AITile::IsBuildable(TileIndex tile)

    16

{

    17

	if (!::IsValidTile(tile)) return false;

    18

    19

	switch (::GetTileType(tile)) {

    20

		default: return true;

    21

		case MP_VOID:

    22

		case MP_HOUSE:

    23

		case MP_STATION:

    24

		case MP_INDUSTRY:

    25

		case MP_UNMOVABLE:

    26

		case MP_WATER: return false;

    27

    28

		case MP_ROAD:

    29

			/* Depots aren't considered buildable */

    30

			if (::GetRoadTileType(tile) == ROAD_TILE_DEPOT) return false;

    31

			return true;

    32

	}

    33

}

    34

    35

/* static */ bool AITile::IsBuildableRectangle(TileIndex tile, uint width, uint height)

    36

{

    37

	uint tx, ty;

    38

    39

	tx = AIMap::GetTileX(tile);

    40

	ty = AIMap::GetTileY(tile);

    41

    42

	for (uint x = tx; x < width + tx; x++) {

    43

		for (uint y = ty; y < height + ty; y++) {

    44

			if (!IsBuildable(AIMap::GetTileIndex(x, y))) return false;

    45

		}

    46

	}

    47

    48

	return true;

    49

}

    50

    51

/* static */ bool AITile::IsWater(TileIndex tile)

    52

{

    53

	if (!::IsValidTile(tile)) return false;

    54

    55

	return ::GetTileType(tile) == MP_WATER;

    56

}

    57

    58

/* static */ int32 AITile::GetSlope(TileIndex tile)

    59

{

    60

	if (!::IsValidTile(tile)) return false;

    61

    62

	return ::GetTileSlope(tile, NULL);

    63

}

    64

    65

/* static */ int32 AITile::GetHeight(TileIndex tile)

    66

{

    67

	if (!::IsValidTile(tile)) return false;

    68

    69

	return ::TileHeight(tile);

    70

}

    71

    72

/* static */ int32 AITile::GetCargoAcceptance(TileIndex tile, CargoID cargo_type, uint width, uint height, uint radius)

    73

{

    74

	if (!::IsValidTile(tile)) return false;

    75

    76

	AcceptedCargo accepts;

    77

	::GetAcceptanceAroundTiles(accepts, tile, width, height, _patches.modified_catchment ? radius : (uint)CA_UNMODIFIED);

    78

	return accepts[cargo_type];

    79

}

    80

    81

/* static */ int32 AITile::GetCargoProduction(TileIndex tile, CargoID cargo_type, uint width, uint height, uint radius)

    82

{

    83

	if (!::IsValidTile(tile)) return false;

    84

    85

	AcceptedCargo produced;

    86

	::GetProductionAroundTiles(produced, tile, width, height, _patches.modified_catchment ? radius : (uint)CA_UNMODIFIED);

    87

	return produced[cargo_type];

    88

}

    89

    90

/* static */ bool AITile::RaiseTile(TileIndex tile, int32 slope)

    91

{

    92

	if (!::IsValidTile(tile)) return false;

    93

    94

	return AIObject::DoCommand(tile, slope, 1, CMD_TERRAFORM_LAND);

    95

}

    96

    97

/* static */ bool AITile::LowerTile(TileIndex tile, int32 slope)

    98

{

    99

	if (!::IsValidTile(tile)) return false;

   100

   101

	return AIObject::DoCommand(tile, slope, 0, CMD_TERRAFORM_LAND);

   102

}

   103

   104

/* static */ int32 AITile::GetDistanceManhattanToTile(TileIndex tile_from, TileIndex tile_to)

   105

{

   106

	return AIMap::DistanceManhattan(tile_from, tile_to);

   107

}

   108

   109

/* static */ int32 AITile::GetDistanceSquareToTile(TileIndex tile_from, TileIndex tile_to)

   110

{

   111

	return AIMap::DistanceSquare(tile_from, tile_to);

   112

}