1

/* $Id$ */

     2

     3

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

     4

     5

#include "ai_tile.hpp"

     6

#include "ai_map.hpp"

     7

#include "ai_town.hpp"

     8

#include "../../openttd.h"

     9

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

    10

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

    11

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

    12

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

    13

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

    14

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

    16

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

    17

    18

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

    19

{

    20

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

    21

    22

	switch (::GetTileType(tile)) {

    25

		case MP_ROAD:

    26

			/* Depots aren't considered buildable */

    27

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

    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 */ bool AITile::IsSteepSlope(Slope slope)

    59

{

    60

	if (slope == SLOPE_INVALID) return false;

    61

    62

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

    63

}

    64

    65

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

    66

{

    67

	if (slope == SLOPE_INVALID) return false;

    68

    69

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

    70

}

    71

    72

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

    73

{

    74

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

    75

    76

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

    77

}

    78

    79

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

    80

{

    81

	if (slope == SLOPE_INVALID) return SLOPE_INVALID;

    82

	if (IsSteepSlope(slope)) return SLOPE_INVALID;

    83

	if (IsHalftileSlope(slope)) return SLOPE_INVALID;

    84

    85

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

    86

}

    87

    88

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

    89

{

    90

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

    91

    92

	return ::TileHeight(tile);

    93

}

    94

    95

/* static */ AICompany::CompanyIndex AITile::GetOwner(TileIndex tile)

    96

{

    97

	if (!::IsValidTile(tile)) return AICompany::INVALID_COMPANY;

    98

	if (::IsTileType(tile, MP_HOUSE)) return AICompany::INVALID_COMPANY;

    99

	if (::IsTileType(tile, MP_INDUSTRY)) return AICompany::INVALID_COMPANY;

   100

   101

	return AICompany::ResolveCompanyIndex((AICompany::CompanyIndex)(byte)::GetTileOwner(tile));

   102

}

   103

   104

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

   105

{

   106

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

   107

   108

	AcceptedCargo accepts;

   109

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

   110

	return accepts[cargo_type];

   111

}

   112

   113

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

   114

{

   115

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

   116

   117

	AcceptedCargo produced;

   118

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

   119

	return produced[cargo_type];

   120

}

   121

   122

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

   123

{

   124

	return AIMap::DistanceManhattan(tile_from, tile_to);

   125

}

   126

   127

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

   128

{

   129

	return AIMap::DistanceSquare(tile_from, tile_to);

   130

}

   131

   132

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

   133

{

   134

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

   135

   136

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

   137

}

   138

   139

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

   140

{

   141

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

   142

   143

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

   144

}

   145

   146

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

   147

{

   148

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

   149

   150

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

   151

}

   152

   153

/* static */ bool AITile::IsWithinTownInfluence(TileIndex tile, TownID town_id)

   154

{

   155

	return AITown::IsWithinTownInfluence(town_id, tile);

   156

}