1

/* $Id$ */

     2

     3

/** @file ai_town.cpp Implementation of AITown. */

     4

     5

#include "ai_town.hpp"

     6

#include "ai_map.hpp"

     7

#include "ai_cargo.hpp"

     8

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

     9

#include "../../town.h"

    10

#include "../../strings_func.h"

    11

#include "../../core/alloc_func.hpp"

    12

#include "table/strings.h"

    13

    14

/* static */ TownID AITown::GetMaxTownID()

    15

{

    16

	return ::GetMaxTownIndex();

    17

}

    18

    19

/* static */ int32 AITown::GetTownCount()

    20

{

    21

	return ::GetNumTowns();

    22

}

    23

    24

/* static */ bool AITown::IsValidTown(TownID town_id)

    25

{

    26

	return ::IsValidTownID(town_id);

    27

}

    28

    29

/* static */ char *AITown::GetName(TownID town_id)

    30

{

    31

	if (!IsValidTown(town_id)) return NULL;

    32

	static const int len = 64;

    33

	char *town_name = MallocT<char>(len);

    34

    35

	::SetDParam(0, town_id);

    36

	::GetString(town_name, STR_TOWN, &town_name[len - 1]);

    37

    38

	return town_name;

    39

}

    40

    41

/* static */ int32 AITown::GetPopulation(TownID town_id)

    42

{

    43

	if (!IsValidTown(town_id)) return -1;

    44

	const Town *t = ::GetTown(town_id);

    45

	return t->population;

    46

}

    47

    48

/* static */ int32 AITown::GetHouseCount(TownID town_id)

    49

{

    50

	if (!IsValidTown(town_id)) return -1;

    51

	const Town *t = ::GetTown(town_id);

    52

	return t->num_houses;

    53

}

    54

    55

/* static */ TileIndex AITown::GetLocation(TownID town_id)

    56

{

    57

	if (!IsValidTown(town_id)) return INVALID_TILE;

    58

	const Town *t = ::GetTown(town_id);

    59

	return t->xy;

    60

}

    61

    62

/* static */ int32 AITown::GetLastMonthProduction(TownID town_id, CargoID cargo_id)

    63

{

    64

	if (!IsValidTown(town_id)) return -1;

    65

	if (!AICargo::IsValidCargo(cargo_id)) return -1;

    66

    67

	const Town *t = ::GetTown(town_id);

    68

    69

	switch(AICargo::GetTownEffect(cargo_id)) {

    70

		case AICargo::TE_PASSENGERS: return t->act_pass;

    71

		case AICargo::TE_MAIL:       return t->act_mail;

    72

		default: return -1;

    73

	}

    74

}

    75

    76

/* static */ int32 AITown::GetLastMonthTransported(TownID town_id, CargoID cargo_id)

    77

{

    78

	if (!IsValidTown(town_id)) return -1;

    79

	if (!AICargo::IsValidCargo(cargo_id)) return -1;

    80

    81

	const Town *t = ::GetTown(town_id);

    82

    83

	switch(AICargo::GetTownEffect(cargo_id)) {

    84

		case AICargo::TE_PASSENGERS: return t->pct_pass_transported;

    85

		case AICargo::TE_MAIL:       return t->pct_mail_transported;

    86

		default: return -1;

    87

	}

    88

}

    89

    90

/* static */ int32 AITown::GetMaxProduction(TownID town_id, CargoID cargo_id)

    91

{

    92

	if (!IsValidTown(town_id)) return -1;

    93

	if (!AICargo::IsValidCargo(cargo_id)) return -1;

    94

    95

	const Town *t = ::GetTown(town_id);

    96

    97

	switch(AICargo::GetTownEffect(cargo_id)) {

    98

		case AICargo::TE_PASSENGERS: return t->max_pass;

    99

		case AICargo::TE_MAIL:       return t->max_mail;

   100

		default: return -1;

   101

	}

   102

}

   103

   104

/* static */ int32 AITown::GetDistanceManhattanToTile(TownID town_id, TileIndex tile)

   105

{

   106

	return AIMap::DistanceManhattan(tile, GetLocation(town_id));

   107

}

   108

   109

/* static */ int32 AITown::GetDistanceSquareToTile(TownID town_id, TileIndex tile)

   110

{

   111

	return AIMap::DistanceSquare(tile, GetLocation(town_id));

   112

}

   113

   114

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

   115

{

   116

	const Town *t = ::GetTown(town_id);

   117

	return ((uint32)GetDistanceSquareToTile(town_id, tile) <= t->squared_town_zone_radius[0]);

   118

}