1

/* $Id$ */

     2

     3

/** @file ai_tilelist.cpp handles all functions of the AITileList class */

     4

     5

#include "ai_tilelist.hpp"

     6

#include "ai_industry.hpp"

     7

     8

#include "../../landscape.h"

     9

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

    10

#include "../../station.h"

    11

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

    12

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

    13

#include "../../industry_map.h"

    14

    15

void AITileList::FixRectangleSpan(TileIndex &t1, TileIndex &t2)

    16

{

    17

	uint x1 = ::TileX(t1);

    18

	uint x2 = ::TileX(t2);

    19

    20

	uint y1 = ::TileY(t1);

    21

	uint y2 = ::TileY(t2);

    22

    23

	if (x1 >= x2) ::Swap(x1, x2);

    24

	if (y1 >= y2) ::Swap(y1, y2);

    25

    26

	t1 = ::TileXY(x1, y1);

    27

	t2 = ::TileXY(x2, y2);

    28

}

    29

    30

void AITileList::AddRectangle(TileIndex t1, TileIndex t2)

    31

{

    32

	if (!::IsValidTile(t1)) return;

    33

	if (!::IsValidTile(t2)) return;

    34

    35

	this->FixRectangleSpan(t1, t2);

    36

    37

	uint w = TileX(t2) - TileX(t1) + 1;

    38

	uint h = TileY(t2) - TileY(t1) + 1;

    39

    40

	BEGIN_TILE_LOOP(t, w, h, t1) {

    41

		this->AddItem(t);

    42

	} END_TILE_LOOP(t, w, h, t1)

    43

}

    44

    45

void AITileList::AddTile(TileIndex tile)

    46

{

    47

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

    48

    49

	this->AddItem(tile);

    50

}

    51

    52

void AITileList::RemoveRectangle(TileIndex t1, TileIndex t2)

    53

{

    54

	if (!::IsValidTile(t1)) return;

    55

	if (!::IsValidTile(t2)) return;

    56

    57

	this->FixRectangleSpan(t1, t2);

    58

    59

	uint w = TileX(t2) - TileX(t1) + 1;

    60

	uint h = TileY(t2) - TileY(t1) + 1;

    61

    62

	BEGIN_TILE_LOOP(t, w, h, t1) {

    63

		this->RemoveItem(t);

    64

	} END_TILE_LOOP(t, w, h, t1)

    65

}

    66

    67

void AITileList::RemoveTile(TileIndex tile)

    68

{

    69

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

    70

    71

	this->RemoveItem(tile);

    72

}

    73

    74

AITileList_IndustryAccepting::AITileList_IndustryAccepting(IndustryID industry_id, uint radius)

    75

{

    76

	if (!AIIndustry::IsValidIndustry(industry_id)) return;

    77

    78

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

    79

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

    80

    81

	/* Check if this industry accepts anything */

    82

	{

    83

		bool cargo_accepts = false;

    84

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

    85

			if (indsp->accepts_cargo[j] != CT_INVALID) cargo_accepts = true;

    86

		}

    87

		if (!cargo_accepts) return;

    88

	}

    89

    90

	if (!_patches.modified_catchment) radius = CA_UNMODIFIED;

    91

    92

	BEGIN_TILE_LOOP(cur_tile, i->width + radius * 2, i->height + radius * 2, i->xy - ::TileDiffXY(radius, radius)) {

    93

		if (!::IsValidTile(cur_tile)) continue;

    94

		/* Exclude all tiles that belong to this industry */

    95

		if (::IsTileType(cur_tile, MP_INDUSTRY) && ::GetIndustryIndex(cur_tile) == industry_id) continue;

    96

    97

		/* Only add the tile if it accepts the cargo (sometimes just 1 tile of an

    98

		 *  industry triggers the acceptance). */

    99

		AcceptedCargo accepts;

   100

		::GetAcceptanceAroundTiles(accepts, cur_tile, 1, 1, radius);

   101

		{

   102

			bool cargo_accepts = false;

   103

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

   104

				if (indsp->accepts_cargo[j] != CT_INVALID && accepts[indsp->accepts_cargo[j]] != 0) cargo_accepts = true;

   105

			}

   106

			if (!cargo_accepts) continue;

   107

		}

   108

   109

		this->AddTile(cur_tile);

   110

	} END_TILE_LOOP(cur_tile, i->width + radius * 2, i->height + radius * 2, i->xy - ::TileDiffXY(radius, radius))

   111

}

   112

   113

AITileList_IndustryProducing::AITileList_IndustryProducing(IndustryID industry_id, uint radius)

   114

{

   115

	if (!AIIndustry::IsValidIndustry(industry_id)) return;

   116

   117

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

   118

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

   119

   120

	/* Check if this industry produces anything */

   121

	{

   122

		bool cargo_produces = false;

   123

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

   124

			if (indsp->produced_cargo[j] != CT_INVALID) cargo_produces = true;

   125

		}

   126

		if (!cargo_produces) return;

   127

	}

   128

   129

	if (!_patches.modified_catchment) radius = CA_UNMODIFIED;

   130

   131

	BEGIN_TILE_LOOP(cur_tile, i->width + radius * 2, i->height + radius * 2, i->xy - ::TileDiffXY(radius, radius)) {

   132

		if (!::IsValidTile(cur_tile)) continue;

   133

		/* Exclude all tiles that belong to this industry */

   134

		if (::IsTileType(cur_tile, MP_INDUSTRY) && ::GetIndustryIndex(cur_tile) == industry_id) continue;

   135

   136

		/* Only add the tile if it produces the cargo (a bug in OpenTTD makes this

   137

		 *  inconsitance). */

   138

		AcceptedCargo produces;

   139

		::GetProductionAroundTiles(produces, cur_tile, 1, 1, radius);

   140

		{

   141

			bool cargo_produces = false;

   142

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

   143

				if (indsp->produced_cargo[j] != CT_INVALID && produces[indsp->produced_cargo[j]] != 0) cargo_produces = true;

   144

			}

   145

			if (!cargo_produces) continue;

   146

		}

   147

   148

		this->AddTile(cur_tile);

   149

	} END_TILE_LOOP(cur_tile, i->width + radius * 2, i->height + radius * 2, i->xy - ::TileDiffXY(radius, radius))

   150

}