}

	}

	/* Handle delivery.

	 * Note that delivery in the right area is sufficient to prevent trouble with neighbouring industries or houses. */

	/* Town delivery. */

	CargoMonitorID num = EncodeCargoTownMonitor(company, cargo_type, st->town->index);

	CargoMonitorMap::iterator iter = _cargo_deliveries.find(num);

	if (iter != _cargo_deliveries.end()) iter->second += amount;

	/* Industry delivery. */

		CargoMonitorMap::iterator iter = _cargo_deliveries.find(num);

		if (iter != _cargo_deliveries.end()) iter->second += amount;

	}

}

 */

static uint DeliverGoodsToIndustry(const Station *st, CargoID cargo_type, uint num_pieces, IndustryID source, CompanyID company)

{

	/* Find the nearest industrytile to the station sign inside the catchment area, whose industry accepts the cargo.

	 * This fails in three cases:

	 *  1) The station accepts the cargo because there are enough houses around it accepting the cargo.

	 *  2) The industries in the catchment area temporarily reject the cargo, and the daily station loop has not yet updated station acceptance.

	 *  3) The results of callbacks CBID_INDUSTRY_REFUSE_CARGO and CBID_INDTILE_CARGO_ACCEPTANCE are inconsistent. (documented behaviour)

	 */

	uint accepted = 0;

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

		if (!_settings_game.station.serve_neutral_industries) {

			/* If this industry is only served by its neutral station, check it's us. */

			if (ind->neutral_station != NULL && ind->neutral_station != st) 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 */

 */

static bool TransportIndustryGoods(TileIndex tile)

{

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

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

	bool moved_cargo = false;

	StationFinder stations(i->location);

	StationList neutral;

	if (i->neutral_station != NULL && !_settings_game.station.serve_neutral_industries) {

		/* Industry has a neutral station. Use it and ignore any other nearby stations. */

	}

	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);

		}

	}

	return moved_cargo;

}

static void AnimateTile_Industry(TileIndex tile)

{

	AddAcceptedCargo_Industry,   // add_accepted_cargo_proc

	GetTileDesc_Industry,        // get_tile_desc_proc

	GetTileTrackStatus_Industry, // get_tile_track_status_proc

	ClickTile_Industry,          // click_tile_proc

	AnimateTile_Industry,        // animate_tile_proc

	TileLoop_Industry,           // tile_loop_proc

	ChangeTileOwner_Industry,    // change_tile_owner_proc

	NULL,                        // add_produced_cargo_proc

	NULL,                        // vehicle_enter_tile_proc

	GetFoundation_Industry,      // get_foundation_proc

	TerraformTile_Industry,      // terraform_tile_proc

};

	Rect ret = {

		max<int>(this->rect.left   - catchment_radius, 0),

		max<int>(this->rect.top    - catchment_radius, 0),

		min<int>(this->rect.right  + catchment_radius, MapMaxX()),

		min<int>(this->rect.bottom + catchment_radius, MapMaxY())

	};

	return ret;

}

/** Rect and pointer to IndustryVector */

struct RectAndIndustryVector {

};

/**

 * Callback function for Station::RecomputeIndustriesNear()

 * Tests whether tile is an industry and possibly adds

 * the industry to station's industries_near list.

 * @param ind_tile tile to check

 * @param user_data pointer to RectAndIndustryVector

 * @return always false, we want to search all tiles

 */

static bool FindIndustryToDeliver(TileIndex ind_tile, void *user_data)

{

	/* Only process industry tiles */

	if (!IsTileType(ind_tile, MP_INDUSTRY)) return false;

	RectAndIndustryVector *riv = (RectAndIndustryVector *)user_data;

	Industry *ind = Industry::GetByTile(ind_tile);

	/* Don't check further if this industry is already in the list */

	/* Only process tiles in the station acceptance rectangle */

	int x = TileX(ind_tile);

	int y = TileY(ind_tile);

	if (x < riv->rect.left || x > riv->rect.right || y < riv->rect.top || y > riv->rect.bottom) return false;

	/* Include only industries that can accept cargo */

	uint cargo_index;

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

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

	}

	if (cargo_index >= lengthof(ind->accepts_cargo)) return false;

	return false;

}

