uint accepted = 0;

	for (uint i = 0; i < st->industries_near.Length() && num_pieces != 0; i++) {

		Industry *ind = st->industries_near[i];

		if (ind->index == source) continue;

		uint cargo_index;

		for (cargo_index = 0; cargo_index < lengthof(ind->accepts_cargo); cargo_index++) {

			if (cargo_type == ind->accepts_cargo[cargo_index]) break;

		}

		/* Check if matching cargo has been found */

		if (cargo_index >= lengthof(ind->accepts_cargo)) continue;

#include <algorithm>

#include "newgrf_storage.h"

#include "subsidy_type.h"

#include "industry_map.h"

#include "industrytype.h"

#include "tilearea_type.h"

typedef Pool<Industry, IndustryID, 64, 64000> IndustryPool;

extern IndustryPool _industry_pool;

/**

/**

 * Defines the internal data of a functional industry.

 */

struct Industry : IndustryPool::PoolItem<&_industry_pool> {

	TileArea location;                                     ///< Location of the industry

	Town *town;                                            ///< Nearest town

	CargoID produced_cargo[INDUSTRY_NUM_OUTPUTS];          ///< 16 production cargo slots

	uint16 produced_cargo_waiting[INDUSTRY_NUM_OUTPUTS];   ///< amount of cargo produced per cargo

	uint16 incoming_cargo_waiting[INDUSTRY_NUM_INPUTS];    ///< incoming cargo waiting to be processed

	byte production_rate[INDUSTRY_NUM_OUTPUTS];            ///< production rate for each cargo

	byte prod_level;                                       ///< general production level

	CargoID accepts_cargo[INDUSTRY_NUM_INPUTS];            ///< 16 input cargo slots

{

	Industry *i = Industry::GetByTile(tile);

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

	bool moved_cargo = false;

	StationFinder stations(i->location);

	for (uint j = 0; j < lengthof(i->produced_cargo_waiting); j++) {

		uint cw = min(i->produced_cargo_waiting[j], 255);

		if (cw > indspec->minimal_cargo && i->produced_cargo[j] != CT_INVALID) {

			i->produced_cargo_waiting[j] -= cw;

			/* fluctuating economy? */

			if (EconomyIsInRecession()) cw = (cw + 1) / 2;

			i->this_month_production[j] += cw;

			i->this_month_transported[j] += am;

			moved_cargo |= (am != 0);

		}

	}

STR_CONFIG_SETTING_MAX_HEIGHTLEVEL_HELPTEXT                     :Set the maximum allowed height for mountains on the map

STR_CONFIG_SETTING_TOO_HIGH_MOUNTAIN                            :{WHITE}You can't set the maximum map height to this value. At least one mountain on the map is higher

STR_CONFIG_SETTING_AUTOSLOPE                                    :Allow landscaping under buildings, tracks, etc.: {STRING2}

STR_CONFIG_SETTING_AUTOSLOPE_HELPTEXT                           :Allow landscaping under buildings and tracks without removing them

STR_CONFIG_SETTING_CATCHMENT                                    :Allow more realistically sized catchment areas: {STRING2}

STR_CONFIG_SETTING_CATCHMENT_HELPTEXT                           :Have differently sized catchment areas for different types of stations and airports

STR_CONFIG_SETTING_EXTRADYNAMITE                                :Allow removal of more town-owned roads, bridges and tunnels: {STRING2}

STR_CONFIG_SETTING_EXTRADYNAMITE_HELPTEXT                       :Make it easier to remove town-owned infrastructure and buildings

STR_CONFIG_SETTING_TRAIN_LENGTH                                 :Maximum length of trains: {STRING2}

STR_CONFIG_SETTING_TRAIN_LENGTH_HELPTEXT                        :Set the maximum length of trains

STR_CONFIG_SETTING_TILE_LENGTH                                  :{COMMA} tile{P 0 "" s}

STR_CONFIG_SETTING_SMOKE_AMOUNT                                 :Amount of vehicle smoke/sparks: {STRING2}

	if (IsSavegameVersionBefore(SLV_TOWN_CARGOGEN)) {

		/* Ensure the original cargo generation mode is used */

		_settings_game.economy.town_cargogen_mode = TCGM_ORIGINAL;

	}

	/* Station acceptance is some kind of cache */

	if (IsSavegameVersionBefore(SLV_127)) {

		Station *st;

		FOR_ALL_STATIONS(st) UpdateStationAcceptance(st, false);

	}

static const SaveLoad _industry_desc[] = {

	SLE_CONDVAR(Industry, location.tile,              SLE_FILE_U16 | SLE_VAR_U32,  SL_MIN_VERSION, SLV_6),

	SLE_CONDVAR(Industry, location.tile,              SLE_UINT32,                  SLV_6, SL_MAX_VERSION),

	    SLE_VAR(Industry, location.w,                 SLE_FILE_U8 | SLE_VAR_U16),

	    SLE_VAR(Industry, location.h,                 SLE_FILE_U8 | SLE_VAR_U16),

	    SLE_REF(Industry, town,                       REF_TOWN),

	SLE_CONDNULL( 2, SL_MIN_VERSION, SLV_61),       ///< used to be industry's produced_cargo

	SLE_CONDARR(Industry, produced_cargo,             SLE_UINT8,   2,              SLV_78, SLV_EXTEND_INDUSTRY_CARGO_SLOTS),

	SLE_CONDARR(Industry, produced_cargo,             SLE_UINT8,  16,             SLV_EXTEND_INDUSTRY_CARGO_SLOTS, SL_MAX_VERSION),

	SLE_CONDARR(Industry, incoming_cargo_waiting,     SLE_UINT16,  3,              SLV_70, SLV_EXTEND_INDUSTRY_CARGO_SLOTS),

	SLE_CONDARR(Industry, incoming_cargo_waiting,     SLE_UINT16, 16,             SLV_EXTEND_INDUSTRY_CARGO_SLOTS, SL_MAX_VERSION),

	SLE_CONDARR(Industry, produced_cargo_waiting,     SLE_UINT16,  2,               SL_MIN_VERSION, SLV_EXTEND_INDUSTRY_CARGO_SLOTS),

	SLV_GROUP_LIVERIES,                     ///< 205  PR#7108 Livery storage change and group liveries.

	SLV_SHIPS_STOP_IN_LOCKS,                ///< 206  PR#7150 Ship/lock movement changes.

	SLV_FIX_CARGO_MONITOR,                  ///< 207  PR#7175 v1.9  Cargo monitor data packing fix to support 64 cargotypes.

	SLV_TOWN_CARGOGEN,                      ///< 208  PR#6965 New algorithms for town building cargo generation.

	SLV_SHIP_CURVE_PENALTY,                 ///< 209  PR#7289 Configurable ship curve penalties.

	SL_MAX_VERSION,                         ///< Highest possible saveload version

};

/** Save or load result codes. */

enum SaveOrLoadResult {

	SL_OK     = 0, ///< completed successfully

			{

				industries->Add(new SettingEntry("construction.raw_industry_construction"));

				industries->Add(new SettingEntry("construction.industry_platform"));

				industries->Add(new SettingEntry("economy.multiple_industry_per_town"));

				industries->Add(new SettingEntry("game_creation.oil_refinery_limit"));

				industries->Add(new SettingEntry("economy.smooth_economy"));

			}

			SettingsPage *cdist = environment->Add(new SettingsPage(STR_CONFIG_SETTING_ENVIRONMENT_CARGODIST));

			{

				cdist->Add(new SettingEntry("linkgraph.recalc_time"));

				cdist->Add(new SettingEntry("linkgraph.recalc_interval"));

	}

};

/** Settings related to stations. */

struct StationSettings {

	bool   modified_catchment;               ///< different-size catchment areas

	bool   adjacent_stations;                ///< allow stations to be built directly adjacent to other stations

	bool   distant_join_stations;            ///< allow to join non-adjacent stations

	bool   never_expire_airports;            ///< never expire airports

	byte   station_spread;                   ///< amount a station may spread

};

 */

void Station::RecomputeIndustriesNear()

{

	this->industries_near.Clear();

	if (this->rect.IsEmpty()) return;

	RectAndIndustryVector riv = {

		this->GetCatchmentRect(),

		&this->industries_near

	};

	/* Compute maximum extent of acceptance rectangle wrt. station sign */

	byte last_vehicle_type;

	std::list<Vehicle *> loading_vehicles;

	GoodsEntry goods[NUM_CARGO];  ///< Goods at this station

	CargoTypes always_accepted;       ///< Bitmask of always accepted cargo types (by houses, HQs, industry tiles when industry doesn't accept cargo)

	IndustryVector industries_near; ///< Cached list of industries near the station that can accept cargo, @see DeliverGoodsToIndustry()

	Station(TileIndex tile = INVALID_TILE);

	~Station();

	void AddFacility(StationFacility new_facility_bit, TileIndex facil_xy);

	 * area loop might not hit an industry tile while

	 * the industry would produce cargo for the station.

	 */

	const Industry *i;

	FOR_ALL_INDUSTRIES(i) {

		if (!ta.Intersects(i->location)) continue;

		for (uint j = 0; j < lengthof(i->produced_cargo); j++) {

			CargoID cargo = i->produced_cargo[j];

			if (cargo != CT_INVALID) produced[cargo]++;

		}

	}

 * Get the acceptance of cargoes around the tile in 1/8.

 * @param tile Center of the search area

 * @param w X extent of area

 * @param h Y extent of area

 * @param rad Search radius in addition to given area

 * @param always_accepted bitmask of cargo accepted by houses and headquarters; can be NULL

 */

{

	CargoArray acceptance;

	if (always_accepted != NULL) *always_accepted = 0;

	int x = TileX(tile);

	int y = TileY(tile);

	assert(w > 0);

	assert(h > 0);

	for (int yc = y1; yc != y2; yc++) {

		for (int xc = x1; xc != x2; xc++) {

			TileIndex tile = TileXY(xc, yc);

			AddAcceptedCargo(tile, acceptance, always_accepted);

		}

	}

	return acceptance;

}

	if (!st->rect.IsEmpty()) {

		acceptance = GetAcceptanceAroundTiles(

			TileXY(st->rect.left, st->rect.top),

			st->rect.right  - st->rect.left + 1,

			st->rect.bottom - st->rect.top  + 1,

			st->GetCatchmentRadius(),

		);

	}

	/* Adjust in case our station only accepts fewer kinds of goods */

	for (CargoID i = 0; i < NUM_CARGO; i++) {

		uint amt = acceptance[i];

	uint min_x = (x > max_rad) ? x - max_rad : 0;

	uint max_x = x + location.w + max_rad;

	uint min_y = (y > max_rad) ? y - max_rad : 0;

	uint max_y = y + location.h + max_rad;

	if (min_x == 0 && _settings_game.construction.freeform_edges) min_x = 1;

	if (min_y == 0 && _settings_game.construction.freeform_edges) min_y = 1;

	if (max_x >= MapSizeX()) max_x = MapSizeX() - 1;

	if (max_y >= MapSizeY()) max_y = MapSizeY() - 1;

	for (uint cy = min_y; cy < max_y; cy++) {

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

			Station *st = Station::GetByTile(cur_tile);

			/* st can be NULL in case of waypoints */

			if (st == NULL) continue;

			if (_settings_game.station.modified_catchment) {

				int rad = st->GetCatchmentRadius();

				int rad_x = cx - x;

				int rad_y = cy - y;

				if (rad_x < -rad || rad_x >= rad + location.w) continue;

	Station *st = new Station(tile);

	st->town = ClosestTownFromTile(tile, UINT_MAX);

	st->string_id = GenerateStationName(st, tile, STATIONNAMING_OILRIG);

	assert(IsTileType(tile, MP_INDUSTRY));

	DeleteAnimatedTile(tile);

	MakeOilrig(tile, st->index, GetWaterClass(tile));

	st->owner = OWNER_NONE;

	st->airport.type = AT_OILRIG;

	st->airport.Add(tile);

#include "rail_type.h"

#include "road_type.h"

#include "vehicle_type.h"

#include "economy_func.h"

#include "rail.h"

#include "linkgraph/linkgraph_type.h"

void ModifyStationRatingAround(TileIndex tile, Owner owner, int amount, uint radius);

void FindStationsAroundTiles(const TileArea &location, StationList *stations);

void ShowStationViewWindow(StationID station);

void UpdateAllStationVirtCoords();

CargoArray GetProductionAroundTiles(TileIndex tile, int w, int h, int rad);

void UpdateStationAcceptance(Station *st, bool show_msg);

const DrawTileSprites *GetStationTileLayout(StationType st, byte gfx);

void StationPickerDrawSprite(int x, int y, StationType st, RailType railtype, RoadType roadtype, int image);

strhelp  = STR_CONFIG_SETTING_CATCHMENT_HELPTEXT

proc     = StationCatchmentChanged

cat      = SC_EXPERT

[SDT_BOOL]

base     = GameSettings

var      = order.gradual_loading

from     = SLV_40

guiflags = SGF_NO_NETWORK

def      = true

cat      = SC_EXPERT