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 "../../tile_cmd.h"

    11

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

    12

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

    13

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

    14

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

    15

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

    16

#include "../../player_func.h"

    17

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

    18

#include "../../water_map.h"

    19

    20

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

    21

{

    22

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

    23

    24

	switch (::GetTileType(tile)) {

    25

		default: return false;

    26

		case MP_CLEAR: return true;

    27

		case MP_TREES: return true;

    28

		case MP_WATER: return IsCoast(tile);

    29

		case MP_ROAD:

    30

			/* Tram bits aren't considered buildable */

    31

			if (::GetRoadTypes(tile) != ROADTYPES_ROAD) return false;

    32

			/* Depots aren't considered buildable */

    33

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

    34

			if (CountBits(::GetRoadBits(tile, ROADTYPE_ROAD)) != 1) return false;

    35

			if (::IsRoadOwner(tile, ROADTYPE_ROAD, OWNER_TOWN)) return true;

    36

			if (::IsRoadOwner(tile, ROADTYPE_ROAD, _current_player)) return true;

    37

			return false;

    38

	}

    39

}

    40

    41

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

    42

{

    43

	uint tx, ty;

    44

    45

	tx = AIMap::GetTileX(tile);

    46

	ty = AIMap::GetTileY(tile);

    47

    48

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

    49

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

    50

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

    51

		}

    52

	}

    53

    54

	return true;

    55

}

    56

    57

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

    58

{

    59

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

    60

    61

	return ::IsTileType(tile, MP_WATER) && !::IsCoast(tile);

    62

}

    63

    64

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

    65

{

    66

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

    67

    68

	return ::IsTileType(tile, MP_WATER) && ::IsCoast(tile);

    69

}

    70

    71

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

    72

{

    73

	if (slope == SLOPE_INVALID) return false;

    74

    75

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

    76

}

    77

    78

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

    79

{

    80

	if (slope == SLOPE_INVALID) return false;

    81

    82

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

    83

}

    84

    85

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

    86

{

    87

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

    88

    89

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

    90

}

    91

    92

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

    93

{

    94

	if (slope == SLOPE_INVALID) return SLOPE_INVALID;

    95

	if (IsSteepSlope(slope)) return SLOPE_INVALID;

    96

	if (IsHalftileSlope(slope)) return SLOPE_INVALID;

    97

    98

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

    99

}

   100

   101

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

   102

{

   103

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

   104

   105

	return ::TileHeight(tile);

   106

}

   107

   108

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

   109

{

   110

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

   111

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

   112

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

   113

   114

	return AICompany::ResolveCompanyID((AICompany::CompanyID)(byte)::GetTileOwner(tile));

   115

}

   116

   117

/* static */ bool AITile::HasTransportType(TileIndex tile, TransportType transport_type)

   118

{

   119

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

   120

   121

	return GB(::GetTileTrackStatus(tile, (::TransportType)transport_type, UINT32_MAX), 0, 16) != 0;

   122

}

   123

   124

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

   125

{

   126

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

   127

   128

	AcceptedCargo accepts;

   129

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

   130

	return accepts[cargo_type];

   131

}

   132

   133

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

   134

{

   135

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

   136

   137

	AcceptedCargo produced;

   138

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

   139

	return produced[cargo_type];

   140

}

   141

   142

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

   143

{

   144

	return AIMap::DistanceManhattan(tile_from, tile_to);

   145

}

   146

   147

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

   148

{

   149

	return AIMap::DistanceSquare(tile_from, tile_to);

   150

}

   151

   152

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

   153

{

   154

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

   155

   156

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

   157

}

   158

   159

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

   160

{

   161

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

   162

   163

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

   164

}

   165

   166

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

   167

{

   168

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

   169

   170

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

   171

}

   172

   173

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

   174

{

   175

	return AITown::IsWithinTownInfluence(town_id, tile);

   176

}