1

/* $Id$ */

     2

     3

/** @file ai_tilelist.cpp Implementation of AITileList and friends. */

     4

     5

#include "ai_tilelist.hpp"

     6

#include "ai_industry.hpp"

     7

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

     8

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

     9

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

    10

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

    11

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

    12

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

    13

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

    14

#include "../../station_base.h"

    15

#include "../../station_map.h"

    16

    17

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

    18

{

    19

	uint x1 = ::TileX(t1);

    20

	uint x2 = ::TileX(t2);

    21

    22

	uint y1 = ::TileY(t1);

    23

	uint y2 = ::TileY(t2);

    24

    25

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

    26

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

    27

    28

	t1 = ::TileXY(x1, y1);

    29

	t2 = ::TileXY(x2, y2);

    30

}

    31

    32

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

    33

{

    34

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

    35

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

    36

    37

	this->FixRectangleSpan(t1, t2);

    38

    39

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

    40

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

    41

    42

	BEGIN_TILE_LOOP(t, w, h, t1) {

    43

		this->AddItem(t);

    44

	} END_TILE_LOOP(t, w, h, t1)

    45

}

    46

    47

void AITileList::AddTile(TileIndex tile)

    48

{

    49

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

    50

    51

	this->AddItem(tile);

    52

}

    53

    54

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

    55

{

    56

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

    57

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

    58

    59

	this->FixRectangleSpan(t1, t2);

    60

    61

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

    62

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

    63

    64

	BEGIN_TILE_LOOP(t, w, h, t1) {

    65

		this->RemoveItem(t);

    66

	} END_TILE_LOOP(t, w, h, t1)

    67

}

    68

    69

void AITileList::RemoveTile(TileIndex tile)

    70

{

    71

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

    72

    73

	this->RemoveItem(tile);

    74

}

    75

    76

AITileList_IndustryAccepting::AITileList_IndustryAccepting(IndustryID industry_id, uint radius)

    77

{

    78

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

    79

    80

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

    81

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

    82

    83

	/* Check if this industry accepts anything */

    84

	{

    85

		bool cargo_accepts = false;

    86

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

    87

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

    88

		}

    89

		if (!cargo_accepts) return;

    90

	}

    91

    92

	if (!_settings_game.station.modified_catchment) radius = CA_UNMODIFIED;

    93

    94

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

    95

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

    96

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

    97

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

    98

    99

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

   100

		 *  industry triggers the acceptance). */

   101

		AcceptedCargo accepts;

   102

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

   103

		{

   104

			bool cargo_accepts = false;

   105

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

   106

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

   107

			}

   108

			if (!cargo_accepts) continue;

   109

		}

   110

   111

		this->AddTile(cur_tile);

   112

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

   113

}

   114

   115

AITileList_IndustryProducing::AITileList_IndustryProducing(IndustryID industry_id, uint radius)

   116

{

   117

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

   118

   119

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

   120

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

   121

   122

	/* Check if this industry produces anything */

   123

	{

   124

		bool cargo_produces = false;

   125

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

   126

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

   127

		}

   128

		if (!cargo_produces) return;

   129

	}

   130

   131

	if (!_settings_game.station.modified_catchment) radius = CA_UNMODIFIED;

   132

   133

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

   134

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

   135

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

   136

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

   137

   138

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

   139

		 *  inconsitance). */

   140

		AcceptedCargo produces;

   141

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

   142

		{

   143

			bool cargo_produces = false;

   144

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

   145

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

   146

			}

   147

			if (!cargo_produces) continue;

   148

		}

   149

   150

		this->AddTile(cur_tile);

   151

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

   152

}

   153

   154

AITileList_StationType::AITileList_StationType(StationID station_id, AIStation::StationType station_type)

   155

{

   156

	if (!AIStation::IsValidStation(station_id)) return;

   157

   158

	const StationRect *rect = &::GetStation(station_id)->rect;

   159

	int station_type_value = ::FindFirstBit(station_type);

   160

   161

	BEGIN_TILE_LOOP(cur_tile, rect->right - rect->left + 1, rect->bottom - rect->top + 1, ::TileXY(rect->left, rect->top)) {

   162

		if (!::IsTileType(cur_tile, MP_STATION)) continue;

   163

		if (::GetStationIndex(cur_tile) != station_id) continue;

   164

		if (::GetStationType(cur_tile) != station_type_value) continue;

   165

		this->AddTile(cur_tile);

   166

	} END_TILE_LOOP(cur_tile, rect->right - rect->left + 1, rect->bottom - rect->top + 1, ::TileXY(rect->left, rect->top))

   167

}