tron@2186: /* $Id$ */
tron@2186: 
belugas@6443: /** @file aircraft_cmd.cpp
belugas@6443:  * This file deals with aircraft and airport movements functionalities */
belugas@6443: 
truelight@0: #include "stdafx.h"
Darkvater@1891: #include "openttd.h"
tron@3963: #include "aircraft.h"
tron@1299: #include "debug.h"
tron@2163: #include "functions.h"
tron@3315: #include "station_map.h"
tron@507: #include "table/strings.h"
tron@679: #include "map.h"
tron@1209: #include "tile.h"
truelight@0: #include "vehicle.h"
Darkvater@1790: #include "depot.h"
truelight@0: #include "engine.h"
truelight@0: #include "command.h"
truelight@0: #include "station.h"
truelight@0: #include "news.h"
tron@337: #include "sound.h"
truelight@0: #include "player.h"
Darkvater@6105: #include "aircraft.h"
truelight@0: #include "airport.h"
matthijs@1752: #include "vehicle_gui.h"
tron@2517: #include "table/sprites.h"
peter1138@2962: #include "newgrf_engine.h"
peter1138@3973: #include "newgrf_callbacks.h"
peter1138@4244: #include "newgrf_text.h"
peter1138@4656: #include "newgrf_sound.h"
rubidium@4261: #include "date.h"
bjarni@6223: #include "spritecache.h"
truelight@0: 
belugas@6449: /** this maps the terminal to its corresponding state and block flag
belugas@6449:  *  currently set for 10 terms, 4 helipads */
truelight@6005: static const byte _airport_terminal_state[] = {2, 3, 4, 5, 6, 7, 19, 20, 0, 0, 8, 9, 21, 22};
truelight@6005: static const byte _airport_terminal_flag[] =  {0, 1, 2, 3, 4, 5, 22, 23, 0, 0, 6, 7, 24, 25};
truelight@6005: 
Darkvater@4842: static bool AirportMove(Vehicle *v, const AirportFTAClass *apc);
tron@6413: static bool AirportSetBlocks(Vehicle *v, const AirportFTA *current_pos, const AirportFTAClass *apc);
Darkvater@4843: static bool AirportHasBlock(Vehicle *v, const AirportFTA *current_pos, const AirportFTAClass *apc);
Darkvater@4842: static bool AirportFindFreeTerminal(Vehicle *v, const AirportFTAClass *apc);
Darkvater@4842: static bool AirportFindFreeHelipad(Vehicle *v, const AirportFTAClass *apc);
dominik@899: static void CrashAirplane(Vehicle *v);
truelight@0: 
truelight@0: static void AircraftNextAirportPos_and_Order(Vehicle *v);
truelight@0: static byte GetAircraftFlyingAltitude(const Vehicle *v);
truelight@0: 
truelight@0: static const SpriteID _aircraft_sprite[] = {
truelight@0: 	0x0EB5, 0x0EBD, 0x0EC5, 0x0ECD,
truelight@0: 	0x0ED5, 0x0EDD, 0x0E9D, 0x0EA5,
truelight@0: 	0x0EAD, 0x0EE5, 0x0F05, 0x0F0D,
truelight@0: 	0x0F15, 0x0F1D, 0x0F25, 0x0F2D,
truelight@0: 	0x0EED, 0x0EF5, 0x0EFD, 0x0F35,
truelight@0: 	0x0E9D, 0x0EA5, 0x0EAD, 0x0EB5,
truelight@0: 	0x0EBD, 0x0EC5
truelight@0: };
truelight@0: 
belugas@6449: /** Helicopter rotor animation states */
peter1138@3710: enum HelicopterRotorStates {
peter1138@3710: 	HRS_ROTOR_STOPPED,
peter1138@3710: 	HRS_ROTOR_MOVING_1,
peter1138@3710: 	HRS_ROTOR_MOVING_2,
peter1138@3710: 	HRS_ROTOR_MOVING_3,
peter1138@3710: };
peter1138@3710: 
belugas@6449: /** Find the nearest hangar to v
tron@1532:  * INVALID_STATION is returned, if the player does not have any suitable
tron@1532:  * airports (like helipads only)
belugas@6449:  * @param v vehicle looking for a hangar
belugas@6449:  * @return the StationID if one is found, otherwise, INVALID_STATION
tron@1532:  */
Darkvater@1793: static StationID FindNearestHangar(const Vehicle *v)
bjarni@1194: {
tron@1532: 	const Station *st;
tron@1532: 	uint best = 0;
Darkvater@1793: 	StationID index = INVALID_STATION;
Darkvater@4284: 	TileIndex vtile = TileVirtXY(v->x_pos, v->y_pos);
bjarni@1194: 
bjarni@1194: 	FOR_ALL_STATIONS(st) {
tron@6351: 		if (st->owner != v->owner || !(st->facilities & FACIL_AIRPORT)) continue;
bjarni@1204: 
tron@6358: 		const AirportFTAClass *afc = st->Airport();
tron@6351: 		if (afc->nof_depots == 0 || (
tron@6351: 					/* don't crash the plane if we know it can't land at the airport */
tron@6351: 					afc->flags & AirportFTAClass::SHORT_STRIP &&
tron@6351: 					AircraftVehInfo(v->engine_type)->subtype & AIR_FAST &&
tron@6351: 					!_cheats.no_jetcrash.value
tron@6351: 				)) {
tron@6351: 			continue;
tron@6351: 		}
tron@1532: 
belugas@6449: 		/* v->tile can't be used here, when aircraft is flying v->tile is set to 0 */
tron@6351: 		uint distance = DistanceSquare(vtile, st->airport_tile);
tron@6351: 		if (distance < best || index == INVALID_STATION) {
tron@6351: 			best = distance;
tron@6351: 			index = st->index;
bjarni@1194: 		}
bjarni@1194: 	}
tron@1532: 	return index;
bjarni@1194: }
bjarni@1194: 
Darkvater@1614: #if 0
belugas@6449: /** Check if given vehicle has a goto hangar in his orders
belugas@6449:  * @param v vehicle to inquiry
belugas@6449:  * @return true if vehicle v has an airport in the schedule, that has a hangar */
bjarni@1194: static bool HaveHangarInOrderList(Vehicle *v)
bjarni@1194: {
bjarni@1194: 	const Order *order;
bjarni@1194: 
bjarni@1194: 	FOR_VEHICLE_ORDERS(v, order) {
bjarni@1194: 		const Station *st = GetStation(order->station);
bjarni@1194: 		if (st->owner == v->owner && st->facilities & FACIL_AIRPORT) {
belugas@6449: 			/* If an airport doesn't have a hangar, skip it */
tron@6358: 			if (st->Airport()->nof_depots != 0)
bjarni@1194: 				return true;
bjarni@1194: 		}
bjarni@1194: 	}
bjarni@1194: 
bjarni@1194: 	return false;
bjarni@1194: }
Darkvater@1614: #endif
bjarni@1194: 
tron@3157: int GetAircraftImage(const Vehicle* v, Direction direction)
truelight@0: {
truelight@0: 	int spritenum = v->spritenum;
truelight@0: 
truelight@0: 	if (is_custom_sprite(spritenum)) {
truelight@0: 		int sprite = GetCustomVehicleSprite(v, direction);
truelight@0: 
tron@2989: 		if (sprite != 0) return sprite;
peter1138@2464: 		spritenum = orig_aircraft_vehicle_info[v->engine_type - AIRCRAFT_ENGINES_INDEX].image_index;
truelight@0: 	}
truelight@0: 	return direction + _aircraft_sprite[spritenum];
truelight@0: }
truelight@0: 
peter1138@3710: SpriteID GetRotorImage(const Vehicle *v)
peter1138@3710: {
Darkvater@6105: 	assert(v->subtype == AIR_HELICOPTER);
peter1138@3710: 
tron@6413: 	const Vehicle *w = v->next->next;
peter1138@3710: 	if (is_custom_sprite(v->spritenum)) {
peter1138@4056: 		SpriteID spritenum = GetCustomRotorSprite(v, false);
peter1138@3710: 		if (spritenum != 0) return spritenum;
peter1138@3710: 	}
peter1138@3710: 
peter1138@3710: 	/* Return standard rotor sprites if there are no custom sprites for this helicopter */
peter1138@3710: 	return SPR_ROTOR_STOPPED + w->u.air.state;
peter1138@3710: }
peter1138@3710: 
peter1138@5919: void DrawAircraftEngine(int x, int y, EngineID engine, SpriteID pal)
truelight@0: {
tron@4023: 	const AircraftVehicleInfo* avi = AircraftVehInfo(engine);
tron@4023: 	int spritenum = avi->image_index;
peter1138@5919: 	SpriteID sprite = (6 + _aircraft_sprite[spritenum]);
truelight@0: 
darkvater@381: 	if (is_custom_sprite(spritenum)) {
tron@3186: 		sprite = GetCustomVehicleIcon(engine, DIR_W);
peter1138@5012: 		if (sprite == 0) {
peter1138@2464: 			spritenum = orig_aircraft_vehicle_info[engine - AIRCRAFT_ENGINES_INDEX].image_index;
peter1138@5012: 			sprite = (6 + _aircraft_sprite[spritenum]);
peter1138@5012: 		}
darkvater@381: 	}
darkvater@381: 
peter1138@5919: 	DrawSprite(sprite, pal, x, y);
darkvater@381: 
tron@4023: 	if (!(avi->subtype & AIR_CTOL)) {
peter1138@3710: 		SpriteID rotor_sprite = GetCustomRotorIcon(engine);
peter1138@3710: 		if (rotor_sprite == 0) rotor_sprite = SPR_ROTOR_STOPPED;
peter1138@5919: 		DrawSprite(rotor_sprite, PAL_NONE, x, y - 5);
dominik@1200: 	}
truelight@0: }
truelight@0: 
bjarni@6223: /** Get the size of the sprite of an aircraft sprite heading west (used for lists)
bjarni@6223:  * @param engine The engine to get the sprite from
bjarni@6223:  * @param &width The width of the sprite
bjarni@6223:  * @param &height The height of the sprite
bjarni@6223:  */
bjarni@6223: void GetAircraftSpriteSize(EngineID engine, uint &width, uint &height)
bjarni@6223: {
bjarni@6223: 	const AircraftVehicleInfo* avi = AircraftVehInfo(engine);
bjarni@6223: 	int spritenum = avi->image_index;
bjarni@6223: 	SpriteID sprite = (6 + _aircraft_sprite[spritenum]);
bjarni@6223: 
bjarni@6223: 	if (is_custom_sprite(spritenum)) {
bjarni@6223: 		sprite = GetCustomVehicleIcon(engine, DIR_W);
bjarni@6223: 		if (sprite == 0) {
bjarni@6223: 			spritenum = orig_aircraft_vehicle_info[engine - AIRCRAFT_ENGINES_INDEX].image_index;
bjarni@6223: 			sprite = (6 + _aircraft_sprite[spritenum]);
bjarni@6223: 		}
bjarni@6223: 	}
bjarni@6223: 
bjarni@6223: 	const Sprite *spr = GetSprite(sprite);
bjarni@6223: 
bjarni@6223: 	width  = spr->width ;
bjarni@6223: 	height = spr->height;
bjarni@6223: }
bjarni@6223: 
tron@6171: static int32 EstimateAircraftCost(const AircraftVehicleInfo *avi)
truelight@0: {
tron@6171: 	return avi->base_cost * (_price.aircraft_base >> 3) >> 5;
truelight@0: }
truelight@0: 
truelight@0: 
peter1138@3973: /**
peter1138@3973:  * Calculates cargo capacity based on an aircraft's passenger
peter1138@3973:  * and mail capacities.
peter1138@3973:  * @param cid Which cargo type to calculate a capacity for.
peter1138@3973:  * @param engine Which engine to find a cargo capacity for.
peter1138@3973:  * @return New cargo capacity value.
peter1138@3973:  */
tron@6413: uint16 AircraftDefaultCargoCapacity(CargoID cid, const AircraftVehicleInfo *avi)
peter1138@3973: {
peter1138@3973: 	assert(cid != CT_INVALID);
peter1138@3973: 
peter1138@3973: 	/* An aircraft can carry twice as much goods as normal cargo,
peter1138@3973: 	 * and four times as many passengers. */
peter1138@3973: 	switch (cid) {
peter1138@3973: 		case CT_PASSENGERS:
peter1138@3973: 			return avi->passenger_capacity;
peter1138@3973: 		case CT_MAIL:
peter1138@3973: 			return avi->passenger_capacity + avi->mail_capacity;
peter1138@3973: 		case CT_GOODS:
peter1138@3973: 			return (avi->passenger_capacity + avi->mail_capacity) / 2;
peter1138@3973: 		default:
peter1138@3973: 			return (avi->passenger_capacity + avi->mail_capacity) / 4;
peter1138@3973: 	}
peter1138@3973: }
peter1138@3973: 
peter1138@3973: 
Darkvater@1793: /** Build an aircraft.
tron@3491:  * @param tile tile of depot where aircraft is built
belugas@6449:  * @param flags for command
Darkvater@1793:  * @param p1 aircraft type being built (engine)
bjarni@3816:  * @param p2 bit 0 when set, the unitnumber will be 0, otherwise it will be a free number
belugas@6449:  * return result of operation.  Could be cost, error
Darkvater@1793:  */
tron@3491: int32 CmdBuildAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
peter1138@5215: 	if (!IsEngineBuildable(p1, VEH_Aircraft, _current_player)) return_cmd_error(STR_ENGINE_NOT_BUILDABLE);
bjarni@1196: 
tron@6171: 	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);
tron@6171: 	int32 value = EstimateAircraftCost(avi);
bjarni@1226: 
belugas@6449: 	/* to just query the cost, it is not neccessary to have a valid tile (automation/AI) */
Darkvater@2423: 	if (flags & DC_QUERY_COST) return value;
Darkvater@2423: 
tron@3338: 	if (!IsHangarTile(tile) || !IsTileOwner(tile, _current_player)) return CMD_ERROR;
bjarni@1226: 
truelight@0: 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
truelight@0: 
belugas@6449: 	/* Prevent building aircraft types at places which can't handle them */
tron@6170: 	const Station* st = GetStationByTile(tile);
tron@6358: 	const AirportFTAClass* apc = st->Airport();
KUDr@6353: 	if (!(apc->flags & (avi->subtype & AIR_CTOL ? AirportFTAClass::AIRPLANES : AirportFTAClass::HELICOPTERS))) {
tron@4161: 		return CMD_ERROR;
tron@4161: 	}
tron@4161: 
Darkvater@6105: 	/* Allocate 2 or 3 vehicle structs, depending on type
Darkvater@6105: 	 * vl[0] = aircraft, vl[1] = shadow, [vl[2] = rotor] */
tron@6413: 	Vehicle *vl[3];
tron@6173: 	if (!AllocateVehicles(vl, avi->subtype & AIR_CTOL ? 2 : 3)) {
tron@2639: 		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
tron@2639: 	}
truelight@0: 
tron@6413: 	UnitID unit_num = HASBIT(p2, 0) ? 0 : GetFreeUnitNumber(VEH_Aircraft);
truelight@0: 	if (unit_num > _patches.max_aircraft)
truelight@0: 		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
truelight@0: 
truelight@0: 	if (flags & DC_EXEC) {
Darkvater@6105: 		Vehicle *v = vl[0]; // aircraft
Darkvater@6105: 		Vehicle *u = vl[1]; // shadow
truelight@0: 
truelight@0: 		v->unitnumber = unit_num;
truelight@0: 		v->type = u->type = VEH_Aircraft;
rubidium@5838: 		v->direction = DIR_SE;
truelight@0: 
truelight@0: 		v->owner = u->owner = _current_player;
truelight@0: 
truelight@0: 		v->tile = tile;
truelight@0: //		u->tile = 0;
truelight@0: 
tron@6413: 		uint x = TileX(tile) * TILE_SIZE + 5;
tron@6413: 		uint y = TileY(tile) * TILE_SIZE + 3;
truelight@0: 
truelight@0: 		v->x_pos = u->x_pos = x;
truelight@0: 		v->y_pos = u->y_pos = y;
truelight@0: 
truelight@0: 		u->z_pos = GetSlopeZ(x, y);
truelight@0: 		v->z_pos = u->z_pos + 1;
truelight@0: 
truelight@0: 		v->x_offs = v->y_offs = -1;
truelight@0: //		u->delta_x = u->delta_y = 0;
truelight@0: 
truelight@0: 		v->sprite_width = v->sprite_height = 2;
truelight@0: 		v->z_height = 5;
truelight@0: 
truelight@0: 		u->sprite_width = u->sprite_height = 2;
truelight@0: 		u->z_height = 1;
truelight@0: 
truelight@0: 		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;
tron@4175: 		u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_SHADOW;
truelight@0: 
tron@538: 		v->spritenum = avi->image_index;
truelight@0: //		v->cargo_count = u->number_of_pieces = 0;
truelight@0: 
celestar@922: 		v->cargo_cap = avi->passenger_capacity;
tron@538: 		u->cargo_cap = avi->mail_capacity;
truelight@0: 
truelight@0: 		v->cargo_type = CT_PASSENGERS;
truelight@0: 		u->cargo_type = CT_MAIL;
truelight@0: 
peter1138@3870: 		v->cargo_subtype = 0;
peter1138@3870: 
truelight@0: 		v->string_id = STR_SV_AIRCRAFT_NAME;
truelight@0: //		v->next_order_param = v->next_order = 0;
truelight@0: 
truelight@0: //		v->load_unload_time_rem = 0;
truelight@0: //		v->progress = 0;
truelight@1266: 		v->last_station_visited = INVALID_STATION;
truelight@0: //		v->destination_coords = 0;
truelight@0: 
tron@538: 		v->max_speed = avi->max_speed;
tron@538: 		v->acceleration = avi->acceleration;
tron@2477: 		v->engine_type = p1;
truelight@0: 
Darkvater@6105: 		v->subtype = (avi->subtype & AIR_CTOL ? AIR_AIRCRAFT : AIR_HELICOPTER);
truelight@0: 		v->value = value;
truelight@0: 
Darkvater@6105: 		u->subtype = AIR_SHADOW;
truelight@0: 
peter1138@3973: 		/* Danger, Will Robinson!
peter1138@3973: 		 * If the aircraft is refittable, but cannot be refitted to
peter1138@3973: 		 * passengers, we select the cargo type from the refit mask.
peter1138@3973: 		 * This is a fairly nasty hack to get around the fact that TTD
peter1138@3973: 		 * has no default cargo type specifier for planes... */
tron@6413: 		CargoID cargo = FindFirstRefittableCargo(p1);
peter1138@3973: 		if (cargo != CT_INVALID && cargo != CT_PASSENGERS) {
peter1138@3973: 			uint16 callback = CALLBACK_FAILED;
peter1138@3973: 
peter1138@3973: 			v->cargo_type = cargo;
peter1138@3973: 
peter1138@3973: 			if (HASBIT(EngInfo(p1)->callbackmask, CBM_REFIT_CAPACITY)) {
peter1138@3973: 				callback = GetVehicleCallback(CBID_VEHICLE_REFIT_CAPACITY, 0, 0, v->engine_type, v);
peter1138@3973: 			}
peter1138@3973: 
peter1138@3973: 			if (callback == CALLBACK_FAILED) {
peter1138@3973: 				/* Callback failed, or not executed; use the default cargo capacity */
tron@6413: 				v->cargo_cap = AircraftDefaultCargoCapacity(v->cargo_type, avi);
peter1138@3973: 			} else {
peter1138@3973: 				v->cargo_cap = callback;
peter1138@3973: 			}
peter1138@3973: 
peter1138@3973: 			/* Set the 'second compartent' capacity to none */
peter1138@3973: 			u->cargo_cap = 0;
peter1138@3973: 		}
peter1138@3973: 
Darkvater@6105: 		const Engine *e = GetEngine(p1);
truelight@0: 		v->reliability = e->reliability;
truelight@0: 		v->reliability_spd_dec = e->reliability_spd_dec;
truelight@0: 		v->max_age = e->lifelength * 366;
truelight@0: 
bjarni@2564: 		_new_vehicle_id = v->index;
truelight@0: 
Darkvater@2423: 		/* When we click on hangar we know the tile it is on. By that we know
Darkvater@2423: 		 * its position in the array of depots the airport has.....we can search
Darkvater@2423: 		 * layout for #th position of depot. Since layout must start with a listing
Darkvater@2423: 		 * of all depots, it is simple */
tron@6172: 		for (uint i = 0;; i++) {
tron@6172: 			assert(i != apc->nof_depots);
tron@6172: 			if (st->airport_tile + ToTileIndexDiff(apc->airport_depots[i]) == tile) {
tron@6172: 				assert(apc->layout[i].heading == HANGAR);
tron@6172: 				v->u.air.pos = apc->layout[i].position;
tron@6172: 				break;
truelight@0: 			}
truelight@0: 		}
truelight@0: 
truelight@0: 		v->u.air.state = HANGAR;
truelight@0: 		v->u.air.previous_pos = v->u.air.pos;
tron@3315: 		v->u.air.targetairport = GetStationIndex(tile);
truelight@0: 		v->next = u;
truelight@0: 
truelight@0: 		v->service_interval = _patches.servint_aircraft;
truelight@0: 
truelight@0: 		v->date_of_last_service = _date;
rubidium@4329: 		v->build_year = u->build_year = _cur_year;
truelight@0: 
truelight@0: 		v->cur_image = u->cur_image = 0xEA0;
truelight@0: 
peter1138@2804: 		v->random_bits = VehicleRandomBits();
peter1138@2804: 		u->random_bits = VehicleRandomBits();
peter1138@2804: 
maedhros@6502: 		v->vehicle_flags = 0;
maedhros@6502: 		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SETBIT(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
maedhros@6502: 
truelight@0: 		VehiclePositionChanged(v);
truelight@0: 		VehiclePositionChanged(u);
truelight@0: 
belugas@6449: 		/* Aircraft with 3 vehicles (chopper)? */
Darkvater@6105: 		if (v->subtype == AIR_HELICOPTER) {
Darkvater@6105: 			Vehicle *w = vl[2];
truelight@0: 
truelight@0: 			u->next = w;
truelight@0: 
truelight@0: 			w->type = VEH_Aircraft;
rubidium@5838: 			w->direction = DIR_N;
truelight@0: 			w->owner = _current_player;
truelight@0: 			w->x_pos = v->x_pos;
truelight@0: 			w->y_pos = v->y_pos;
truelight@0: 			w->z_pos = v->z_pos + 5;
truelight@0: 			w->x_offs = w->y_offs = -1;
truelight@0: 			w->sprite_width = w->sprite_height = 2;
truelight@0: 			w->z_height = 1;
truelight@0: 			w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;
peter1138@3710: 			w->spritenum = 0xFF;
Darkvater@6105: 			w->subtype = AIR_ROTOR;
tron@2517: 			w->cur_image = SPR_ROTOR_STOPPED;
peter1138@2804: 			w->random_bits = VehicleRandomBits();
peter1138@3710: 			/* Use rotor's air.state to store the rotor animation frame */
peter1138@3710: 			w->u.air.state = HRS_ROTOR_STOPPED;
truelight@0: 			VehiclePositionChanged(w);
truelight@0: 		}
truelight@0: 
bjarni@4739: 		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
tron@588: 		RebuildVehicleLists();
truelight@0: 		InvalidateWindow(WC_COMPANY, v->owner);
bjarni@2618: 		if (IsLocalPlayer())
bjarni@6195: 			InvalidateAutoreplaceWindow(VEH_Aircraft); //updates the replace Aircraft window
bjarni@6195: 
bjarni@6195: 		GetPlayer(_current_player)->num_engines[p1]++;
truelight@0: 	}
truelight@0: 
truelight@0: 	return value;
truelight@0: }
truelight@0: 
truelight@0: 
tron@410: static void DoDeleteAircraft(Vehicle *v)
truelight@0: {
truelight@0: 	DeleteWindowById(WC_VEHICLE_VIEW, v->index);
tron@588: 	RebuildVehicleLists();
truelight@0: 	InvalidateWindow(WC_COMPANY, v->owner);
bjarni@5256: 	DeleteDepotHighlightOfVehicle(v);
truelight@0: 	DeleteVehicleChain(v);
Celestar@1055: 	InvalidateWindowClasses(WC_AIRCRAFT_LIST);
truelight@0: }
truelight@0: 
Darkvater@1786: /** Sell an aircraft.
tron@3491:  * @param tile unused
belugas@6449:  * @param flags for command type
Darkvater@1786:  * @param p1 vehicle ID to be sold
Darkvater@1786:  * @param p2 unused
belugas@6449:  * @return result of operation.  Error or sold value
Darkvater@1786:  */
tron@3491: int32 CmdSellAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
truelight@4352: 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
truelight@0: 
tron@6413: 	Vehicle *v = GetVehicle(p1);
truelight@0: 
tron@3183: 	if (v->type != VEH_Aircraft || !CheckOwnership(v->owner)) return CMD_ERROR;
tron@3963: 	if (!IsAircraftInHangarStopped(v)) return_cmd_error(STR_A01B_AIRCRAFT_MUST_BE_STOPPED);
truelight@0: 
bjarni@1237: 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
bjarni@1237: 
truelight@0: 	if (flags & DC_EXEC) {
truelight@0: 		// Invalidate depot
truelight@0: 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
truelight@0: 		DoDeleteAircraft(v);
truelight@0: 	}
truelight@0: 
truelight@0: 	return -(int32)v->value;
truelight@0: }
truelight@0: 
Darkvater@1786: /** Start/Stop an aircraft.
tron@3491:  * @param tile unused
belugas@6449:  * @param flags for command type
Darkvater@1793:  * @param p1 aircraft ID to start/stop
Darkvater@1786:  * @param p2 unused
belugas@6449:  * @return result of operation.  Nothing if everything went well
Darkvater@1786:  */
tron@3491: int32 CmdStartStopAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
truelight@4352: 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
bjarni@1237: 
tron@6413: 	Vehicle *v = GetVehicle(p1);
truelight@0: 
Darkvater@1786: 	if (v->type != VEH_Aircraft || !CheckOwnership(v->owner)) return CMD_ERROR;
truelight@0: 
belugas@6449: 	/* cannot stop airplane when in flight, or when taking off / landing */
richk@4059: 	if (v->u.air.state >= STARTTAKEOFF && v->u.air.state < TERM7)
truelight@0: 		return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT);
truelight@0: 
bjarni@4338: 	/* Check if this aircraft can be started/stopped. The callback will fail or
bjarni@4338: 	 * return 0xFF if it can. */
tron@6413: 	uint16 callback = GetVehicleCallback(CBID_VEHICLE_START_STOP_CHECK, 0, 0, v->engine_type, v);
bjarni@4338: 	if (callback != CALLBACK_FAILED && callback != 0xFF) {
bjarni@4338: 		StringID error = GetGRFStringID(GetEngineGRFID(v->engine_type), 0xD000 + callback);
bjarni@4338: 		return_cmd_error(error);
bjarni@4338: 	}
bjarni@4338: 
truelight@0: 	if (flags & DC_EXEC) {
tron@3963: 		if (IsAircraftInHangarStopped(v)) {
tron@3139: 			DeleteVehicleNews(p1, STR_A014_AIRCRAFT_IS_WAITING_IN);
tron@3139: 		}
tron@3139: 
truelight@0: 		v->vehstatus ^= VS_STOPPED;
darkvater@755: 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
truelight@0: 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
Celestar@1055: 		InvalidateWindowClasses(WC_AIRCRAFT_LIST);
truelight@0: 	}
truelight@0: 
truelight@0: 	return 0;
truelight@0: }
truelight@0: 
Darkvater@1793: /** Send an aircraft to the hangar.
tron@3491:  * @param tile unused
belugas@6449:  * @param flags for command type
Darkvater@1793:  * @param p1 vehicle ID to send to the hangar
Darkvater@1793:  * @param p2 various bitmasked elements
bjarni@4506:  * - p2 bit 0-3 - DEPOT_ flags (see vehicle.h)
bjarni@4506:  * - p2 bit 8-10 - VLW flag (for mass goto depot)
belugas@6449:  * @return o if everything went well
Darkvater@1793:  */
tron@3491: int32 CmdSendAircraftToHangar(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
bjarni@4506: 	if (p2 & DEPOT_MASS_SEND) {
bjarni@4506: 		/* Mass goto depot requested */
Darkvater@4546: 		if (!ValidVLWFlags(p2 & VLW_MASK)) return CMD_ERROR;
Darkvater@4546: 		return SendAllVehiclesToDepot(VEH_Aircraft, flags, p2 & DEPOT_SERVICE, _current_player, (p2 & VLW_MASK), p1);
bjarni@4463: 	}
bjarni@4463: 
bjarni@4506: 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
bjarni@1237: 
tron@6413: 	Vehicle *v = GetVehicle(p1);
truelight@0: 
bjarni@4526: 	if (v->type != VEH_Aircraft || !CheckOwnership(v->owner) || IsAircraftInHangar(v)) return CMD_ERROR;
bjarni@4451: 
bjarni@4506: 	if (v->current_order.type == OT_GOTO_DEPOT && !(p2 & DEPOT_LOCATE_HANGAR)) {
bjarni@4519: 		if (!!(p2 & DEPOT_SERVICE) == HASBIT(v->current_order.flags, OFB_HALT_IN_DEPOT)) {
bjarni@4510: 			/* We called with a different DEPOT_SERVICE setting.
bjarni@4510: 			 * Now we change the setting to apply the new one and let the vehicle head for the same hangar.
rubidium@4549: 			 * Note: the if is (true for requesting service == true for ordered to stop in hangar) */
bjarni@4510: 			if (flags & DC_EXEC) {
bjarni@4510: 				TOGGLEBIT(v->current_order.flags, OFB_HALT_IN_DEPOT);
bjarni@4510: 				InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
bjarni@4510: 			}
bjarni@4510: 			return 0;
bjarni@4510: 		}
bjarni@4510: 
bjarni@4506: 		if (p2 & DEPOT_DONT_CANCEL) return CMD_ERROR; // Requested no cancelation of hangar orders
truelight@0: 		if (flags & DC_EXEC) {
tron@555: 			if (v->current_order.flags & OF_UNLOAD) v->cur_order_index++;
tron@555: 			v->current_order.type = OT_DUMMY;
tron@555: 			v->current_order.flags = 0;
darkvater@755: 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
truelight@0: 		}
truelight@0: 	} else {
bjarni@1262: 		bool next_airport_has_hangar = true;
bjarni@4412: 		StationID next_airport_index = v->u.air.targetairport;
Darkvater@1793: 		const Station *st = GetStation(next_airport_index);
bjarni@4111: 		/* If the station is not a valid airport or if it has no hangars */
tron@6358: 		if (!st->IsValid() || st->airport_tile == 0 || st->Airport()->nof_depots == 0) {
belugas@6449: 			/* the aircraft has to search for a hangar on its own */
tron@6413: 			StationID station = FindNearestHangar(v);
Darkvater@1793: 
Darkvater@1793: 			next_airport_has_hangar = false;
bjarni@4506: 			if (station == INVALID_STATION) return CMD_ERROR;
Darkvater@1793: 			next_airport_index = station;
bjarni@1262: 		}
truelight@0: 
truelight@0: 		if (flags & DC_EXEC) {
tron@555: 			v->current_order.type = OT_GOTO_DEPOT;
bjarni@4412: 			v->current_order.flags = OF_NON_STOP;
tron@4991: 			if (!(p2 & DEPOT_SERVICE)) SETBIT(v->current_order.flags, OFB_HALT_IN_DEPOT);
bjarni@5259: 			v->current_order.refit_cargo = CT_INVALID;
tron@4527: 			v->current_order.dest = next_airport_index;
darkvater@755: 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
rubidium@5689: 			if (v->u.air.state == FLYING && !next_airport_has_hangar) {
bjarni@4506: 				/* The aircraft is now heading for a different hangar than the next in the orders */
bjarni@1194: 				AircraftNextAirportPos_and_Order(v);
bjarni@1194: 			}
truelight@0: 		}
truelight@0: 	}
truelight@0: 
truelight@0: 	return 0;
truelight@0: }
truelight@0: 
truelight@0: 
Darkvater@1802: /** Refits an aircraft to the specified cargo type.
tron@3491:  * @param tile unused
belugas@6449:  * @param flags for command type
Darkvater@1802:  * @param p1 vehicle ID of the aircraft to refit
Darkvater@1802:  * @param p2 various bitstuffed elements
tron@2635:  * - p2 = (bit 0-7) - the new cargo type to refit to
peter1138@3954:  * - p2 = (bit 8-15) - the new cargo subtype to refit to
belugas@6449:  * @return cost of refit or error
Darkvater@1802:  */
tron@3491: int32 CmdRefitAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
peter1138@3954: 	byte new_subtype = GB(p2, 8, 8);
truelight@0: 
truelight@4352: 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
truelight@0: 
tron@6413: 	Vehicle *v = GetVehicle(p1);
bjarni@1237: 
Darkvater@1802: 	if (v->type != VEH_Aircraft || !CheckOwnership(v->owner)) return CMD_ERROR;
tron@3963: 	if (!IsAircraftInHangarStopped(v)) return_cmd_error(STR_A01B_AIRCRAFT_MUST_BE_STOPPED);
bjarni@1237: 
Darkvater@1802: 	/* Check cargo */
tron@6413: 	CargoID new_cid = GB(p2, 0, 8);
peter1138@2704: 	if (new_cid > NUM_CARGO || !CanRefitTo(v->engine_type, new_cid)) return CMD_ERROR;
truelight@0: 
bjarni@1237: 	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);
bjarni@1237: 
peter1138@3974: 	/* Check the refit capacity callback */
tron@6413: 	uint16 callback = CALLBACK_FAILED;
peter1138@3974: 	if (HASBIT(EngInfo(v->engine_type)->callbackmask, CBM_REFIT_CAPACITY)) {
peter1138@3974: 		/* Back up the existing cargo type */
peter1138@3974: 		CargoID temp_cid = v->cargo_type;
peter1138@3988: 		byte temp_subtype = v->cargo_subtype;
peter1138@3974: 		v->cargo_type = new_cid;
peter1138@3988: 		v->cargo_subtype = new_subtype;
peter1138@3974: 
peter1138@3974: 		callback = GetVehicleCallback(CBID_VEHICLE_REFIT_CAPACITY, 0, 0, v->engine_type, v);
peter1138@3974: 
peter1138@3974: 		/* Restore the cargo type */
peter1138@3974: 		v->cargo_type = temp_cid;
peter1138@3988: 		v->cargo_subtype = temp_subtype;
peter1138@3974: 	}
peter1138@3974: 
tron@6413: 	const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
tron@6413: 
tron@6413: 	uint pass;
peter1138@3974: 	if (callback == CALLBACK_FAILED) {
peter1138@3974: 		/* If the callback failed, or wasn't executed, use the aircraft's
peter1138@3974: 		 * default cargo capacity */
tron@6413: 		pass = AircraftDefaultCargoCapacity(new_cid, avi);
peter1138@3974: 	} else {
peter1138@3974: 		pass = callback;
truelight@0: 	}
peter1138@3008: 	_returned_refit_capacity = pass;
truelight@0: 
tron@6413: 	int32 cost = 0;
Darkvater@4845: 	if (IsHumanPlayer(v->owner) && new_cid != v->cargo_type) {
bjarni@4544: 		cost = GetRefitCost(v->engine_type);
truelight@0: 	}
truelight@0: 
truelight@0: 	if (flags & DC_EXEC) {
truelight@0: 		v->cargo_cap = pass;
truelight@0: 
tron@6413: 		Vehicle *u = v->next;
tron@6413: 		uint mail = new_cid != CT_PASSENGERS ? 0 : avi->mail_capacity;
truelight@0: 		u->cargo_cap = mail;
peter1138@3955: 		if (v->cargo_type == new_cid) {
peter1138@3955: 			v->cargo_count = min(pass, v->cargo_count);
peter1138@3955: 			u->cargo_count = min(mail, u->cargo_count);
peter1138@3955: 		} else {
peter1138@3955: 			v->cargo_count = 0;
peter1138@3955: 			u->cargo_count = 0;
peter1138@3955: 		}
Darkvater@1802: 		v->cargo_type = new_cid;
peter1138@3954: 		v->cargo_subtype = new_subtype;
truelight@0: 		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
peter1138@3722: 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
peter1138@3722: 		RebuildVehicleLists();
truelight@0: 	}
truelight@0: 
truelight@0: 	return cost;
truelight@0: }
truelight@0: 
truelight@0: 
truelight@0: static void CheckIfAircraftNeedsService(Vehicle *v)
truelight@0: {
tron@2639: 	if (_patches.servint_aircraft == 0) return;
tron@2639: 	if (!VehicleNeedsService(v)) return;
tron@2639: 	if (v->vehstatus & VS_STOPPED) return;
truelight@0: 
tron@555: 	if (v->current_order.type == OT_GOTO_DEPOT &&
celestar@1530: 			v->current_order.flags & OF_HALT_IN_DEPOT)
truelight@0: 		return;
truelight@0: 
tron@2639: 	if (_patches.gotodepot && VehicleHasDepotOrders(v)) return;
truelight@193: 
bjarni@4529: 	if (IsAircraftInHangar(v)) {
bjarni@4529: 		VehicleServiceInDepot(v);
bjarni@4529: 		return;
bjarni@4529: 	}
bjarni@4529: 
tron@6413: 	const Station *st = GetStation(v->current_order.dest);
belugas@6449: 	/* only goto depot if the target airport has terminals (eg. it is airport) */
tron@6358: 	if (st->IsValid() && st->airport_tile != 0 && st->Airport()->terminals != NULL) {
truelight@0: //		printf("targetairport = %d, st->index = %d\n", v->u.air.targetairport, st->index);
truelight@0: //		v->u.air.targetairport = st->index;
tron@555: 		v->current_order.type = OT_GOTO_DEPOT;
tron@555: 		v->current_order.flags = OF_NON_STOP;
darkvater@755: 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
tron@555: 	} else if (v->current_order.type == OT_GOTO_DEPOT) {
tron@555: 		v->current_order.type = OT_DUMMY;
tron@555: 		v->current_order.flags = 0;
darkvater@755: 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
truelight@0: 	}
truelight@0: }
truelight@0: 
truelight@0: void OnNewDay_Aircraft(Vehicle *v)
truelight@0: {
Darkvater@6105: 	if (!IsNormalAircraft(v)) return;
truelight@0: 
tron@2639: 	if ((++v->day_counter & 7) == 0) DecreaseVehicleValue(v);
truelight@0: 
tron@3140: 	CheckOrders(v);
dominik@19: 
truelight@0: 	CheckVehicleBreakdown(v);
truelight@0: 	AgeVehicle(v);
truelight@0: 	CheckIfAircraftNeedsService(v);
truelight@0: 
tron@2639: 	if (v->vehstatus & VS_STOPPED) return;
truelight@0: 
tron@6413: 	int32 cost = AircraftVehInfo(v->engine_type)->running_cost * _price.aircraft_running / 364;
truelight@0: 
truelight@0: 	v->profit_this_year -= cost >> 8;
truelight@0: 
truelight@0: 	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);
truelight@0: 	SubtractMoneyFromPlayerFract(v->owner, cost);
truelight@0: 
truelight@0: 	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
Celestar@1055: 	InvalidateWindowClasses(WC_AIRCRAFT_LIST);
truelight@0: }
truelight@0: 
tron@1093: void AircraftYearlyLoop(void)
truelight@0: {
truelight@0: 	Vehicle *v;
truelight@0: 
truelight@0: 	FOR_ALL_VEHICLES(v) {
Darkvater@6105: 		if (v->type == VEH_Aircraft && IsNormalAircraft(v)) {
truelight@0: 			v->profit_last_year = v->profit_this_year;
truelight@0: 			v->profit_this_year = 0;
truelight@0: 			InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
truelight@0: 		}
truelight@0: 	}
truelight@0: }
truelight@0: 
truelight@0: static void AgeAircraftCargo(Vehicle *v)
truelight@0: {
tron@2639: 	if (_age_cargo_skip_counter != 0) return;
truelight@0: 
truelight@0: 	do {
tron@2639: 		if (v->cargo_days != 0xFF) v->cargo_days++;
tron@2639: 		v = v->next;
tron@2639: 	} while (v != NULL);
truelight@0: }
truelight@0: 
truelight@0: static void HelicopterTickHandler(Vehicle *v)
truelight@0: {
tron@6413: 	Vehicle *u = v->next->next;
truelight@0: 
tron@2639: 	if (u->vehstatus & VS_HIDDEN) return;
truelight@0: 
belugas@6449: 	/* if true, helicopter rotors do not rotate. This should only be the case if a helicopter is
belugas@6449: 	 * loading/unloading at a terminal or stopped */
tron@555: 	if (v->current_order.type == OT_LOADING || (v->vehstatus & VS_STOPPED)) {
truelight@0: 		if (u->cur_speed != 0) {
truelight@0: 			u->cur_speed++;
peter1138@3710: 			if (u->cur_speed >= 0x80 && u->u.air.state == HRS_ROTOR_MOVING_3) {
truelight@0: 				u->cur_speed = 0;
truelight@0: 			}
truelight@0: 		}
truelight@0: 	} else {
truelight@0: 		if (u->cur_speed == 0)
truelight@0: 			u->cur_speed = 0x70;
truelight@0: 
truelight@0: 		if (u->cur_speed >= 0x50)
truelight@0: 			u->cur_speed--;
truelight@0: 	}
truelight@0: 
tron@6413: 	int tick = ++u->tick_counter;
tron@6413: 	int spd = u->cur_speed >> 4;
truelight@0: 
tron@6413: 	SpriteID img;
truelight@0: 	if (spd == 0) {
peter1138@3710: 		u->u.air.state = HRS_ROTOR_STOPPED;
peter1138@3710: 		img = GetRotorImage(v);
tron@2549: 		if (u->cur_image == img) return;
truelight@0: 	} else if (tick >= spd) {
truelight@0: 		u->tick_counter = 0;
peter1138@3710: 		u->u.air.state++;
peter1138@3710: 		if (u->u.air.state > HRS_ROTOR_MOVING_3) u->u.air.state = HRS_ROTOR_MOVING_1;
peter1138@3710: 		img = GetRotorImage(v);
tron@2549: 	} else {
truelight@0: 		return;
tron@2549: 	}
truelight@0: 
tron@2549: 	u->cur_image = img;
truelight@0: 
truelight@0: 	BeginVehicleMove(u);
truelight@0: 	VehiclePositionChanged(u);
truelight@0: 	EndVehicleMove(u);
truelight@0: }
truelight@0: 
truelight@0: static void SetAircraftPosition(Vehicle *v, int x, int y, int z)
truelight@0: {
truelight@0: 	v->x_pos = x;
truelight@0: 	v->y_pos = y;
truelight@0: 	v->z_pos = z;
truelight@0: 
truelight@0: 	v->cur_image = GetAircraftImage(v, v->direction);
Darkvater@6105: 	if (v->subtype == AIR_HELICOPTER) v->next->next->cur_image = GetRotorImage(v);
truelight@0: 
truelight@0: 	BeginVehicleMove(v);
truelight@0: 	VehiclePositionChanged(v);
truelight@0: 	EndVehicleMove(v);
truelight@0: 
tron@6413: 	Vehicle *u = v->next;
truelight@0: 
tron@6413: 	int safe_x = clamp(x, 0, MapMaxX() * TILE_SIZE);
tron@6413: 	int safe_y = clamp(y - 1, 0, MapMaxY() * TILE_SIZE);
truelight@0: 	u->x_pos = x;
rubidium@4259: 	u->y_pos = y - ((v->z_pos-GetSlopeZ(safe_x, safe_y)) >> 3);;
rubidium@4259: 
rubidium@4259: 	safe_y = clamp(u->y_pos, 0, MapMaxY() * TILE_SIZE);
rubidium@4259: 	u->z_pos = GetSlopeZ(safe_x, safe_y);
truelight@0: 	u->cur_image = v->cur_image;
truelight@0: 
truelight@0: 	BeginVehicleMove(u);
truelight@0: 	VehiclePositionChanged(u);
truelight@0: 	EndVehicleMove(u);
truelight@0: 
tron@2639: 	u = u->next;
tron@2639: 	if (u != NULL) {
truelight@0: 		u->x_pos = x;
truelight@0: 		u->y_pos = y;
truelight@0: 		u->z_pos = z + 5;
truelight@0: 
truelight@0: 		BeginVehicleMove(u);
truelight@0: 		VehiclePositionChanged(u);
truelight@0: 		EndVehicleMove(u);
truelight@0: 	}
truelight@0: }
truelight@0: 
bjarni@4725: /** Handle Aircraft specific tasks when a an Aircraft enters a hangar
bjarni@4725:  * @param *v Vehicle that enters the hangar
bjarni@4725:  */
belugas@4732: void HandleAircraftEnterHangar(Vehicle *v)
truelight@0: {
truelight@0: 	v->subspeed = 0;
truelight@0: 	v->progress = 0;
truelight@0: 
tron@6413: 	Vehicle *u = v->next;
truelight@0: 	u->vehstatus |= VS_HIDDEN;
tron@2639: 	u = u->next;
tron@2639: 	if (u != NULL) {
truelight@0: 		u->vehstatus |= VS_HIDDEN;
truelight@0: 		u->cur_speed = 0;
truelight@0: 	}
truelight@0: 
truelight@0: 	SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);
truelight@0: }
truelight@0: 
tron@2549: static void PlayAircraftSound(const Vehicle* v)
truelight@0: {
peter1138@4656: 	if (!PlayVehicleSound(v, VSE_START)) {
peter1138@4656: 		SndPlayVehicleFx(AircraftVehInfo(v->engine_type)->sfx, v);
peter1138@4656: 	}
truelight@0: }
truelight@0: 
celestar@6519: /**
celestar@6519:  * Special velocities for aircraft
celestar@6196:  */
celestar@6196: enum AircraftSpeedLimits {
celestar@6519: 	SPEED_LIMIT_TAXI     =     50,  ///< Maximum speed of an aircraft while taxiing
celestar@6519: 	SPEED_LIMIT_APPROACH =    230,  ///< Maximum speed of an aircraft on finals
celestar@6519: 	SPEED_LIMIT_BROKEN   =    320,  ///< Maximum speed of an aircraft that is broken
celestar@6519: 	SPEED_LIMIT_HOLD     =    425,  ///< Maximum speed of an aircraft that flies the holding pattern
celestar@6519: 	SPEED_LIMIT_NONE     = 0xFFFF   ///< No environmental speed limit. Speed limit is type dependent
celestar@6196: };
celestar@6196: 
celestar@6519: /**
celestar@6519:  * Sets the new speed for an aircraft
celestar@6519:  * @param v The vehicle for which the speed should be obtained
celestar@6519:  * @param speed_limit The maximum speed the vehicle may have.
celestar@6519:  * @param hard_limit If true, the limit is directly enforced, otherwise the plane is slowed down gradually
celestar@6519:  * @return The number of position updates needed within the tick
celestar@6519:  */
celestar@6519: static int UpdateAircraftSpeed(Vehicle *v, uint speed_limit = SPEED_LIMIT_NONE, bool hard_limit = true)
truelight@0: {
celestar@6519: 	uint spd = v->acceleration * 16;
truelight@0: 	byte t;
truelight@0: 
celestar@6519: 	speed_limit = min(speed_limit, v->max_speed);
celestar@6519: 
truelight@0: 	v->subspeed = (t=v->subspeed) + (byte)spd;
celestar@6519: 
celestar@6519: 	if (!hard_limit && v->cur_speed > speed_limit) speed_limit = v->cur_speed - (v->cur_speed / 48);
celestar@6519: 
celestar@6196: 	spd = min(v->cur_speed + (spd >> 8) + (v->subspeed < t), speed_limit);
truelight@193: 
belugas@6449: 	/* adjust speed for broken vehicles */
celestar@6196: 	if (v->vehstatus & VS_AIRCRAFT_BROKEN) spd = min(spd, SPEED_LIMIT_BROKEN);
truelight@0: 
belugas@6449: 	/* updates statusbar only if speed have changed to save CPU time */
truelight@0: 	if (spd != v->cur_speed) {
truelight@0: 		v->cur_speed = spd;
truelight@0: 		if (_patches.vehicle_speed)
darkvater@755: 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
truelight@0: 	}
truelight@0: 
tron@2639: 	if (!(v->direction & 1)) spd = spd * 3 / 4;
truelight@0: 
celestar@6519: 	spd += v->progress;
celestar@6519: 	v->progress = (byte)spd;
celestar@6519: 	return spd >> 8;
truelight@0: }
truelight@0: 
celestar@6159: /**
celestar@6159:  * Gets the cruise altitude of an aircraft.
celestar@6159:  * The cruise altitude is determined by the velocity of the vehicle
celestar@6159:  * and the direction it is moving
celestar@6159:  * @param v The vehicle. Should be an aircraft
celestar@6159:  * @returns Altitude in pixel units
celestar@6159:  */
truelight@0: static byte GetAircraftFlyingAltitude(const Vehicle *v)
truelight@0: {
celestar@6159: 	/* Make sure Aircraft fly no lower so that they don't conduct
celestar@6159: 	 * CFITs (controlled flight into terrain)
celestar@6159: 	 */
celestar@6159: 	byte base_altitude = 150;
celestar@6159: 
celestar@6159: 	/* Make sure eastbound and westbound planes do not "crash" into each
celestar@6159: 	 * other by providing them with vertical seperation
celestar@6159: 	 */
celestar@6159: 	switch (v->direction) {
tron@6413: 		case DIR_N:
tron@6413: 		case DIR_NE:
tron@6413: 		case DIR_E:
tron@6413: 		case DIR_SE:
celestar@6519: 			base_altitude += 10;
tron@6413: 			break;
tron@6413: 
celestar@6159: 		default: break;
truelight@0: 	}
celestar@6159: 
celestar@6159: 	/* Make faster planes fly higher so that they can overtake slower ones */
celestar@6519: 	base_altitude += min(20 * (v->max_speed / 200), 90);
celestar@6159: 
celestar@6159: 	return base_altitude;
truelight@0: }
truelight@0: 
celestar@6519: /**
celestar@6519:  * Controls the movement of an aircraft. This function actually moves the vehicle
celestar@6519:  * on the map and takes care of minor things like sound playback.
celestar@6519:  * @todo    De-mystify the cur_speed values for helicopter rotors.
celestar@6519:  * @param v The vehicle that is moved. Must be the first vehicle of the chain
celestar@6519:  * @return  Whether the position requested by the State Machine has been reached
celestar@6519:  */
Darkvater@1401: static bool AircraftController(Vehicle *v)
truelight@0: {
celestar@6519: 	int count;
tron@6413: 	const Station *st = GetStation(v->u.air.targetairport);
truelight@0: 
belugas@6449: 	/* prevent going to 0,0 if airport is deleted. */
tron@6413: 	TileIndex tile = st->airport_tile;
tron@6413: 	if (tile == 0) tile = st->xy;
tron@6413: 	int x = TileX(tile) * TILE_SIZE;
tron@6413: 	int y = TileY(tile) * TILE_SIZE;
truelight@0: 
belugas@6449: 	/*  get airport moving data */
tron@6358: 	const AirportFTAClass *afc = st->Airport();
tron@6346: 	const AirportMovingData *amd = afc->MovingData(v->u.air.pos);
truelight@0: 
belugas@6449: 	/* Helicopter raise */
truelight@0: 	if (amd->flag & AMED_HELI_RAISE) {
tron@6413: 		Vehicle *u = v->next->next;
truelight@0: 
belugas@6449: 		/* Make sure the rotors don't rotate too fast */
truelight@0: 		if (u->cur_speed > 32) {
truelight@0: 			v->cur_speed = 0;
tron@2639: 			if (--u->cur_speed == 32) SndPlayVehicleFx(SND_18_HELICOPTER, v);
truelight@0: 		} else {
truelight@0: 			u->cur_speed = 32;
celestar@6519: 			count = UpdateAircraftSpeed(v);
celestar@6519: 			if (count > 0) {
truelight@0: 				v->tile = 0;
truelight@0: 
belugas@6449: 				/* Reached altitude? */
truelight@0: 				if (v->z_pos >= 184) {
truelight@0: 					v->cur_speed = 0;
truelight@0: 					return true;
truelight@0: 				}
celestar@6519: 				SetAircraftPosition(v, v->x_pos, v->y_pos, min(v->z_pos + count, 184));
truelight@0: 			}
truelight@0: 		}
truelight@0: 		return false;
truelight@0: 	}
truelight@0: 
belugas@6449: 	/* Helicopter landing. */
truelight@0: 	if (amd->flag & AMED_HELI_LOWER) {
celestar@6519: 		count = UpdateAircraftSpeed(v);
celestar@6519: 		if (count > 0) {
truelight@0: 			if (st->airport_tile == 0) {
belugas@6449: 				/* FIXME - AircraftController -> if station no longer exists, do not land
belugas@6449: 				 * helicopter will circle until sign disappears, then go to next order
belugas@6449: 				 * what to do when it is the only order left, right now it just stays in 1 place */
truelight@0: 				v->u.air.state = FLYING;
truelight@0: 				AircraftNextAirportPos_and_Order(v);
truelight@0: 				return false;
truelight@0: 			}
truelight@0: 
belugas@6449: 			/* Vehicle is now at the airport. */
truelight@0: 			v->tile = st->airport_tile;
truelight@0: 
belugas@6449: 			/* Find altitude of landing position. */
celestar@6519: 			int z = GetSlopeZ(x, y) + 1 + afc->delta_z;
truelight@0: 
truelight@0: 			if (z == v->z_pos) {
tron@6413: 				Vehicle *u = v->next->next;
truelight@0: 
belugas@6449: 				/*  Increase speed of rotors. When speed is 80, we've landed. */
tron@2639: 				if (u->cur_speed >= 80) return true;
tron@2639: 				u->cur_speed += 4;
truelight@0: 			} else if (v->z_pos > z) {
celestar@6519: 				SetAircraftPosition(v, v->x_pos, v->y_pos, max(v->z_pos - count, z));
truelight@0: 			} else {
celestar@6519: 				SetAircraftPosition(v, v->x_pos, v->y_pos, min(v->z_pos + count, z));
truelight@0: 			}
truelight@0: 		}
truelight@0: 		return false;
truelight@0: 	}
truelight@0: 
belugas@6449: 	/* Get distance from destination pos to current pos. */
tron@6413: 	uint dist = myabs(x + amd->x - v->x_pos) +  myabs(y + amd->y - v->y_pos);
truelight@0: 
belugas@6449: 	/* Need exact position? */
celestar@6519: 	if (!(amd->flag & AMED_EXACTPOS) && dist <= (amd->flag & AMED_SLOWTURN ? 8U : 4U)) return true;
truelight@0: 
belugas@6449: 	/* At final pos? */
truelight@0: 	if (dist == 0) {
belugas@6449: 		/* Change direction smoothly to final direction. */
tron@6413: 		DirDiff dirdiff = DirDifference(amd->direction, v->direction);
belugas@6449: 		/* if distance is 0, and plane points in right direction, no point in calling
belugas@6449: 		 * UpdateAircraftSpeed(). So do it only afterwards */
tron@3158: 		if (dirdiff == DIRDIFF_SAME) {
truelight@0: 			v->cur_speed = 0;
truelight@0: 			return true;
truelight@0: 		}
truelight@0: 
celestar@6196: 		if (!UpdateAircraftSpeed(v, SPEED_LIMIT_TAXI)) return false;
truelight@0: 
tron@3158: 		v->direction = ChangeDir(v->direction, dirdiff > DIRDIFF_REVERSE ? DIRDIFF_45LEFT : DIRDIFF_45RIGHT);
truelight@0: 		v->cur_speed >>= 1;
truelight@0: 
truelight@0: 		SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);
truelight@0: 		return false;
truelight@0: 	}
truelight@0: 
celestar@6519: 	uint speed_limit = SPEED_LIMIT_TAXI;
celestar@6519: 	bool hard_limit = true;
celestar@6519: 
celestar@6519: 	if (amd->flag & AMED_NOSPDCLAMP)   speed_limit = SPEED_LIMIT_NONE;
celestar@6519: 	if (amd->flag & AMED_HOLD)       { speed_limit = SPEED_LIMIT_HOLD;     hard_limit = false; }
celestar@6519: 	if (amd->flag & AMED_LAND)       { speed_limit = SPEED_LIMIT_APPROACH; hard_limit = false; }
celestar@6519: 	if (amd->flag & AMED_BRAKE)      { speed_limit = SPEED_LIMIT_TAXI;     hard_limit = false; }
celestar@6519: 
celestar@6519: 	count = UpdateAircraftSpeed(v, speed_limit, hard_limit);
celestar@6519: 	if (count == 0) return false;
truelight@0: 
tron@2639: 	if (v->load_unload_time_rem != 0) v->load_unload_time_rem--;
truelight@0: 
celestar@6519: 	do {
celestar@6519: 		/* Turn. Do it slowly if in the air. */
celestar@6519: 		Direction newdir = GetDirectionTowards(v, x + amd->x, y + amd->y);
celestar@6519: 		if (newdir != v->direction) {
truelight@0: 			v->direction = newdir;
celestar@6519: 			if (amd->flag & AMED_SLOWTURN) {
celestar@6519: 				if (v->load_unload_time_rem == 0) v->load_unload_time_rem = 8;
celestar@6519: 			} else {
celestar@6519: 				v->cur_speed >>= 1;
celestar@6519: 			}
truelight@0: 		}
truelight@0: 
celestar@6519: 		/* Move vehicle. */
celestar@6519: 		GetNewVehiclePosResult gp = GetNewVehiclePos(v);
celestar@6519: 		v->tile = gp.new_tile;
celestar@6519: 		/* If vehicle is in the air, use tile coordinate 0. */
celestar@6519: 		// if (amd->flag & (AMED_TAKEOFF | AMED_SLOWTURN | AMED_LAND)) v->tile = 0;
truelight@0: 
celestar@6519: 		/* Adjust Z for land or takeoff? */
celestar@6519: 		uint z = v->z_pos;
truelight@0: 
celestar@6519: 		if (amd->flag & AMED_TAKEOFF) {
celestar@6519: 			z = min(z + 2, GetAircraftFlyingAltitude(v));
tron@2639: 		}
truelight@0: 
celestar@6519: 		if ((amd->flag & AMED_HOLD) && (z > 150)) z--;
truelight@0: 
celestar@6519: 		if (amd->flag & AMED_LAND) {
celestar@6519: 			if (st->airport_tile == 0) {
celestar@6519: 				/* Airport has been removed, abort the landing procedure */
celestar@6519: 				v->u.air.state = FLYING;
celestar@6519: 				AircraftNextAirportPos_and_Order(v);
celestar@6519: 				/* get aircraft back on running altitude */
celestar@6519: 				SetAircraftPosition(v, gp.x, gp.y, GetAircraftFlyingAltitude(v));
celestar@6519: 				continue;
celestar@6519: 			}
celestar@6519: 
celestar@6519: 			uint curz = GetSlopeZ(x, y) + 1;
celestar@6519: 
celestar@6519: 			if (curz > z) {
celestar@6519: 				z++;
celestar@6519: 			} else {
celestar@6519: 				int t = max(1U, dist - 4);
celestar@6519: 
celestar@6519: 				z -= ((z - curz) + t - 1) / t;
celestar@6519: 				if (z < curz) z = curz;
celestar@6519: 			}
celestar@6519: 		}
celestar@6519: 
celestar@6519: 		/* We've landed. Decrase speed when we're reaching end of runway. */
celestar@6519: 		if (amd->flag & AMED_BRAKE) {
celestar@6519: 			uint curz = GetSlopeZ(x, y) + 1;
celestar@6519: 
celestar@6519: 			if (z > curz) {
celestar@6519: 				z--;
celestar@6519: 			} else if (z < curz) {
celestar@6519: 				z++;
celestar@6519: 			}
celestar@6519: 
celestar@6519: 		}
celestar@6519: 
celestar@6519: 		SetAircraftPosition(v, gp.x, gp.y, z);
celestar@6519: 	} while (--count != 0);
truelight@0: 	return false;
truelight@0: }
truelight@0: 
truelight@0: 
truelight@0: static void HandleCrashedAircraft(Vehicle *v)
truelight@0: {
truelight@0: 	v->u.air.crashed_counter++;
truelight@0: 
tron@6413: 	Station *st = GetStation(v->u.air.targetairport);
dominik@899: 
belugas@6449: 	/* make aircraft crash down to the ground */
dominik@1150: 	if (v->u.air.crashed_counter < 500 && st->airport_tile==0 && ((v->u.air.crashed_counter % 3) == 0) ) {
tron@6413: 		uint z = GetSlopeZ(v->x_pos, v->y_pos);
dominik@899: 		v->z_pos -= 1;
dominik@1150: 		if (v->z_pos == z) {
dominik@1150: 			v->u.air.crashed_counter = 500;
dominik@1150: 			v->z_pos++;
dominik@1150: 		}
dominik@899: 	}
dominik@899: 
truelight@0: 	if (v->u.air.crashed_counter < 650) {
tron@6413: 		uint32 r;
truelight@0: 		if (CHANCE16R(1,32,r)) {
tron@3160: 			static const DirDiff delta[] = {
tron@3160: 				DIRDIFF_45LEFT, DIRDIFF_SAME, DIRDIFF_SAME, DIRDIFF_45RIGHT
tron@3160: 			};
tron@3160: 
tron@3160: 			v->direction = ChangeDir(v->direction, delta[GB(r, 16, 2)]);
truelight@0: 			SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);
truelight@0: 			r = Random();
truelight@0: 			CreateEffectVehicleRel(v,
tron@2140: 				GB(r, 0, 4) + 4,
tron@2140: 				GB(r, 4, 4) + 4,
tron@2140: 				GB(r, 8, 4),
tron@1359: 				EV_EXPLOSION_SMALL);
truelight@0: 		}
truelight@0: 	} else if (v->u.air.crashed_counter >= 10000) {
belugas@6449: 		/*  remove rubble of crashed airplane */
truelight@0: 
belugas@6449: 		/* clear runway-in on all airports, set by crashing plane
belugas@6449: 		 * small airports use AIRPORT_BUSY, city airports use RUNWAY_IN_OUT_block, etc.
belugas@6449: 		 * but they all share the same number */
truelight@0: 		CLRBITS(st->airport_flags, RUNWAY_IN_block);
richk@4059: 		CLRBITS(st->airport_flags, RUNWAY_IN_OUT_block); // commuter airport
belugas@6449: 		CLRBITS(st->airport_flags, RUNWAY_IN2_block);    // intercontinental
truelight@0: 
truelight@0: 		BeginVehicleMove(v);
truelight@0: 		EndVehicleMove(v);
truelight@0: 
truelight@0: 		DoDeleteAircraft(v);
truelight@0: 	}
truelight@0: }
truelight@0: 
truelight@0: static void HandleBrokenAircraft(Vehicle *v)
truelight@0: {
truelight@0: 	if (v->breakdown_ctr != 1) {
truelight@0: 		v->breakdown_ctr = 1;
truelight@0: 		v->vehstatus |= VS_AIRCRAFT_BROKEN;
truelight@0: 
truelight@0: 		if (v->breakdowns_since_last_service != 255)
truelight@0: 			v->breakdowns_since_last_service++;
truelight@0: 		InvalidateWindow(WC_VEHICLE_VIEW, v->index);
truelight@0: 		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
truelight@0: 	}
truelight@0: }
truelight@0: 
truelight@0: 
truelight@0: static void HandleAircraftSmoke(Vehicle *v)
truelight@0: {
tron@2654: 	static const struct {
tron@2654: 		int8 x;
tron@2654: 		int8 y;
tron@2654: 	} smoke_pos[] = {
tron@2654: 		{  5,  5 },
tron@2654: 		{  6,  0 },
tron@2654: 		{  5, -5 },
tron@2654: 		{  0, -6 },
tron@2654: 		{ -5, -5 },
tron@2654: 		{ -6,  0 },
tron@2654: 		{ -5,  5 },
tron@2654: 		{  0,  6 }
tron@2654: 	};
tron@2654: 
tron@2639: 	if (!(v->vehstatus & VS_AIRCRAFT_BROKEN)) return;
truelight@0: 
truelight@0: 	if (v->cur_speed < 10) {
truelight@0: 		v->vehstatus &= ~VS_AIRCRAFT_BROKEN;
truelight@0: 		v->breakdown_ctr = 0;
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
truelight@0: 	if ((v->tick_counter & 0x1F) == 0) {
truelight@0: 		CreateEffectVehicleRel(v,
tron@2654: 			smoke_pos[v->direction].x,
tron@2654: 			smoke_pos[v->direction].y,
truelight@0: 			2,
tron@1359: 			EV_SMOKE
truelight@0: 		);
truelight@0: 	}
truelight@0: }
truelight@0: 
truelight@0: static void ProcessAircraftOrder(Vehicle *v)
truelight@0: {
tron@3005: 	switch (v->current_order.type) {
tron@3005: 		case OT_GOTO_DEPOT:
tron@3005: 			if (!(v->current_order.flags & OF_PART_OF_ORDERS)) return;
tron@3005: 			if (v->current_order.flags & OF_SERVICE_IF_NEEDED &&
tron@3005: 					!VehicleNeedsService(v)) {
tron@3005: 				v->cur_order_index++;
tron@3005: 			}
tron@3005: 			break;
tron@3005: 
tron@3005: 		case OT_LOADING: return;
truelight@4351: 
truelight@4351: 		default: break;
bjarni@1151: 	}
truelight@193: 
tron@2639: 	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
truelight@0: 
tron@6413: 	const Order *order = GetVehicleOrder(v, v->cur_order_index);
truelight@0: 
rubidium@6493: 	if (order == NULL|| (order->type == OT_DUMMY && !CheckForValidOrders(v))) {
rubidium@6493: 		/*
rubidium@6493: 		 * We do not have an order. This can be divided into two cases:
rubidium@6493: 		 * 1) we are heading to an invalid station. In this case we must
rubidium@6493: 		 *    find another airport to go to. If there is nowhere to go,
rubidium@6493: 		 *    we will destroy the aircraft as it otherwise will enter
rubidium@6493: 		 *    the holding pattern for the first airport, which can cause
rubidium@6493: 		 *    the plane to go into an undefined state when building an
rubidium@6493: 		 *    airport with the same StationID.
rubidium@6493: 		 * 2) we are (still) heading to a (still) valid airport, then we
rubidium@6493: 		 *    can continue going there. This can happen when you are
rubidium@6493: 		 *    changing the aircraft's orders while in-flight or in for
rubidium@6493: 		 *    example a depot. However, when we have a current order to
rubidium@6493: 		 *    go to a depot, we have to keep that order so the aircraft
rubidium@6493: 		 *    actually stops.
rubidium@6493: 		 */
rubidium@6493: 		const Station *st = GetStation(v->u.air.targetairport);
rubidium@6493: 		if (!st->IsValid() || st->airport_tile == 0) {
rubidium@6493: 			int32 ret;
rubidium@6493: 			PlayerID old_player = _current_player;
rubidium@6493: 
rubidium@6493: 			_current_player = v->owner;
rubidium@6493: 			ret = DoCommand(v->tile, v->index, 0, DC_EXEC, CMD_SEND_AIRCRAFT_TO_HANGAR);
rubidium@6493: 			_current_player = old_player;
rubidium@6493: 
rubidium@6493: 			if (CmdFailed(ret)) CrashAirplane(v);
rubidium@6493: 		} else if (v->current_order.type != OT_GOTO_DEPOT) {
rubidium@6493: 			v->current_order.type = OT_NOTHING;
rubidium@6493: 			v->current_order.flags = 0;
rubidium@6493: 		}
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
tron@4527: 	if (order->type  == v->current_order.type  &&
tron@4527: 			order->flags == v->current_order.flags &&
tron@4527: 			order->dest  == v->current_order.dest)
truelight@0: 		return;
truelight@0: 
truelight@1024: 	v->current_order = *order;
truelight@0: 
belugas@6449: 	/* orders are changed in flight, ensure going to the right station */
truelight@1024: 	if (order->type == OT_GOTO_STATION && v->u.air.state == FLYING) {
truelight@0: 		AircraftNextAirportPos_and_Order(v);
truelight@0: 	}
truelight@0: 
truelight@1024: 	InvalidateVehicleOrder(v);
truelight@1024: 
Celestar@1055: 	InvalidateWindowClasses(WC_AIRCRAFT_LIST);
truelight@0: }
truelight@0: 
peter1138@3722: /** Mark all views dirty for an aircraft.
peter1138@3722:  * @param v vehicle to be redrawn.
peter1138@3722:  */
peter1138@3722: static void MarkAircraftDirty(Vehicle *v)
peter1138@3722: {
peter1138@3722: 		v->cur_image = GetAircraftImage(v, v->direction);
Darkvater@6105: 		if (v->subtype == AIR_HELICOPTER) v->next->next->cur_image = GetRotorImage(v);
peter1138@3722: 		MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1);
peter1138@3722: }
peter1138@3722: 
truelight@0: static void HandleAircraftLoading(Vehicle *v, int mode)
truelight@0: {
tron@6107: 	switch (v->current_order.type) {
peter1138@6109: 		case OT_LOADING: {
tron@6107: 			if (mode != 0) return;
tron@6107: 			if (--v->load_unload_time_rem != 0) return;
truelight@0: 
tron@6107: 			if (CanFillVehicle(v) && (
tron@6107: 						v->current_order.flags & OF_FULL_LOAD ||
maedhros@6501: 						(_patches.gradual_loading && !HASBIT(v->vehicle_flags, VF_LOADING_FINISHED))
tron@6107: 					)) {
tron@6107: 				SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_INC);
tron@6107: 				if (LoadUnloadVehicle(v, false)) {
tron@6107: 					InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);
tron@6107: 					MarkAircraftDirty(v);
tron@6107: 				}
tron@6107: 				return;
peter1138@3722: 			}
truelight@0: 
tron@555: 			Order b = v->current_order;
tron@555: 			v->current_order.type = OT_NOTHING;
tron@555: 			v->current_order.flags = 0;
peter1138@3722: 			MarkAircraftDirty(v);
tron@2639: 			if (!(b.flags & OF_NON_STOP)) return;
tron@6107: 			break;
peter1138@6109: 		}
tron@6107: 
tron@6107: 		case OT_DUMMY: break;
tron@6107: 
tron@6107: 		default: return;
truelight@0: 	}
tron@6107: 
truelight@0: 	v->cur_order_index++;
truelight@1024: 	InvalidateVehicleOrder(v);
truelight@0: }
truelight@0: 
dominik@899: static void CrashAirplane(Vehicle *v)
dominik@899: {
dominik@899: 	v->vehstatus |= VS_CRASHED;
dominik@899: 	v->u.air.crashed_counter = 0;
dominik@899: 
tron@1359: 	CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
dominik@899: 
dominik@899: 	InvalidateWindow(WC_VEHICLE_VIEW, v->index);
dominik@899: 
tron@6413: 	uint amt = 2;
dominik@899: 	if (v->cargo_type == CT_PASSENGERS) amt += v->cargo_count;
dominik@899: 	SetDParam(0, amt);
dominik@899: 
dominik@899: 	v->cargo_count = 0;
tron@6202: 	v->next->cargo_count = 0;
tron@6413: 	const Station *st = GetStation(v->u.air.targetairport);
tron@6413: 	StringID newsitem;
tron@2639: 	if (st->airport_tile == 0) {
dominik@899: 		newsitem = STR_PLANE_CRASH_OUT_OF_FUEL;
dominik@899: 	} else {
dominik@899: 		SetDParam(1, st->index);
dominik@899: 		newsitem = STR_A034_PLANE_CRASH_DIE_IN_FIREBALL;
dominik@899: 	}
dominik@899: 
dominik@899: 	SetDParam(1, st->index);
dominik@899: 	AddNewsItem(newsitem,
dominik@899: 		NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ACCIDENT, 0),
dominik@899: 		v->index,
dominik@899: 		0);
dominik@899: 
dominik@899: 	SndPlayVehicleFx(SND_12_EXPLOSION, v);
dominik@899: }
dominik@899: 
truelight@0: static void MaybeCrashAirplane(Vehicle *v)
truelight@0: {
tron@6413: 	Station *st = GetStation(v->u.air.targetairport);
truelight@0: 
belugas@6449: 	/* FIXME -- MaybeCrashAirplane -> increase crashing chances of very modern airplanes on smaller than AT_METROPOLITAN airports */
tron@6413: 	uint16 prob = 0x10000 / 1500;
tron@6358: 	if (st->Airport()->flags & AirportFTAClass::SHORT_STRIP &&
tron@6351: 			AircraftVehInfo(v->engine_type)->subtype & AIR_FAST &&
tron@6351: 			!_cheats.no_jetcrash.value) {
truelight@0: 		prob = 0x10000 / 20;
truelight@0: 	}
truelight@0: 
tron@2484: 	if (GB(Random(), 0, 16) > prob) return;
truelight@0: 
belugas@6449: 	/* Crash the airplane. Remove all goods stored at the station. */
tron@6413: 	for (uint i = 0; i != NUM_CARGO; i++) {
truelight@0: 		st->goods[i].rating = 1;
tron@2504: 		SB(st->goods[i].waiting_acceptance, 0, 12, 0);
truelight@0: 	}
truelight@0: 
dominik@899: 	CrashAirplane(v);
truelight@0: }
truelight@0: 
belugas@6449: /** we've landed and just arrived at a terminal */
truelight@0: static void AircraftEntersTerminal(Vehicle *v)
truelight@0: {
tron@2639: 	if (v->current_order.type == OT_GOTO_DEPOT) return;
truelight@0: 
tron@6413: 	Station *st = GetStation(v->u.air.targetairport);
truelight@0: 	v->last_station_visited = v->u.air.targetairport;
truelight@0: 
truelight@0: 	/* Check if station was ever visited before */
truelight@0: 	if (!(st->had_vehicle_of_type & HVOT_AIRCRAFT)) {
truelight@0: 		uint32 flags;
truelight@0: 
truelight@0: 		st->had_vehicle_of_type |= HVOT_AIRCRAFT;
tron@534: 		SetDParam(0, st->index);
belugas@6449: 		/* show newsitem of celebrating citizens */
truelight@0: 		flags = (v->owner == _local_player) ? NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) : NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_OTHER, 0);
truelight@0: 		AddNewsItem(
truelight@0: 			STR_A033_CITIZENS_CELEBRATE_FIRST,
truelight@0: 			flags,
truelight@0: 			v->index,
truelight@0: 			0);
truelight@0: 	}
truelight@0: 
tron@6413: 	Order old_order = v->current_order;
KUDr@5902: 	v->BeginLoading();
tron@555: 	v->current_order.flags = 0;
truelight@0: 
tron@555: 	if (old_order.type == OT_GOTO_STATION &&
tron@4527: 			v->current_order.dest == v->last_station_visited) {
tron@555: 		v->current_order.flags =
celestar@3872: 			(old_order.flags & (OF_FULL_LOAD | OF_UNLOAD | OF_TRANSFER)) | OF_NON_STOP;
truelight@0: 	}
truelight@0: 
truelight@0: 	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_INC);
peter1138@5211: 	LoadUnloadVehicle(v, true);
peter1138@3722: 	MarkAircraftDirty(v);
darkvater@755: 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
Celestar@1055: 	InvalidateWindowClasses(WC_AIRCRAFT_LIST);
truelight@0: }
truelight@0: 
truelight@0: static void AircraftLand(Vehicle *v)
truelight@0: {
truelight@0: 	v->sprite_width = v->sprite_height = 2;
truelight@0: }
truelight@0: 
truelight@0: static void AircraftLandAirplane(Vehicle *v)
truelight@0: {
truelight@0: 	AircraftLand(v);
peter1138@4656: 	if (!PlayVehicleSound(v, VSE_TOUCHDOWN)) {
peter1138@4656: 		SndPlayVehicleFx(SND_17_SKID_PLANE, v);
peter1138@4656: 	}
truelight@0: 	MaybeCrashAirplane(v);
truelight@0: }
truelight@0: 
celestar@6362: /**
celestar@6362:  * Find the entry point to an airport depending on direction which
celestar@6362:  * the airport is being approached from. Each airport can have up to
celestar@6362:  * four entry points for its approach system so that approaching
celestar@6362:  * aircraft do not fly through each other or are forced to do 180
celestar@6362:  * degree turns during the approach. The arrivals are grouped into
celestar@6362:  * four sectors dependent on the DiagDirection from which the airport
celestar@6362:  * is approached.
celestar@6362:  *
celestar@6362:  * @param v   The vehicle that is approaching the airport
celestar@6362:  * @param apc The Airport Class being approached.
celestar@6362:  * @returns   The index of the entry point
celestar@6362:  */
celestar@6362: static byte AircraftGetEntryPoint(const Vehicle *v, const AirportFTAClass *apc)
celestar@6362: {
celestar@6362: 	assert(v != NULL);
celestar@6362: 	assert(apc != NULL);
celestar@6362: 
tron@6363: 	const Station *st = GetStation(v->u.air.targetairport);
celestar@6362: 	/* Make sure we don't go to 0,0 if the airport has been removed. */
tron@6363: 	TileIndex tile = (st->airport_tile != 0) ? st->airport_tile : st->xy;
celestar@6362: 
tron@6363: 	int delta_x = v->x_pos - TileX(tile) * TILE_SIZE;
tron@6363: 	int delta_y = v->y_pos - TileY(tile) * TILE_SIZE;
celestar@6362: 
tron@6363: 	DiagDirection dir;
celestar@6362: 	if (abs(delta_y) < abs(delta_x)) {
celestar@6362: 		/* We are northeast or southwest of the airport */
tron@6363: 		dir = delta_x < 0 ? DIAGDIR_NE : DIAGDIR_SW;
tron@6363: 	} else {
tron@6363: 		/* We are northwest or southeast of the airport */
tron@6363: 		dir = delta_y < 0 ? DIAGDIR_NW : DIAGDIR_SE;
celestar@6362: 	}
tron@6363: 	return apc->entry_points[dir];
celestar@6362: }
celestar@6362: 
celestar@6362: 
belugas@6449: /** set the right pos when heading to other airports after takeoff */
truelight@0: static void AircraftNextAirportPos_and_Order(Vehicle *v)
truelight@0: {
tron@555: 	if (v->current_order.type == OT_GOTO_STATION ||
tron@555: 			v->current_order.type == OT_GOTO_DEPOT)
tron@4527: 		v->u.air.targetairport = v->current_order.dest;
truelight@0: 
tron@6358: 	const AirportFTAClass *apc = GetStation(v->u.air.targetairport)->Airport();
celestar@6362: 	v->u.air.pos = v->u.air.previous_pos = AircraftGetEntryPoint(v, apc);
truelight@0: }
truelight@0: 
truelight@0: static void AircraftLeaveHangar(Vehicle *v)
truelight@0: {
truelight@0: 	v->cur_speed = 0;
truelight@0: 	v->subspeed = 0;
truelight@0: 	v->progress = 0;
rubidium@5838: 	v->direction = DIR_SE;
truelight@0: 	v->vehstatus &= ~VS_HIDDEN;
truelight@0: 	{
truelight@0: 		Vehicle *u = v->next;
truelight@0: 		u->vehstatus &= ~VS_HIDDEN;
truelight@0: 
belugas@6449: 		/* Rotor blades */
tron@2639: 		u = u->next;
tron@2639: 		if (u != NULL) {
truelight@0: 			u->vehstatus &= ~VS_HIDDEN;
truelight@0: 			u->cur_speed = 80;
truelight@0: 		}
truelight@0: 	}
truelight@0: 
bjarni@578: 	VehicleServiceInDepot(v);
truelight@0: 	SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);
bjarni@4739: 	InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
Celestar@1055: 	InvalidateWindowClasses(WC_AIRCRAFT_LIST);
truelight@0: }
truelight@0: 
truelight@0: 
truelight@0: ////////////////////////////////////////////////////////////////////////////////
truelight@0: ///////////////////   AIRCRAFT MOVEMENT SCHEME  ////////////////////////////////
truelight@0: ////////////////////////////////////////////////////////////////////////////////
Darkvater@4842: static void AircraftEventHandler_EnterTerminal(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
truelight@0: 	AircraftEntersTerminal(v);
Darkvater@4842: 	v->u.air.state = apc->layout[v->u.air.pos].heading;
truelight@0: }
truelight@0: 
Darkvater@4842: static void AircraftEventHandler_EnterHangar(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
bjarni@4725: 	VehicleEnterDepot(v);
Darkvater@4842: 	v->u.air.state = apc->layout[v->u.air.pos].heading;
truelight@0: }
truelight@0: 
belugas@6449: /** In an Airport Hangar */
Darkvater@4842: static void AircraftEventHandler_InHangar(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
belugas@6449: 	/* if we just arrived, execute EnterHangar first */
truelight@0: 	if (v->u.air.previous_pos != v->u.air.pos) {
Darkvater@4842: 		AircraftEventHandler_EnterHangar(v, apc);
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
belugas@6449: 	/* if we were sent to the depot, stay there */
tron@555: 	if (v->current_order.type == OT_GOTO_DEPOT && (v->vehstatus & VS_STOPPED)) {
tron@555: 		v->current_order.type = OT_NOTHING;
tron@555: 		v->current_order.flags = 0;
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
tron@555: 	if (v->current_order.type != OT_GOTO_STATION &&
tron@555: 			v->current_order.type != OT_GOTO_DEPOT)
truelight@0: 		return;
truelight@0: 
belugas@6449: 	/* if the block of the next position is busy, stay put */
Darkvater@4842: 	if (AirportHasBlock(v, &apc->layout[v->u.air.pos], apc)) return;
truelight@0: 
belugas@6449: 	/* We are already at the target airport, we need to find a terminal */
tron@4527: 	if (v->current_order.dest == v->u.air.targetairport) {
belugas@6449: 		/* FindFreeTerminal:
belugas@6449: 		 * 1. Find a free terminal, 2. Occupy it, 3. Set the vehicle's state to that terminal */
Darkvater@6105: 		if (v->subtype == AIR_HELICOPTER) {
Darkvater@6105: 			if (!AirportFindFreeHelipad(v, apc)) return; // helicopter
Darkvater@6105: 		} else {
Darkvater@4842: 			if (!AirportFindFreeTerminal(v, apc)) return; // airplane
tron@2549: 		}
tron@2549: 	} else { // Else prepare for launch.
belugas@6449: 		/* airplane goto state takeoff, helicopter to helitakeoff */
Darkvater@6105: 		v->u.air.state = (v->subtype == AIR_HELICOPTER) ? HELITAKEOFF : TAKEOFF;
truelight@0: 	}
truelight@0: 	AircraftLeaveHangar(v);
Darkvater@4842: 	AirportMove(v, apc);
truelight@0: }
truelight@0: 
belugas@6449: /** At one of the Airport's Terminals */
Darkvater@4842: static void AircraftEventHandler_AtTerminal(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
belugas@6449: 	/* if we just arrived, execute EnterTerminal first */
truelight@0: 	if (v->u.air.previous_pos != v->u.air.pos) {
Darkvater@4842: 		AircraftEventHandler_EnterTerminal(v, apc);
belugas@6449: 		/* on an airport with helipads, a helicopter will always land there
belugas@6449: 		 * and get serviced at the same time - patch setting */
truelight@0: 		if (_patches.serviceathelipad) {
Darkvater@6105: 			if (v->subtype == AIR_HELICOPTER && apc->helipads != NULL) {
belugas@6449: 				/* an exerpt of ServiceAircraft, without the invisibility stuff */
truelight@0: 				v->date_of_last_service = _date;
truelight@0: 				v->breakdowns_since_last_service = 0;
tron@1926: 				v->reliability = GetEngine(v->engine_type)->reliability;
truelight@0: 				InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
truelight@0: 			}
truelight@0: 		}
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
tron@555: 	if (v->current_order.type == OT_NOTHING) return;
truelight@0: 
belugas@6449: 	/* if the block of the next position is busy, stay put */
Darkvater@4843: 	if (AirportHasBlock(v, &apc->layout[v->u.air.pos], apc)) return;
truelight@0: 
belugas@6449: 	/* airport-road is free. We either have to go to another airport, or to the hangar
belugas@6449: 	 * ---> start moving */
truelight@0: 
tron@555: 	switch (v->current_order.type) {
truelight@0: 		case OT_GOTO_STATION: // ready to fly to another airport
belugas@6449: 			/* airplane goto state takeoff, helicopter to helitakeoff */
Darkvater@6105: 			v->u.air.state = (v->subtype == AIR_HELICOPTER) ? HELITAKEOFF : TAKEOFF;
truelight@0: 			break;
truelight@0: 		case OT_GOTO_DEPOT:   // visit hangar for serivicing, sale, etc.
tron@4527: 			if (v->current_order.dest == v->u.air.targetairport) {
truelight@0: 				v->u.air.state = HANGAR;
tron@2639: 			} else {
Darkvater@6105: 				v->u.air.state = (v->subtype == AIR_HELICOPTER) ? HELITAKEOFF : TAKEOFF;
tron@2639: 			}
truelight@0: 			break;
truelight@0: 		default:  // orders have been deleted (no orders), goto depot and don't bother us
tron@555: 			v->current_order.type = OT_NOTHING;
tron@555: 			v->current_order.flags = 0;
truelight@0: 			v->u.air.state = HANGAR;
truelight@0: 	}
Darkvater@4842: 	AirportMove(v, apc);
truelight@0: }
truelight@0: 
Darkvater@4842: static void AircraftEventHandler_General(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
Darkvater@5568: 	assert("OK, you shouldn't be here, check your Airport Scheme!" && 0);
truelight@0: }
truelight@0: 
tron@6413: static void AircraftEventHandler_TakeOff(Vehicle *v, const AirportFTAClass *apc)
tron@6413: {
truelight@0: 	PlayAircraftSound(v); // play takeoffsound for airplanes
truelight@0: 	v->u.air.state = STARTTAKEOFF;
truelight@0: }
truelight@0: 
Darkvater@4842: static void AircraftEventHandler_StartTakeOff(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
truelight@0: 	v->sprite_width = v->sprite_height = 24; // ??? no idea what this is
truelight@0: 	v->u.air.state = ENDTAKEOFF;
truelight@0: }
truelight@0: 
Darkvater@4842: static void AircraftEventHandler_EndTakeOff(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
truelight@0: 	v->u.air.state = FLYING;
belugas@6449: 	/* get the next position to go to, differs per airport */
truelight@0: 	AircraftNextAirportPos_and_Order(v);
truelight@0: }
truelight@0: 
Darkvater@4842: static void AircraftEventHandler_HeliTakeOff(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
tron@2475: 	const Player* p = GetPlayer(v->owner);
truelight@0: 	v->sprite_width = v->sprite_height = 24; // ??? no idea what this is
truelight@0: 	v->u.air.state = FLYING;
belugas@6449: 	/* get the next position to go to, differs per airport */
truelight@0: 	AircraftNextAirportPos_and_Order(v);
bjarni@1135: 
belugas@6449: 	/* check if the aircraft needs to be replaced or renewed and send it to a hangar if needed
belugas@6449: 	 * unless it is due for renewal but the engine is no longer available */
tron@2639: 	if (v->owner == _local_player && (
peter1138@2848: 				EngineHasReplacementForPlayer(p, v->engine_type) ||
bjarni@4111: 				((p->engine_renew && v->age - v->max_age > p->engine_renew_months * 30) &&
bjarni@4111: 				HASBIT(GetEngine(v->engine_type)->player_avail, _local_player))
tron@2639: 			)) {
bjarni@1520: 		_current_player = _local_player;
bjarni@4506: 		DoCommandP(v->tile, v->index, DEPOT_SERVICE | DEPOT_LOCATE_HANGAR, NULL, CMD_SEND_AIRCRAFT_TO_HANGAR | CMD_SHOW_NO_ERROR);
bjarni@1520: 		_current_player = OWNER_NONE;
bjarni@1135: 	}
truelight@0: }
truelight@0: 
Darkvater@4842: static void AircraftEventHandler_Flying(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
tron@6413: 	Station *st = GetStation(v->u.air.targetairport);
truelight@0: 
belugas@6449: 	/* runway busy or not allowed to use this airstation, circle */
KUDr@6353: 	if (apc->flags & (v->subtype == AIR_HELICOPTER ? AirportFTAClass::HELICOPTERS : AirportFTAClass::AIRPLANES) &&
tron@2639: 			st->airport_tile != 0 &&
tron@2639: 			(st->owner == OWNER_NONE || st->owner == v->owner)) {
truelight@0: 		// {32,FLYING,NOTHING_block,37}, {32,LANDING,N,33}, {32,HELILANDING,N,41},
truelight@0: 		// if it is an airplane, look for LANDING, for helicopter HELILANDING
truelight@0: 		// it is possible to choose from multiple landing runways, so loop until a free one is found
tron@6413: 		byte landingtype = (v->subtype == AIR_HELICOPTER) ? HELILANDING : LANDING;
tron@6413: 		const AirportFTA *current = apc->layout[v->u.air.pos].next;
truelight@0: 		while (current != NULL) {
truelight@0: 			if (current->heading == landingtype) {
belugas@6449: 				/* save speed before, since if AirportHasBlock is false, it resets them to 0
belugas@6449: 				 * we don't want that for plane in air
belugas@6449: 				 * hack for speed thingie */
tron@6413: 				uint16 tcur_speed = v->cur_speed;
tron@6413: 				uint16 tsubspeed = v->subspeed;
Darkvater@4842: 				if (!AirportHasBlock(v, current, apc)) {
truelight@0: 					v->u.air.state = landingtype; // LANDING / HELILANDING
belugas@6449: 					/* it's a bit dirty, but I need to set position to next position, otherwise
belugas@6449: 					 * if there are multiple runways, plane won't know which one it took (because
belugas@6449: 					 * they all have heading LANDING). And also occupy that block! */
truelight@0: 					v->u.air.pos = current->next_position;
Darkvater@4842: 					SETBITS(st->airport_flags, apc->layout[v->u.air.pos].block);
truelight@0: 					return;
truelight@0: 				}
truelight@0: 				v->cur_speed = tcur_speed;
truelight@0: 				v->subspeed = tsubspeed;
truelight@0: 			}
Darkvater@4842: 			current = current->next;
truelight@0: 		}
truelight@0: 	}
truelight@0: 	v->u.air.state = FLYING;
Darkvater@4842: 	v->u.air.pos = apc->layout[v->u.air.pos].next_position;
truelight@0: }
truelight@0: 
Darkvater@4842: static void AircraftEventHandler_Landing(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
truelight@0: 	AircraftLandAirplane(v);  // maybe crash airplane
truelight@0: 	v->u.air.state = ENDLANDING;
belugas@6449: 	/* check if the aircraft needs to be replaced or renewed and send it to a hangar if needed */
bjarni@1195: 	if (v->current_order.type != OT_GOTO_DEPOT && v->owner == _local_player) {
belugas@6449: 		/* only the vehicle owner needs to calculate the rest (locally) */
tron@6413: 		const Player* p = GetPlayer(v->owner);
peter1138@2848: 		if (EngineHasReplacementForPlayer(p, v->engine_type) ||
bjarni@2293: 			(p->engine_renew && v->age - v->max_age > (p->engine_renew_months * 30))) {
belugas@6449: 			/* send the aircraft to the hangar at next airport */
bjarni@1195: 			_current_player = _local_player;
bjarni@4506: 			DoCommandP(v->tile, v->index, DEPOT_SERVICE, NULL, CMD_SEND_AIRCRAFT_TO_HANGAR | CMD_SHOW_NO_ERROR);
bjarni@1195: 			_current_player = OWNER_NONE;
bjarni@1195: 		}
bjarni@1195: 	}
truelight@0: }
truelight@0: 
Darkvater@4842: static void AircraftEventHandler_HeliLanding(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
truelight@0: 	AircraftLand(v); // helicopters don't crash
truelight@0: 	v->u.air.state = HELIENDLANDING;
truelight@0: }
truelight@0: 
Darkvater@4842: static void AircraftEventHandler_EndLanding(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
belugas@6449: 	/* next block busy, don't do a thing, just wait */
Darkvater@4842: 	if (AirportHasBlock(v, &apc->layout[v->u.air.pos], apc)) return;
truelight@0: 
belugas@6449: 	/* if going to terminal (OT_GOTO_STATION) choose one
belugas@6449: 	 * 1. in case all terminals are busy AirportFindFreeTerminal() returns false or
belugas@6449: 	 * 2. not going for terminal (but depot, no order),
belugas@6449: 	 * --> get out of the way to the hangar. */
tron@555: 	if (v->current_order.type == OT_GOTO_STATION) {
Darkvater@4842: 		if (AirportFindFreeTerminal(v, apc)) return;
truelight@0: 	}
truelight@0: 	v->u.air.state = HANGAR;
truelight@0: 
truelight@0: }
truelight@0: 
Darkvater@4842: static void AircraftEventHandler_HeliEndLanding(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
belugas@6449: 	/*  next block busy, don't do a thing, just wait */
Darkvater@4842: 	if (AirportHasBlock(v, &apc->layout[v->u.air.pos], apc)) return;
truelight@0: 
belugas@6449: 	/* if going to helipad (OT_GOTO_STATION) choose one. If airport doesn't have helipads, choose terminal
belugas@6449: 	 * 1. in case all terminals/helipads are busy (AirportFindFreeHelipad() returns false) or
belugas@6449: 	 * 2. not going for terminal (but depot, no order),
belugas@6449: 	 * --> get out of the way to the hangar IF there are terminals on the airport.
belugas@6449: 	 * --> else TAKEOFF
belugas@6449: 	 * the reason behind this is that if an airport has a terminal, it also has a hangar. Airplanes
belugas@6449: 	 * must go to a hangar. */
tron@555: 	if (v->current_order.type == OT_GOTO_STATION) {
Darkvater@4842: 		if (AirportFindFreeHelipad(v, apc)) return;
truelight@0: 	}
Darkvater@4842: 	v->u.air.state = (apc->nof_depots != 0) ? HANGAR : HELITAKEOFF;
truelight@0: }
truelight@0: 
Darkvater@4842: typedef void AircraftStateHandler(Vehicle *v, const AirportFTAClass *apc);
truelight@0: static AircraftStateHandler * const _aircraft_state_handlers[] = {
rubidium@4344: 	AircraftEventHandler_General,        // TO_ALL         =  0
rubidium@4344: 	AircraftEventHandler_InHangar,       // HANGAR         =  1
rubidium@4344: 	AircraftEventHandler_AtTerminal,     // TERM1          =  2
rubidium@4344: 	AircraftEventHandler_AtTerminal,     // TERM2          =  3
rubidium@4344: 	AircraftEventHandler_AtTerminal,     // TERM3          =  4
rubidium@4344: 	AircraftEventHandler_AtTerminal,     // TERM4          =  5
rubidium@4344: 	AircraftEventHandler_AtTerminal,     // TERM5          =  6
rubidium@4344: 	AircraftEventHandler_AtTerminal,     // TERM6          =  7
rubidium@4344: 	AircraftEventHandler_AtTerminal,     // HELIPAD1       =  8
rubidium@4344: 	AircraftEventHandler_AtTerminal,     // HELIPAD2       =  9
rubidium@4344: 	AircraftEventHandler_TakeOff,        // TAKEOFF        = 10
rubidium@4344: 	AircraftEventHandler_StartTakeOff,   // STARTTAKEOFF   = 11
rubidium@4344: 	AircraftEventHandler_EndTakeOff,     // ENDTAKEOFF     = 12
rubidium@4344: 	AircraftEventHandler_HeliTakeOff,    // HELITAKEOFF    = 13
rubidium@4344: 	AircraftEventHandler_Flying,         // FLYING         = 14
rubidium@4344: 	AircraftEventHandler_Landing,        // LANDING        = 15
rubidium@4344: 	AircraftEventHandler_EndLanding,     // ENDLANDING     = 16
rubidium@4344: 	AircraftEventHandler_HeliLanding,    // HELILANDING    = 17
rubidium@4344: 	AircraftEventHandler_HeliEndLanding, // HELIENDLANDING = 18
rubidium@4344: 	AircraftEventHandler_AtTerminal,     // TERM7          = 19
rubidium@4344: 	AircraftEventHandler_AtTerminal,     // TERM8          = 20
rubidium@4344: 	AircraftEventHandler_AtTerminal,     // HELIPAD3       = 21
rubidium@4344: 	AircraftEventHandler_AtTerminal,     // HELIPAD4       = 22
truelight@0: };
truelight@0: 
Darkvater@4842: static void AirportClearBlock(const Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
belugas@6449: 	/* we have left the previous block, and entered the new one. Free the previous block */
Darkvater@4842: 	if (apc->layout[v->u.air.previous_pos].block != apc->layout[v->u.air.pos].block) {
rubidium@4344: 		Station *st = GetStation(v->u.air.targetairport);
tron@2639: 
Darkvater@4842: 		CLRBITS(st->airport_flags, apc->layout[v->u.air.previous_pos].block);
truelight@0: 	}
truelight@0: }
truelight@0: 
tron@6425: static void AirportGoToNextPosition(Vehicle *v)
truelight@0: {
belugas@6449: 	/* if aircraft is not in position, wait until it is */
tron@2549: 	if (!AircraftController(v)) return;
truelight@0: 
tron@6425: 	const AirportFTAClass *apc = GetStation(v->u.air.targetairport)->Airport();
tron@6425: 
Darkvater@4842: 	AirportClearBlock(v, apc);
Darkvater@4842: 	AirportMove(v, apc); // move aircraft to next position
truelight@0: }
truelight@0: 
belugas@6449: /* gets pos from vehicle and next orders */
Darkvater@4842: static bool AirportMove(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
belugas@6449: 	/* error handling */
Darkvater@4842: 	if (v->u.air.pos >= apc->nofelements) {
Darkvater@5568: 		DEBUG(misc, 0, "[Ap] position %d is not valid for current airport. Max position is %d", v->u.air.pos, apc->nofelements-1);
Darkvater@4842: 		assert(v->u.air.pos < apc->nofelements);
truelight@0: 	}
truelight@0: 
tron@6413: 	const AirportFTA *current = &apc->layout[v->u.air.pos];
belugas@6449: 	/* we have arrived in an important state (eg terminal, hangar, etc.) */
truelight@0: 	if (current->heading == v->u.air.state) {
tron@6413: 		byte prev_pos = v->u.air.pos; // location could be changed in state, so save it before-hand
Darkvater@4842: 		_aircraft_state_handlers[v->u.air.state](v, apc);
tron@2549: 		if (v->u.air.state != FLYING) v->u.air.previous_pos = prev_pos;
truelight@0: 		return true;
truelight@0: 	}
truelight@0: 
truelight@0: 	v->u.air.previous_pos = v->u.air.pos; // save previous location
truelight@0: 
belugas@6449: 	/* there is only one choice to move to */
Darkvater@4842: 	if (current->next == NULL) {
Darkvater@4842: 		if (AirportSetBlocks(v, current, apc)) {
truelight@0: 			v->u.air.pos = current->next_position;
truelight@0: 		} // move to next position
celestar@3579: 		return false;
truelight@0: 	}
truelight@0: 
belugas@6449: 	/* there are more choices to choose from, choose the one that
belugas@6449: 	 * matches our heading */
truelight@0: 	do {
truelight@0: 		if (v->u.air.state == current->heading || current->heading == TO_ALL) {
Darkvater@4842: 			if (AirportSetBlocks(v, current, apc)) {
tron@2639: 				v->u.air.pos = current->next_position;
tron@2639: 			} // move to next position
celestar@3579: 			return false;
truelight@0: 		}
Darkvater@4842: 		current = current->next;
truelight@0: 	} while (current != NULL);
truelight@0: 
celestar@6362: 	DEBUG(misc, 0, "[Ap] cannot move further on Airport! (pos %d state %d) for vehicle %d", v->u.air.pos, v->u.air.state, v->index);
truelight@0: 	assert(0);
truelight@0: 	return false;
truelight@0: }
truelight@0: 
belugas@6449: /*  returns true if the road ahead is busy, eg. you must wait before proceeding */
Darkvater@4843: static bool AirportHasBlock(Vehicle *v, const AirportFTA *current_pos, const AirportFTAClass *apc)
truelight@0: {
Darkvater@4843: 	const AirportFTA *reference = &apc->layout[v->u.air.pos];
Darkvater@4843: 	const AirportFTA *next = &apc->layout[current_pos->next_position];
truelight@0: 
belugas@6449: 	/* same block, then of course we can move */
Darkvater@4842: 	if (apc->layout[current_pos->position].block != next->block) {
Darkvater@4843: 		const Station *st = GetStation(v->u.air.targetairport);
celestar@6337: 		uint64 airport_flags = next->block;
tron@2630: 
belugas@6449: 		/* check additional possible extra blocks */
truelight@0: 		if (current_pos != reference && current_pos->block != NOTHING_block) {
truelight@0: 			airport_flags |= current_pos->block;
truelight@0: 		}
truelight@0: 
truelight@0: 		if (HASBITS(st->airport_flags, airport_flags)) {
truelight@0: 			v->cur_speed = 0;
truelight@0: 			v->subspeed = 0;
truelight@0: 			return true;
truelight@0: 		}
truelight@0: 	}
truelight@0: 	return false;
truelight@0: }
truelight@0: 
belugas@6449: /**
belugas@6449:  * ...
belugas@6449:  * @param v airplane that requires the operation
belugas@6449:  * @param currentpos of the vehicle in the list of blocks
belugas@6449:  * @param apc airport on which block is requsted to be set
belugas@6449:  * @returns true on success. Eg, next block was free and we have occupied it
belugas@6449:  */
tron@6413: static bool AirportSetBlocks(Vehicle *v, const AirportFTA *current_pos, const AirportFTAClass *apc)
truelight@0: {
tron@6413: 	const AirportFTA *next = &apc->layout[current_pos->next_position];
tron@6413: 	const AirportFTA *reference = &apc->layout[v->u.air.pos];
truelight@0: 
belugas@6449: 	/* if the next position is in another block, check it and wait until it is free */
Darkvater@4842: 	if ((apc->layout[current_pos->position].block & next->block) != next->block) {
celestar@6337: 		uint64 airport_flags = next->block;
belugas@6449: 		/* search for all all elements in the list with the same state, and blocks != N
belugas@6449: 		 * this means more blocks should be checked/set */
tron@6413: 		const AirportFTA *current = current_pos;
Darkvater@4842: 		if (current == reference) current = current->next;
truelight@0: 		while (current != NULL) {
truelight@0: 			if (current->heading == current_pos->heading && current->block != 0) {
truelight@0: 				airport_flags |= current->block;
truelight@0: 				break;
truelight@0: 			}
Darkvater@4842: 			current = current->next;
truelight@0: 		};
truelight@0: 
belugas@6449: 		/* if the block to be checked is in the next position, then exclude that from
belugas@6449: 		 * checking, because it has been set by the airplane before */
tron@2549: 		if (current_pos->block == next->block) airport_flags ^= next->block;
truelight@0: 
tron@6413: 		Station* st = GetStation(v->u.air.targetairport);
truelight@0: 		if (HASBITS(st->airport_flags, airport_flags)) {
truelight@0: 			v->cur_speed = 0;
truelight@0: 			v->subspeed = 0;
truelight@0: 			return false;
truelight@0: 		}
truelight@0: 
truelight@0: 		if (next->block != NOTHING_block) {
truelight@0: 			SETBITS(st->airport_flags, airport_flags); // occupy next block
truelight@0: 		}
truelight@0: 	}
truelight@0: 	return true;
truelight@0: }
truelight@0: 
truelight@0: static bool FreeTerminal(Vehicle *v, byte i, byte last_terminal)
truelight@0: {
truelight@919: 	Station *st = GetStation(v->u.air.targetairport);
truelight@0: 	for (; i < last_terminal; i++) {
richk@4059: 		if (!HASBIT(st->airport_flags, _airport_terminal_flag[i])) {
belugas@6449: 			/* TERMINAL# HELIPAD# */
richk@4059: 			v->u.air.state = _airport_terminal_state[i]; // start moving to that terminal/helipad
richk@4059: 			SETBIT(st->airport_flags, _airport_terminal_flag[i]); // occupy terminal/helipad
truelight@0: 			return true;
truelight@0: 		}
truelight@0: 	}
truelight@0: 	return false;
truelight@0: }
truelight@0: 
Darkvater@4842: static uint GetNumTerminals(const AirportFTAClass *apc)
celestar@950: {
tron@2639: 	uint num = 0;
tron@1019: 
tron@6413: 	for (uint i = apc->terminals[0]; i > 0; i--) num += apc->terminals[i];
tron@1019: 
celestar@950: 	return num;
celestar@950: }
celestar@950: 
Darkvater@4842: static bool AirportFindFreeTerminal(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
truelight@0: 	/* example of more terminalgroups
rubidium@4549: 	 * {0,HANGAR,NOTHING_block,1}, {0,255,TERM_GROUP1_block,0}, {0,255,TERM_GROUP2_ENTER_block,1}, {0,0,N,1},
rubidium@4549: 	 * Heading 255 denotes a group. We see 2 groups here:
rubidium@4549: 	 * 1. group 0 -- TERM_GROUP1_block (check block)
rubidium@4549: 	 * 2. group 1 -- TERM_GROUP2_ENTER_block (check block)
rubidium@4549: 	 * First in line is checked first, group 0. If the block (TERM_GROUP1_block) is free, it
rubidium@4549: 	 * looks at the corresponding terminals of that group. If no free ones are found, other
rubidium@4549: 	 * possible groups are checked (in this case group 1, since that is after group 0). If that
rubidium@4549: 	 * fails, then attempt fails and plane waits
rubidium@4549: 	 */
Darkvater@4842: 	if (apc->terminals[0] > 1) {
tron@6413: 		const Station *st = GetStation(v->u.air.targetairport);
tron@6413: 		const AirportFTA *temp = apc->layout[v->u.air.pos].next;
Darkvater@4843: 
truelight@0: 		while (temp != NULL) {
truelight@0: 			if (temp->heading == 255) {
truelight@0: 				if (!HASBITS(st->airport_flags, temp->block)) {
belugas@6449: 					/* read which group do we want to go to?
belugas@6449: 					 * (the first free group) */
tron@6413: 					uint target_group = temp->next_position + 1;
celestar@950: 
belugas@6449: 					/* at what terminal does the group start?
belugas@6449: 					 * that means, sum up all terminals of
belugas@6449: 					 * groups with lower number */
tron@6413: 					uint group_start = 0;
tron@6413: 					for (uint i = 1; i < target_group; i++) {
Darkvater@4842: 						group_start += apc->terminals[i];
tron@6413: 					}
celestar@950: 
tron@6413: 					uint group_end = group_start + apc->terminals[target_group];
tron@2549: 					if (FreeTerminal(v, group_start, group_end)) return true;
truelight@0: 				}
tron@2549: 			} else {
tron@2549: 				/* once the heading isn't 255, we've exhausted the possible blocks.
tron@2549: 				 * So we cannot move */
tron@2549: 				return false;
truelight@0: 			}
Darkvater@4842: 			temp = temp->next;
truelight@0: 		}
truelight@0: 	}
truelight@0: 
belugas@6449: 	/* if there is only 1 terminalgroup, all terminals are checked (starting from 0 to max) */
Darkvater@4842: 	return FreeTerminal(v, 0, GetNumTerminals(apc));
truelight@0: }
truelight@0: 
Darkvater@4842: static uint GetNumHelipads(const AirportFTAClass *apc)
celestar@950: {
tron@2639: 	uint num = 0;
tron@1019: 
tron@6413: 	for (uint i = apc->helipads[0]; i > 0; i--) num += apc->helipads[i];
tron@1019: 
celestar@950: 	return num;
celestar@950: }
celestar@950: 
celestar@950: 
Darkvater@4842: static bool AirportFindFreeHelipad(Vehicle *v, const AirportFTAClass *apc)
truelight@0: {
belugas@6449: 	/* if an airport doesn't have helipads, use terminals */
Darkvater@4842: 	if (apc->helipads == NULL) return AirportFindFreeTerminal(v, apc);
truelight@0: 
belugas@6449: 	/* if there are more helicoptergroups, pick one, just as in AirportFindFreeTerminal() */
Darkvater@4842: 	if (apc->helipads[0] > 1) {
tron@4077: 		const Station* st = GetStation(v->u.air.targetairport);
Darkvater@4842: 		const AirportFTA* temp = apc->layout[v->u.air.pos].next;
tron@4077: 
truelight@0: 		while (temp != NULL) {
truelight@0: 			if (temp->heading == 255) {
truelight@0: 				if (!HASBITS(st->airport_flags, temp->block)) {
celestar@950: 
belugas@6449: 					/* read which group do we want to go to?
belugas@6449: 					 * (the first free group) */
tron@6413: 					uint target_group = temp->next_position + 1;
celestar@950: 
belugas@6449: 					/* at what terminal does the group start?
belugas@6449: 					 * that means, sum up all terminals of
belugas@6449: 					 * groups with lower number */
tron@6413: 					uint group_start = 0;
tron@6413: 					for (uint i = 1; i < target_group; i++) {
Darkvater@4842: 						group_start += apc->helipads[i];
tron@6413: 					}
celestar@950: 
tron@6413: 					uint group_end = group_start + apc->helipads[target_group];
tron@2549: 					if (FreeTerminal(v, group_start, group_end)) return true;
truelight@0: 				}
tron@2549: 			} else {
tron@2549: 				/* once the heading isn't 255, we've exhausted the possible blocks.
tron@2549: 				 * So we cannot move */
tron@2549: 				return false;
truelight@0: 			}
Darkvater@4842: 			temp = temp->next;
truelight@0: 		}
tron@2549: 	} else {
belugas@6449: 		/* only 1 helicoptergroup, check all helipads
belugas@6449: 		 * The blocks for helipads start after the last terminal (MAX_TERMINALS) */
Darkvater@4842: 		return FreeTerminal(v, MAX_TERMINALS, GetNumHelipads(apc) + MAX_TERMINALS);
truelight@0: 	}
rubidium@4434: 	return false; // it shouldn't get here anytime, but just to be sure
truelight@0: }
truelight@0: 
truelight@0: static void AircraftEventHandler(Vehicle *v, int loop)
truelight@0: {
truelight@0: 	v->tick_counter++;
truelight@0: 
truelight@0: 	if (v->vehstatus & VS_CRASHED) {
truelight@0: 		HandleCrashedAircraft(v);
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
tron@2639: 	if (v->vehstatus & VS_STOPPED) return;
truelight@0: 
truelight@0: 	/* aircraft is broken down? */
truelight@0: 	if (v->breakdown_ctr != 0) {
truelight@0: 		if (v->breakdown_ctr <= 2) {
truelight@0: 			HandleBrokenAircraft(v);
truelight@0: 		} else {
truelight@0: 			v->breakdown_ctr--;
truelight@0: 		}
truelight@0: 	}
truelight@0: 
truelight@0: 	HandleAircraftSmoke(v);
truelight@0: 	ProcessAircraftOrder(v);
truelight@0: 	HandleAircraftLoading(v, loop);
truelight@0: 
tron@2639: 	if (v->current_order.type >= OT_LOADING) return;
truelight@0: 
tron@6425: 	AirportGoToNextPosition(v);
truelight@0: }
truelight@0: 
truelight@0: void Aircraft_Tick(Vehicle *v)
truelight@0: {
Darkvater@6105: 	if (!IsNormalAircraft(v)) return;
truelight@0: 
Darkvater@6105: 	if (v->subtype == AIR_HELICOPTER) HelicopterTickHandler(v);
truelight@0: 
truelight@0: 	AgeAircraftCargo(v);
truelight@0: 
celestar@6519: 	for (uint i = 0; i != 2; i++) {
truelight@0: 		AircraftEventHandler(v, i);
truelight@0: 		if (v->type != VEH_Aircraft) // In case it was deleted
truelight@0: 			break;
truelight@0: 	}
truelight@0: }
truelight@0: 
celestar@950: 
belugas@6449: /** need to be called to load aircraft from old version */
tron@1093: void UpdateOldAircraft(void)
truelight@0: {
belugas@6449: 	/* set airport_flags to 0 for all airports just to be sure */
truelight@0: 	Station *st;
truelight@0: 	FOR_ALL_STATIONS(st) {
truelight@0: 		st->airport_flags = 0; // reset airport
truelight@0: 	}
truelight@0: 
tron@6413: 	Vehicle *v_oldstyle;
truelight@0: 	FOR_ALL_VEHICLES(v_oldstyle) {
belugas@6449: 	/* airplane has another vehicle with subtype 4 (shadow), helicopter also has 3 (rotor)
belugas@6449: 	 * skip those */
Darkvater@6105: 		if (v_oldstyle->type == VEH_Aircraft && IsNormalAircraft(v_oldstyle)) {
belugas@6449: 			/* airplane in terminal stopped doesn't hurt anyone, so goto next */
tron@2639: 			if (v_oldstyle->vehstatus & VS_STOPPED && v_oldstyle->u.air.state == 0) {
truelight@0: 				v_oldstyle->u.air.state = HANGAR;
truelight@0: 				continue;
truelight@0: 			}
truelight@0: 
truelight@0: 			AircraftLeaveHangar(v_oldstyle); // make airplane visible if it was in a depot for example
truelight@0: 			v_oldstyle->vehstatus &= ~VS_STOPPED; // make airplane moving
truelight@0: 			v_oldstyle->u.air.state = FLYING;
truelight@0: 			AircraftNextAirportPos_and_Order(v_oldstyle); // move it to the entry point of the airport
tron@6479: 			GetNewVehiclePosResult gp = GetNewVehiclePos(v_oldstyle);
truelight@0: 			v_oldstyle->tile = 0; // aircraft in air is tile=0
truelight@193: 
belugas@6449: 			/* correct speed of helicopter-rotors */
Darkvater@6105: 			if (v_oldstyle->subtype == AIR_HELICOPTER) v_oldstyle->next->next->cur_speed = 32;
truelight@0: 
belugas@6449: 			/* set new position x,y,z */
truelight@0: 			SetAircraftPosition(v_oldstyle, gp.x, gp.y, GetAircraftFlyingAltitude(v_oldstyle));
truelight@0: 		}
truelight@0: 	}
truelight@0: }
truelight@0: 
tron@6413: void UpdateAirplanesOnNewStation(const Station *st)
truelight@0: {
belugas@6449: 	/* only 1 station is updated per function call, so it is enough to get entry_point once */
tron@6358: 	const AirportFTAClass *ap = st->Airport();
tron@6413: 
tron@6413: 	Vehicle *v;
truelight@0: 	FOR_ALL_VEHICLES(v) {
Darkvater@6105: 		if (v->type == VEH_Aircraft && IsNormalAircraft(v)) {
rubidium@4434: 			if (v->u.air.targetairport == st->index) { // if heading to this airport
rubidium@4434: 				/* update position of airplane. If plane is not flying, landing, or taking off
belugas@6449: 				 *you cannot delete airport, so it doesn't matter */
rubidium@4434: 				if (v->u.air.state >= FLYING) { // circle around
celestar@6362: 					v->u.air.pos = v->u.air.previous_pos = AircraftGetEntryPoint(v, ap);
truelight@0: 					v->u.air.state = FLYING;
belugas@6449: 					/* landing plane needs to be reset to flying height (only if in pause mode upgrade,
belugas@6449: 					 * in normal mode, plane is reset in AircraftController. It doesn't hurt for FLYING */
tron@6479: 					GetNewVehiclePosResult gp = GetNewVehiclePos(v);
belugas@6449: 					/* set new position x,y,z */
truelight@0: 					SetAircraftPosition(v, gp.x, gp.y, GetAircraftFlyingAltitude(v));
tron@2549: 				} else {
truelight@0: 					assert(v->u.air.state == ENDTAKEOFF || v->u.air.state == HELITAKEOFF);
tron@6413: 					byte takeofftype = (v->subtype == AIR_HELICOPTER) ? HELITAKEOFF : ENDTAKEOFF;
belugas@6449: 					/* search in airportdata for that heading
belugas@6449: 					 * easiest to do, since this doesn't happen a lot */
tron@6413: 					for (uint cnt = 0; cnt < ap->nofelements; cnt++) {
truelight@0: 						if (ap->layout[cnt].heading == takeofftype) {
truelight@0: 							v->u.air.pos = ap->layout[cnt].position;
truelight@0: 							break;
truelight@0: 						}
truelight@0: 					}
truelight@0: 				}
truelight@0: 			}
truelight@0: 		}
truelight@0: 	}
truelight@0: }