* @param ind Industry

 */

static void PopulateStationsNearby(Industry *ind)

{

	if (ind->neutral_station != nullptr && !_settings_game.station.serve_neutral_industries) {

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

		ind->stations_near.insert(ind->neutral_station);

		ind->neutral_station->industries_near.clear();

		ind->neutral_station->industries_near.insert(ind);

		return;

	}

}

/**

 * Put an industry on the map.

 * @param i                   Just allocated poolitem, mostly empty.

 * @param tile                North tile of the industry.

 * @param type                Type of the industry.

 * @param layout              Industrylayout to build.

 * @param layout_index        Number of the industry layout.

 * @param t                   Nearest town.

 * @param founder             Founder of the industry; OWNER_NONE in case of random construction.

 * @param initial_random_bits Random bits for the industry.

		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;

}

/**

 * Add nearby industry to station's industries_near list if it accepts cargo.

 * @param ind Industry

 */

{

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

	/* 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;

}

/**

 * Remove this station from the nearby stations lists of all towns and industries.

 */

void Station::RemoveFromAllNearbyLists()

{

	for (Town *t : Town::Iterate()) { t->stations_near.erase(this); }

	for (Industry *i : Industry::Iterate()) { i->stations_near.erase(this); }

}

/**

			Town *t = Town::GetByTile(tile);

			t->stations_near.insert(this);

		}

		if (IsTileType(tile, MP_INDUSTRY)) {

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

			/* Ignore industry if it has a neutral station. It already can't be this station. */

			if (!_settings_game.station.serve_neutral_industries && i->neutral_station != nullptr) continue;

			i->stations_near.insert(this);

			/* Add if we can deliver to this industry as well */

		}

	}

}

/**

 * Recomputes catchment of all stations.

 * This will additionally recompute nearby stations for all towns and industries.

 */

/* static */ void Station::RecomputeCatchmentForAll()

{

	for (Station *st : Station::Iterate()) { st->RecomputeCatchment(); }

}

	void MoveSign(TileIndex new_xy) override;

	void AfterStationTileSetChange(bool adding, StationType type);

	uint GetPlatformLength(TileIndex tile, DiagDirection dir) const override;

	uint GetPlatformLength(TileIndex tile) const override;

	void RecomputeCatchment();

	static void RecomputeCatchmentForAll();

	uint GetCatchmentRadius() const;

	Rect GetCatchmentRect() const;

	bool CatchmentCoversTown(TownID t) const;

	void RemoveFromAllNearbyLists();

	inline bool TileIsInCatchment(TileIndex tile) const

	{

		return this->catchment_tiles.HasTile(tile);

	}

	inline bool TileBelongsToRailStation(TileIndex tile) const override

	{

		return IsRailStationTile(tile) && GetStationIndex(tile) == this->index;

	}

		}

		return *this;

	}

	virtual TileIterator *Clone() const

	{

		return new AirportTileIterator(*this);

	}

};

void RebuildStationKdtree();

#endif /* STATION_BASE_H */

#include "pathfinder/yapf/yapf_cache.h"

#include "road_internal.h" /* For drawing catenary/checking road removal */

#include "autoslope.h"

#include "water.h"

#include "strings_func.h"

#include "clear_func.h"

#include "date_func.h"

#include "vehicle_func.h"

#include "string_func.h"

#include "animated_tile_func.h"

#include "elrail_func.h"

#include "station_base.h"

#include "station_kdtree.h"

#include "roadstop_base.h"

#include "newgrf_railtype.h"

#include "newgrf_roadtype.h"

#include "waypoint_base.h"

#include "waypoint_func.h"

#include "pbs.h"

#include "debug.h"

#include "core/random_func.hpp"

#include "company_base.h"

#include "table/airporttile_ids.h"

#include "newgrf_airporttiles.h"

	return CommandCost();

}

static void AddNearbyStationsByCatchment(TileIndex tile, StationList *stations, StationList &nearby)

{

	for (Station *st : nearby) {

		if (st->TileIsInCatchment(tile)) stations->insert(st);

	}

}

/**

 * Run a tile loop to find stations around a tile, on demand. Cache the result for further requests

 * @return pointer to a StationList containing all stations found

 */

const StationList *StationFinder::GetStations()

{

	if (this->tile != INVALID_TILE) {

		this->tile = INVALID_TILE;

	}

	return &this->stations;

}

static bool CanMoveGoodsToStation(const Station *st, CargoID type)

{

	/* Is the station reserved exclusively for somebody else? */

	if (st->owner != OWNER_NONE && st->town->exclusive_counter > 0 && st->town->exclusivity != st->owner) return false;

	/* Lowest possible rating, better not to give cargo anymore. */

	if (st->goods[type].rating == 0) return false;

	/* Selectively servicing stations, and not this one. */

	if (_settings_game.order.selectgoods && !st->goods[type].HasVehicleEverTriedLoading()) return false;

	if (IsCargoInClass(type, CC_PASSENGERS)) {

#include "sprite.h"

#include "rail_type.h"

#include "road_type.h"

#include "vehicle_type.h"

#include "economy_func.h"

#include "rail.h"

#include "road.h"

#include "linkgraph/linkgraph_type.h"

#include "industry_type.h"

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

void ShowStationViewWindow(StationID station);

void UpdateAllStationVirtCoords();

void ClearAllStationCachedNames();

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

CargoArray GetAcceptanceAroundTiles(TileIndex tile, int w, int h, int rad, CargoTypes *always_accepted = nullptr);

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

	/* Tile area for TileHighlightData */

	TileArea location(TileVirtXY(_thd.pos.x, _thd.pos.y), _thd.size.x / TILE_SIZE - 1, _thd.size.y / TILE_SIZE - 1);

	/* Extended area by one tile */

	uint x = TileX(location.tile);

	uint y = TileY(location.tile);

	int max_c = 1;

	TileArea ta(TileXY(max<int>(0, x - max_c), max<int>(0, y - max_c)), TileXY(min<int>(MapMaxX(), x + location.w + max_c), min<int>(MapMaxY(), y + location.h + max_c)));

	Station *adjacent = nullptr;

	TILE_AREA_LOOP(tile, ta) {

		if (IsTileType(tile, MP_STATION) && GetTileOwner(tile) == _local_company) {

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

			if (st == nullptr) continue;

			if (adjacent != nullptr && st != adjacent) {

				/* Multiple nearby, distant join is required. */

				adjacent = nullptr;

				break;

			}

			adjacent = st;

		}

	}

 * @param random_bits required for newgrf houses

 * @pre house can be built here

 */

static void MakeTownHouse(TileIndex t, Town *town, byte counter, byte stage, HouseID type, byte random_bits)

{

	BuildingFlags size = HouseSpec::Get(type)->building_flags;

	ClearMakeHouseTile(t, town, counter, stage, type, random_bits);

	if (size & BUILDING_2_TILES_Y)   ClearMakeHouseTile(t + TileDiffXY(0, 1), town, counter, stage, ++type, random_bits);

	if (size & BUILDING_2_TILES_X)   ClearMakeHouseTile(t + TileDiffXY(1, 0), town, counter, stage, ++type, random_bits);

	if (size & BUILDING_HAS_4_TILES) ClearMakeHouseTile(t + TileDiffXY(1, 1), town, counter, stage, ++type, random_bits);

}

/**

 * Checks if a house can be built here. Important is slope, bridge above

 * and ability to clear the land.

 * @param tile tile to check

 * @param noslope are slopes (foundations) allowed?

 * @return true iff house can be built here

 */

static inline bool CanBuildHouseHere(TileIndex tile, bool noslope)

{