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 "ai_error.hpp"

     9

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

    10

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

    11

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

    12

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

    13

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

    14

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

    15

#include "table/strings.h"

    16

    17

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

    18

{

    19

	return ::GetMaxTownIndex();

    20

}

    21

    22

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

    23

{

    24

	return ::GetNumTowns();

    25

}

    26

    27

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

    28

{

    29

	return ::IsValidTownID(town_id);

    30

}

    31

    32

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

    33

{

    34

	if (!IsValidTown(town_id)) return NULL;

    35

	static const int len = 64;

    36

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

    37

    38

	::SetDParam(0, town_id);

    39

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

    40

    41

	return town_name;

    42

}

    43

    44

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

    45

{

    46

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

    47

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

    48

	return t->population;

    49

}

    50

    51

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

    52

{

    53

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

    54

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

    55

	return t->num_houses;

    56

}

    57

    58

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

    59

{

    60

	if (!IsValidTown(town_id)) return INVALID_TILE;

    61

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

    62

	return t->xy;

    63

}

    64

    65

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

    66

{

    67

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

    68

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

    69

    70

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

    71

    72

	switch(AICargo::GetTownEffect(cargo_id)) {

    73

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

    74

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

    75

		default: return -1;

    76

	}

    77

}

    78

    79

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

    80

{

    81

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

    82

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

    83

    84

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

    85

    86

	switch(AICargo::GetTownEffect(cargo_id)) {

    87

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

    88

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

    89

		default: return -1;

    90

	}

    91

}

    92

    93

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

    94

{

    95

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

    96

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

    97

    98

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

    99

   100

	switch(AICargo::GetTownEffect(cargo_id)) {

   101

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

   102

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

   103

		default: return -1;

   104

	}

   105

}

   106

   107

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

   108

{

   109

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

   110

}

   111

   112

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

   113

{

   114

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

   115

}

   116

   117

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

   118

{

   119

	if (!IsValidTown(town_id)) return false;

   120

   121

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

   122

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

   123

}

   124

   125

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

   126

{

   127

	if (!IsValidTown(town_id)) return false;

   128

   129

	return ::HasBit(::GetTown(town_id)->statues, _current_player);

   130

}

   131

   132

/* static */ int AITown::GetRoadReworkDuration(TownID town_id)

   133

{

   134

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

   135

   136

	return ::GetTown(town_id)->road_build_months;

   137

}

   138

   139

/* static */ AICompany::CompanyID AITown::GetExclusiveRightsPlayer(TownID town_id)

   140

{

   141

	if (!IsValidTown(town_id)) return AICompany::INVALID_COMPANY;

   142

   143

	return (AICompany::CompanyID)(int8)::GetTown(town_id)->exclusivity;

   144

}

   145

   146

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

   147

{

   148

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

   149

   150

	return ::GetTown(town_id)->exclusive_counter;

   151

}

   152

   153

extern uint GetMaskOfTownActions(int *nump, PlayerID pid, const Town *t);

   154

   155

/* static */ bool AITown::IsActionAvailable(TownID town_id, TownAction town_action)

   156

{

   157

	if (!IsValidTown(town_id)) return false;

   158

   159

	return HasBit(::GetMaskOfTownActions(NULL, _current_player, ::GetTown(town_id)), town_action);

   160

}

   161

   162

/* static */ bool AITown::PerformTownAction(TownID town_id, TownAction town_action)

   163

{

   164

	EnforcePrecondition(false, IsValidTown(town_id));

   165

	EnforcePrecondition(false, IsActionAvailable(town_id, town_action));

   166

   167

	return AIObject::DoCommand(::GetTown(town_id)->xy, town_id, town_action, CMD_DO_TOWN_ACTION);

   168

}

   169

   170

/* static */ AITown::TownRating AITown::GetRating(TownID town_id, AICompany::CompanyID company_id)

   171

{

   172

	if (!IsValidTown(town_id)) return INVALID_TOWN_RATING;

   173

	AICompany::CompanyID company = AICompany::ResolveCompanyID(company_id);

   174

	if (company == AICompany::INVALID_COMPANY) return INVALID_TOWN_RATING;

   175

   176

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

   177

	if (!HasBit(t->have_ratings, company)) return TOWN_RATING_NONE;

   178

	return max(TOWN_RATING_APPALLING, (TownRating)((t->ratings[company] / 200) + 3));

   179

}