1

/* $Id$ */

     2

     3

/** @file ai_tile.cpp Implementation of AITile. */

     4

     5

#include "ai_tile.hpp"

     6

#include "ai_map.hpp"

     8

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

     9

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

    10

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

    11

#include "../../station_func.h"

    12

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

    13

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

    14

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

    15

    16

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

    17

{

    18

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

    19

    20

	switch (::GetTileType(tile)) {

    21

		default: return true;

    22

		case MP_VOID:

    23

		case MP_HOUSE:

    24

		case MP_STATION:

    25

		case MP_INDUSTRY:

    26

		case MP_UNMOVABLE:

    27

		case MP_WATER: return false;

    28

    29

		case MP_ROAD:

    30

			/* Depots aren't considered buildable */

    31

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

    32

			return true;

    33

	}

    34

}

    35

    36

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

    37

{

    38

	uint tx, ty;

    39

    40

	tx = AIMap::GetTileX(tile);

    41

	ty = AIMap::GetTileY(tile);

    42

    43

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

    44

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

    45

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

    46

		}

    47

	}

    48

    49

	return true;

    50

}

    51

    52

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

    53

{

    54

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

    55

    56

	return ::GetTileType(tile) == MP_WATER;

    57

}

    58

    59

/* static */ bool AITile::IsSteepSlope(Slope slope)

    60

{

    61

	if (slope == SLOPE_INVALID) return false;

    62

    63

	return ::IsSteepSlope((::Slope)slope);

    64

}

    65

    66

/* static */ bool AITile::IsHalftileSlope(Slope slope)

    67

{

    68

	if (slope == SLOPE_INVALID) return false;

    69

    70

	return ::IsHalftileSlope((::Slope)slope);

    71

}

    72

    73

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

    74

{

    75

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

    76

    77

	return (Slope)::GetTileSlope(tile, NULL);

    78

}

    79

    80

/* static */ AITile::Slope AITile::GetComplementSlope(Slope slope)

    81

{

    82

	if (slope == SLOPE_INVALID) return SLOPE_INVALID;

    83

	if (IsSteepSlope(slope)) return SLOPE_INVALID;

    84

	if (IsHalftileSlope(slope)) return SLOPE_INVALID;

    85

    86

	return (Slope)::ComplementSlope((::Slope)slope);

    87

}

    88

    89

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

    90

{

    91

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

    92

    93

	return ::TileHeight(tile);

    94

}

    95

    96

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

    97

{

    98

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

    99

   100

	AcceptedCargo accepts;

   101

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

   102

	return accepts[cargo_type];

   103

}

   104

   105

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

   106

{

   107

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

   108

   109

	AcceptedCargo produced;

   110

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

   111

	return produced[cargo_type];

   112

}

   113

   114

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

   115

{

   116

	return AIMap::DistanceManhattan(tile_from, tile_to);

   117

}

   118

   119

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

   120

{

   121

	return AIMap::DistanceSquare(tile_from, tile_to);

   122

}

   123

   124

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

   125

{

   126

	EnforcePrecondition(false, ::IsValidTile(tile));

   127

   128

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

   129

}

   130

   131

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

   132

{

   133

	EnforcePrecondition(false, ::IsValidTile(tile));

   134

   135

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

   136

}

   137

   138

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

   139

{

   140

	EnforcePrecondition(false, ::IsValidTile(tile));

   141

   142

	return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR);

   143

}