} else if (st->dock_tile != INVALID_TILE) {

				return st->dock_tile;

			} else if (st->bus_stops != NULL) {

				return st->bus_stops->xy;

			} else if (st->truck_stops != NULL) {

				return st->truck_stops->xy;

				}

			}

			return INVALID_TILE;

		}

		case OT_GOTO_WAYPOINT: {

					(avi->subtype & AIR_FAST) &&

					!_cheats.no_jetcrash.value)) {

			continue;

		}

		/* v->tile can't be used here, when aircraft is flying v->tile is set to 0 */

		if (distance < best || index == INVALID_STATION) {

			best = distance;

			index = st->index;

		}

	}

	return index;

	 * or it will simply crash in next tick */

	TileIndex tile = 0;

	const Station *st = Station::GetIfValid(v->targetairport);

	if (st != NULL) {

		/* Make sure we don't go to INVALID_TILE if the airport has been removed. */

	}

	int delta_x = v->x_pos - TileX(tile) * TILE_SIZE;

	int delta_y = v->y_pos - TileY(tile) * TILE_SIZE;

	DiagDirection dir;

	/* NULL if station is invalid */

	const Station *st = Station::GetIfValid(v->targetairport);

	/* INVALID_TILE if there is no station */

	TileIndex tile = INVALID_TILE;

	if (st != NULL) {

	}

	/* DUMMY if there is no station or no airport */

	const AirportFTAClass *afc = tile == INVALID_TILE ? GetAirport(AT_DUMMY) : st->Airport();

	/* prevent going to INVALID_TILE if airport is deleted. */

		/* Jump into our "holding pattern" state machine if possible */

		if (v->pos >= afc->nofelements) {

			v->pos = v->previous_pos = AircraftGetEntryPoint(v, afc);

		} else if (v->targetairport != v->current_order.GetDestination()) {

			/* If not possible, just get out of here fast */

			v->state = FLYING;

					v->x_pos + ((x + amd->x > v->x_pos) ? 1 : -1) :

					v->x_pos;

			gp.y = (v->y_pos != (y + amd->y)) ?

					v->y_pos + ((y + amd->y > v->y_pos) ? 1 : -1) :

					v->y_pos;

		} else {

			/* Turn. Do it slowly if in the air. */

			Direction newdir = GetDirectionTowards(v, x + amd->x, y + amd->y);

			if (newdir != v->direction) {

			z = min(z + 2, GetAircraftFlyingAltitude(v));

		}

		if ((amd->flag & AMED_HOLD) && (z > 150)) z--;

		if (amd->flag & AMED_LAND) {

				/* Airport has been removed, abort the landing procedure */

				v->state = FLYING;

				UpdateAircraftCache(v);

				AircraftNextAirportPos_and_Order(v);

				/* get aircraft back on running altitude */

				SetAircraftPosition(v, gp.x, gp.y, GetAircraftFlyingAltitude(v));

static void AircraftEventHandler_Flying(Aircraft *v, const AirportFTAClass *apc)

{

	Station *st = Station::Get(v->targetairport);

	/* runway busy or not allowed to use this airstation, circle */

	if ((apc->flags & (v->subtype == AIR_HELICOPTER ? AirportFTAClass::HELICOPTERS : AirportFTAClass::AIRPLANES)) &&

			(st->owner == OWNER_NONE || st->owner == v->owner)) {

		/* {32,FLYING,NOTHING_block,37}, {32,LANDING,N,33}, {32,HELILANDING,N,41},

		 * if it is an airplane, look for LANDING, for helicopter HELILANDING

		 * it is possible to choose from multiple landing runways, so loop until a free one is found */

		byte landingtype = (v->subtype == AIR_HELICOPTER) ? HELILANDING : LANDING;

		const AirportFTA *current = apc->layout[v->pos].next;

{

	assert(v->type == VEH_AIRCRAFT);

	Station *st = Station::GetIfValid(v->targetairport);

	if (st == NULL) return NULL;

}

/**

 * Updates the status of the Aircraft heading or in the station

 * @param st Station been updated

 */

	/* Pick a random place, unless we find a small airport */

	int x = TileX(Random()) * TILE_SIZE + TILE_SIZE / 2;

	Station *st;

	FOR_ALL_STATIONS(st) {

			break;

		}

	}

	DisasterVehicle *v = new DisasterVehicle();

	InitializeDisasterVehicle(v, x, 0, 135, DIR_SE, ST_ZEPPELINER);

		case 0x41: return GetTerrainType(tile);

		/* Current town zone of the tile in the nearest town */

		case 0x42: return GetTownRadiusGroup(ClosestTownFromTile(tile, UINT_MAX), tile);

		/* Position relative to most northern airport tile. */

		/* Animation frame of tile */

		case 0x44: return GetStationAnimationFrame(tile);

		/* Land info of nearby tiles */

		case 0x60: return GetNearbyAirportTileInformation(parameter, tile, st->index);

	ChangeAirportTileAnimationFrame(ats, tile, trigger, gfx, st);

	return;

}

void AirportAnimationTrigger(Station *st, AirpAnimationTrigger trigger, CargoID cargo_type)

{

	const AirportSpec *as = st->GetAirportSpec();

		if (st->TileBelongsToAirport(tile)) AirportTileAnimationTrigger(st, tile, trigger, cargo_type);

	}

}

	ResetOldNames();

	if (CheckSavegameVersion(106)) {

		/* no station is determined by 'tile == INVALID_TILE' now (instead of '0') */

		Station *st;

		FOR_ALL_STATIONS(st) {

			if (st->dock_tile          == 0) st->dock_tile    = INVALID_TILE;

			if (st->train_station.tile == 0) st->train_station.tile   = INVALID_TILE;

		}

		/* the same applies to Company::location_of_HQ */

		Company *c;

					offset += atc[i].num_frames - 1;

				}

			}

		}

	}

	/* Road stops is 'only' updating some caches */

	AfterLoadRoadStops();

	AfterLoadLabelMaps();

	GamelogPrintDebug(1);