/**

 * Recomputes Station::industries_near, list of industries possibly

 * accepting cargo in station's catchment radius

 */

void Station::RecomputeIndustriesNear()

{

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

	if (!_settings_game.station.serve_neutral_industries && this->industry != NULL) {

		/* Station is associated with an industry, so we only need to deliver to that industry. */

		return;

	}

	RectAndIndustryVector riv = {

		this->GetCatchmentRect(),

		&this->industries_near

	};

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

	TileIndex start_tile = this->xy;

	uint max_radius = max(

		max(DistanceManhattan(start_tile, TileXY(riv.rect.left,  riv.rect.top)), DistanceManhattan(start_tile, TileXY(riv.rect.left,  riv.rect.bottom))),

#ifndef STATION_BASE_H

#define STATION_BASE_H

#include "core/random_func.hpp"

#include "base_station_base.h"

#include "newgrf_airport.h"

#include "cargopacket.h"

#include "industry_type.h"

#include "linkgraph/linkgraph_type.h"

#include "newgrf_storage.h"

#include <map>

typedef Pool<BaseStation, StationID, 32, 64000> StationPool;

extern StationPool _station_pool;

static const byte INITIAL_STATION_RATING = 175;

/**

 * Flow statistics telling how much flow should be sent along a link. This is

 * done by creating "flow shares" and using std::map's upper_bound() method to

 * look them up with a random number. A flow share is the difference between a

 * key in a map and the previous key. So one key in the map doesn't actually

 * mean anything by itself.

	inline const HangarTileTable *GetHangarDataByTile(TileIndex tile) const

	{

		const AirportSpec *as = this->GetSpec();

		for (uint i = 0; i < as->nof_depots; i++) {

			if (this->GetRotatedTileFromOffset(as->depot_table[i].ti) == tile) {

				return as->depot_table + i;

			}

		}

		NOT_REACHED();

	}

};

/** Station data structure */

struct Station FINAL : SpecializedStation<Station, false> {

public:

	RoadStop *GetPrimaryRoadStop(RoadStopType type) const

	{

		return type == ROADSTOP_BUS ? bus_stops : truck_stops;

	}

	RoadStop *GetPrimaryRoadStop(const struct RoadVehicle *v) const;

	RoadStop *bus_stops;    ///< All the road stops

	IndustryType indtype;   ///< Industry type to get the name from

	StationHadVehicleOfTypeByte had_vehicle_of_type;

	byte time_since_load;

	byte time_since_unload;

	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)

	Station(TileIndex tile = INVALID_TILE);

	~Station();

	void AddFacility(StationFacility new_facility_bit, TileIndex facil_xy);

	void MarkTilesDirty(bool cargo_change) const;

	void UpdateVirtCoord();

	void AfterStationTileSetChange(bool adding, StationType type);

		}

	}

	bool subsidised = false;

	/* Check if there's a (new) subsidy that applies. There can be more subsidies triggered by this delivery!

	 * Think about the case that subsidies are A->B and A->C and station has both B and C in its catchment area */

	Subsidy *s;

	FOR_ALL_SUBSIDIES(s) {

		if (s->cargo_type == cargo_type && s->src_type == src_type && s->src == src && (!s->IsAwarded() || s->awarded == company)) {

			switch (s->dst_type) {

				case ST_INDUSTRY:

							subsidised = true;

							if (!s->IsAwarded()) s->AwardTo(company);

						}

					}

					break;

				case ST_TOWN:

					for (const Town * const *tp = towns_near.Begin(); tp != towns_near.End(); tp++) {

						if (s->dst == (*tp)->index) {

							assert((*tp)->cache.part_of_subsidy & POS_DST);

							subsidised = true;

							if (!s->IsAwarded()) s->AwardTo(company);

						}