1

/* $Id$ */

     2

     3

/** @file ai_industry.cpp Implementation of AIIndustry. */

     4

     5

#include "ai_industry.hpp"

     6

#include "ai_cargo.hpp"

     7

#include "ai_map.hpp"

     8

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

     9

#include "../../industry.h"

    10

#include "../../tile_type.h"

    11

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

    13

#include "table/strings.h"

    14

    15

/* static */ IndustryID AIIndustry::GetMaxIndustryID()

    16

{

    17

	return ::GetMaxIndustryIndex();

    18

}

    19

    20

/* static */ int32 AIIndustry::GetIndustryCount()

    21

{

    22

	return ::GetNumIndustries();

    23

}

    24

    25

/* static */ bool AIIndustry::IsValidIndustry(IndustryID industry_id)

    26

{

    27

	return ::IsValidIndustryID(industry_id);

    28

}

    29

    30

/* static */ char *AIIndustry::GetName(IndustryID industry_id)

    31

{

    32

	if (!IsValidIndustry(industry_id)) return NULL;

    33

	static const int len = 64;

    34

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

    35

    36

	::SetDParam(0, industry_id);

    37

	::GetString(industry_name, STR_INDUSTRY, &industry_name[len - 1]);

    38

    39

	return industry_name;

    40

}

    41

    42

/* static */ int32 AIIndustry::GetProduction(IndustryID industry_id, CargoID cargo_id)

    43

{

    44

	if (!IsValidIndustry(industry_id)) return -1;

    45

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

    46

    47

	const Industry *i = ::GetIndustry(industry_id);

    48

	const IndustrySpec *indsp = ::GetIndustrySpec(i->type);

    49

    50

	for (byte j = 0; j < lengthof(indsp->produced_cargo); j++)

    51

		if (indsp->produced_cargo[j] == cargo_id) return i->production_rate[j] * 8;

    52

    53

	return -1;

    54

}

    55

    56

/* static */ bool AIIndustry::IsCargoAccepted(IndustryID industry_id, CargoID cargo_id)

    57

{

    58

	if (!IsValidIndustry(industry_id)) return false;

    59

	if (!AICargo::IsValidCargo(cargo_id)) return false;

    60

    61

	const Industry *i = ::GetIndustry(industry_id);

    62

	const IndustrySpec *indsp = ::GetIndustrySpec(i->type);

    63

    64

	for (byte j = 0; j < lengthof(indsp->accepts_cargo); j++)

    65

		if (indsp->accepts_cargo[j] == cargo_id) return true;

    66

    67

	return false;

    68

}

    69

    70

/* static */ uint16 AIIndustry::GetLastMonthProduction(IndustryID industry_id, CargoID cargo_id)

    71

{

    72

	if (!IsValidIndustry(industry_id)) return false;

    73

	if (!AICargo::IsValidCargo(cargo_id)) return false;

    74

    75

	const Industry *i = ::GetIndustry(industry_id);

    76

	const IndustrySpec *indsp = ::GetIndustrySpec(i->type);

    77

    78

	for (byte j = 0; j < lengthof(indsp->produced_cargo); j++)

    79

		if (indsp->produced_cargo[j] == cargo_id) return i->last_month_production[j];

    80

    81

	return false;

    82

}

    83

    84

/* static */ uint16 AIIndustry::GetLastMonthTransported(IndustryID industry_id, CargoID cargo_id)

    85

{

    86

	if (!IsValidIndustry(industry_id)) return false;

    87

	if (!AICargo::IsValidCargo(cargo_id)) return false;

    88

    89

	const Industry *i = ::GetIndustry(industry_id);

    90

	const IndustrySpec *indsp = ::GetIndustrySpec(i->type);

    91

    92

	for (byte j = 0; j < lengthof(indsp->produced_cargo); j++)

    93

		if (indsp->produced_cargo[j] == cargo_id) return i->last_month_transported[j];

    94

    95

	return false;

    96

}

    97

   113

/* static */ int32 AIIndustry::GetDistanceManhattanToTile(IndustryID industry_id, TileIndex tile)

   114

{

   117

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

   118

}

   119

   120

/* static */ int32 AIIndustry::GetDistanceSquareToTile(IndustryID industry_id, TileIndex tile)

   121

{

   124

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

   125

}

   126

   127

/* static */ bool AIIndustry::IsBuiltOnWater(IndustryID industry_id)

   128

{

   129

	if (!IsValidIndustry(industry_id)) return false;

   130

   131

	return (::GetIndustrySpec(::GetIndustry(industry_id)->type)->behaviour & INDUSTRYBEH_BUILT_ONWATER) != 0;

   132

}

   133

   134

/* static */ bool AIIndustry::HasHeliportAndDock(IndustryID industry_id)

   135

{

   136

	if (!IsValidIndustry(industry_id)) return false;

   137

   138

	return (::GetIndustrySpec(::GetIndustry(industry_id)->type)->behaviour & INDUSTRYBEH_AI_AIRSHIP_ROUTES) != 0;

   139

}

   140

   141

/* static */ TileIndex AIIndustry::GetHeliportAndDockLocation(IndustryID industry_id)

   142

{

   143

	if (!IsValidIndustry(industry_id)) return INVALID_TILE;

   144

	if (!HasHeliportAndDock(industry_id)) return INVALID_TILE;

   145

   146

	return ::GetIndustry(industry_id)->xy;

   147

}