static const OldChunks station_chunk[] = {

	OCL_SVAR(   OC_TILE, Station, xy ),

	OCL_VAR ( OC_UINT32,   1, &_old_town_index ),

	OCL_NULL( 4 ), ///< bus/lorry tile

	OCL_SVAR(   OC_TILE, Station, train_station.tile ),

	OCL_SVAR(   OC_TILE, Station, dock_tile ),

	OCL_SVAR(  OC_UINT8, Station, train_station.w ),

	OCL_NULL( 1 ),         ///< sort-index, no longer in use

	OCL_NULL( 2 ),         ///< sign-width, no longer in use

static const SaveLoad _old_station_desc[] = {

	SLE_CONDVAR(Station, xy,                         SLE_FILE_U16 | SLE_VAR_U32,  0, 5),

	SLE_CONDVAR(Station, xy,                         SLE_UINT32,                  6, SL_MAX_VERSION),

	SLE_CONDNULL(4, 0, 5),  ///< bus/lorry tile

	SLE_CONDVAR(Station, train_station.tile,         SLE_FILE_U16 | SLE_VAR_U32,  0, 5),

	SLE_CONDVAR(Station, train_station.tile,         SLE_UINT32,                  6, SL_MAX_VERSION),

	SLE_CONDVAR(Station, dock_tile,                  SLE_FILE_U16 | SLE_VAR_U32,  0, 5),

	SLE_CONDVAR(Station, dock_tile,                  SLE_UINT32,                  6, SL_MAX_VERSION),

	    SLE_REF(Station, town,                       REF_TOWN),

	    SLE_VAR(Station, train_station.w,            SLE_UINT8),

	SLE_CONDVAR(Station, train_station.h,            SLE_UINT8,                   2, SL_MAX_VERSION),

	      SLE_VAR(Station, train_station.w,            SLE_UINT8),

	      SLE_VAR(Station, train_station.h,            SLE_UINT8),

	      SLE_REF(Station, bus_stops,                  REF_ROADSTOPS),

	      SLE_REF(Station, truck_stops,                REF_ROADSTOPS),

	      SLE_VAR(Station, dock_tile,                  SLE_UINT32),

	      SLE_VAR(Station, airport_type,               SLE_UINT8),

	      SLE_VAR(Station, airport_flags,              SLE_UINT64),

	      SLE_VAR(Station, indtype,                    SLE_UINT8),

	      SLE_VAR(Station, time_since_load,            SLE_UINT8),

}

Station::Station(TileIndex tile) :

	SpecializedStation<Station, false>(tile),

	bus_station(INVALID_TILE, 0, 0),

	truck_station(INVALID_TILE, 0, 0),

	dock_tile(INVALID_TILE),

	indtype(IT_INVALID),

	time_since_load(255),

	time_since_unload(255),

	last_vehicle_type(VEH_INVALID)

{

	if (_settings_game.station.modified_catchment) {

		if (this->bus_stops          != NULL)         ret = max<uint>(ret, CA_BUS);

		if (this->truck_stops        != NULL)         ret = max<uint>(ret, CA_TRUCK);

		if (this->train_station.tile != INVALID_TILE) ret = max<uint>(ret, CA_TRAIN);

		if (this->dock_tile          != INVALID_TILE) ret = max<uint>(ret, CA_DOCK);

	} else {

			ret = CA_UNMODIFIED;

		}

	}

	return ret;

}

	}

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

	const AirportFTAClass *Airport() const

	{

		return GetAirport(airport_type);

	}

	const AirportSpec *GetAirportSpec() const

	{

		return AirportSpec::Get(this->airport_type);

	}

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

	TileArea bus_station;   ///< Tile area the bus 'station' part covers

	RoadStop *truck_stops;  ///< All the truck stops

	TileArea truck_station; ///< Tile area the truck 'station' part covers

	TileIndex dock_tile;    ///< The location of the dock

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

	StationHadVehicleOfTypeByte had_vehicle_of_type;

	{

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

	}

	FORCEINLINE TileIndex GetHangarTile(uint hangar_num) const

	{

		assert(hangar_num < this->GetAirportSpec()->nof_depots);

	}

	/* virtual */ uint32 GetNewGRFVariable(const ResolverObject *object, byte variable, byte parameter, bool *available) const;

	/* virtual */ void GetTileArea(TileArea *ta, StationType type) const;

};

	switch (type) {

		case STATION_RAIL:

			*ta = this->train_station;

			return;

		case STATION_AIRPORT:

			return;

		case STATION_TRUCK:

			*ta = this->truck_station;

			return;

}

/**

 * Computes the minimal distance from town's xy to any airport's tile.

 * @param as airport's description

 * @param town_tile town's tile (t->xy)

 * @return minimal manhattan distance from town_tile to any airport's tile

 */

static uint GetMinimalAirportDistanceToTile(const AirportSpec *as, TileIndex town_tile, TileIndex airport_tile)

{

	uint ttx = TileX(town_tile); // X, Y of town

	uint tty = TileY(town_tile);

}

/**

 * Finds the town nearest to given airport. Based on minimal manhattan distance to any airport's tile.

 * If two towns have the same distance, town with lower index is returned.

 * @param as airport's description

 * @return nearest town to airport

 */

Town *AirportGetNearestTown(const AirportSpec *as, TileIndex airport_tile)

{

	Town *t, *nearest = NULL;

	uint add = as->size_x + as->size_y - 2; // GetMinimalAirportDistanceToTile can differ from DistanceManhattan by this much

	Town *t;

	const Station *st;

	FOR_ALL_TOWNS(t) t->noise_reached = 0;

	FOR_ALL_STATIONS(st) {

			const AirportSpec *as = st->GetAirportSpec();

		}

	}

}

/** Place an Airport.

 * @param tile tile where airport will be built

		if (st->owner != _current_company) {

			return_cmd_error(STR_ERROR_TOO_CLOSE_TO_ANOTHER_STATION);

		}

		if (!st->rect.BeforeAddRect(tile, w, h, StationRect::ADD_TEST)) return CMD_ERROR;

			return_cmd_error(STR_ERROR_TOO_CLOSE_TO_ANOTHER_AIRPORT);

		}

	} else {

		airport_upgrade = false;

		/* allocate and initialize new station */

	cost.AddCost(_price[PR_BUILD_STATION_AIRPORT] * w * h);

	if (flags & DC_EXEC) {

		/* Always add the noise, so there will be no need to recalculate when option toggles */

		nearest->noise_reached += newnoise_level;

		st->AddFacility(FACIL_AIRPORT, tile);

		st->airport_type = (byte)p1;

		st->airport_flags = 0;

		st->rect.BeforeAddRect(tile, w, h, StationRect::ADD_TRY);

		if (airport_upgrade) UpdateAirplanesOnNewStation(st);

		const AirportTileTable *it = as->table[0];

		do {

			TileIndex cur_tile = tile + ToTileIndexDiff(it->ti);

			MakeAirport(cur_tile, st->owner, st->index, it->gfx);

			if (AirportTileSpec::Get(GetTranslatedAirportTileID(it->gfx))->animation_info != 0xFFFF) AddAnimatedTile(cur_tile);

		} while ((++it)->ti.x != -0x80);

		/* Only call the animation trigger after all tiles have been built */

		it = as->table[0];

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

	if (_current_company != OWNER_WATER && !CheckOwnership(st->owner)) {

		return CMD_ERROR;

	}

	const AirportSpec *as = st->GetAirportSpec();

	int w = as->size_x;

	int h = as->size_y;

	CommandCost cost(EXPENSES_CONSTRUCTION);

	const Aircraft *a;

	FOR_ALL_AIRCRAFT(a) {

		if (!a->IsNormalAircraft()) continue;

		if (a->targetairport == st->index && a->state != FLYING) return CMD_ERROR;

	}

		if (!EnsureNoVehicleOnGround(tile_cur)) return CMD_ERROR;

		cost.AddCost(_price[PR_CLEAR_STATION_AIRPORT]);

		if (flags & DC_EXEC) {

			DeleteAnimatedTile(tile_cur);

			DoClearSquare(tile_cur);

		}

		 * need of recalculation */

		Town *nearest = AirportGetNearestTown(as, tile);

		nearest->noise_reached -= GetAirportNoiseLevelForTown(as, nearest->xy, tile);

		st->rect.AfterRemoveRect(st, tile, w, h);

		st->facilities &= ~FACIL_AIRPORT;

		SetWindowWidgetDirty(WC_STATION_VIEW, st->index, SVW_PLANES);

		if (_settings_game.economy.station_noise_level) {

			SetWindowDirty(WC_TOWN_VIEW, st->town->index);

	assert(IsTileType(tile, MP_INDUSTRY));

	DeleteAnimatedTile(tile);

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

	st->owner = OWNER_NONE;

	st->airport_type = AT_OILRIG;

	st->dock_tile = tile;

	st->facilities = FACIL_AIRPORT | FACIL_DOCK;

	st->build_date = _date;

	st->rect.BeforeAddTile(tile, StationRect::ADD_FORCE);

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

	MakeWaterKeepingClass(tile, OWNER_NONE);

	MarkTileDirtyByTile(tile);

	st->dock_tile = INVALID_TILE;

	st->facilities &= ~(FACIL_AIRPORT | FACIL_DOCK);

	st->airport_flags = 0;

	st->rect.AfterRemoveTile(st, tile);

	st->UpdateVirtCoord();

		const Station *st;

		FOR_ALL_STATIONS(st) {

			if (st->town == this->town) {

				/* Non-oil rig stations are always a problem. */

				if (!(st->facilities & FACIL_AIRPORT) || st->airport_type != AT_OILRIG) return false;

				/* We can only automatically delete oil rigs *if* there's no vehicle on them. */

			}

		}

		/* Depots refer to towns. */

		const Depot *d;

		FOR_ALL_DEPOTS(d) {

	byte z = 0;

	if (IsAirportTile(tile)) {

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

		const AirportSpec *as = st->GetAirportSpec();

		z = 1 + st->Airport()->delta_z;

		}

		/* No vehicle could be flooded on this airport anymore */

		return;

	}