tron@2186: /* $Id$ */ tron@2186: belugas@6117: /** @file aircraft_cmd.cpp belugas@6117: * This file deals with aircraft and airport movements functionalities */ belugas@6117: truelight@0: #include "stdafx.h" Darkvater@1891: #include "openttd.h" tron@3963: #include "aircraft.h" tron@1299: #include "debug.h" maedhros@6453: #include "landscape.h" tron@3315: #include "station_map.h" maedhros@6980: #include "timetable.h" rubidium@8962: #include "depot_func.h" rubidium@8763: #include "news_func.h" Darkvater@5854: #include "aircraft.h" truelight@0: #include "airport.h" matthijs@1752: #include "vehicle_gui.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" bjarni@5972: #include "spritecache.h" peter1138@6340: #include "cargotype.h" rubidium@8114: #include "strings_func.h" rubidium@8116: #include "command_func.h" rubidium@8131: #include "window_func.h" rubidium@8140: #include "date_func.h" rubidium@8144: #include "vehicle_func.h" rubidium@8157: #include "sound_func.h" rubidium@8131: #include "functions.h" rubidium@8211: #include "variables.h" rubidium@8965: #include "cheat_func.h" rubidium@8212: #include "autoreplace_func.h" rubidium@8212: #include "autoreplace_gui.h" rubidium@8224: #include "gfx_func.h" rubidium@10208: #include "company_func.h" rubidium@8270: #include "settings_type.h" rubidium@8784: #include "order_func.h" rubidium@9009: #include "effectvehicle_func.h" truelight@0: rubidium@8264: #include "table/strings.h" rubidium@8264: #include "table/sprites.h" rubidium@8264: rubidium@6558: void Aircraft::UpdateDeltaXY(Direction direction) rubidium@6558: { rubidium@6558: uint32 x; rubidium@6558: #define MKIT(a, b, c, d) ((a & 0xFF) << 24) | ((b & 0xFF) << 16) | ((c & 0xFF) << 8) | ((d & 0xFF) << 0) rubidium@6558: switch (this->subtype) { rubidium@6558: default: NOT_REACHED(); rubidium@6558: case AIR_AIRCRAFT: rubidium@6558: case AIR_HELICOPTER: rubidium@6558: switch (this->u.air.state) { rubidium@6558: case ENDTAKEOFF: rubidium@6558: case LANDING: rubidium@6558: case HELILANDING: rubidium@6558: case FLYING: x = MKIT(24, 24, -1, -1); break; rubidium@6558: default: x = MKIT( 2, 2, -1, -1); break; rubidium@6558: } frosch@8793: this->z_extent = 5; rubidium@6558: break; frosch@8793: case AIR_SHADOW: this->z_extent = 1; x = MKIT(2, 2, 0, 0); break; frosch@8793: case AIR_ROTOR: this->z_extent = 1; x = MKIT(2, 2, -1, -1); break; rubidium@6558: } rubidium@6558: #undef MKIT rubidium@6558: rubidium@6558: this->x_offs = GB(x, 0, 8); rubidium@6558: this->y_offs = GB(x, 8, 8); frosch@8793: this->x_extent = GB(x, 16, 8); frosch@8793: this->y_extent = GB(x, 24, 8); rubidium@6558: } rubidium@6558: rubidium@6558: belugas@6123: /** this maps the terminal to its corresponding state and block flag belugas@6123: * currently set for 10 terms, 4 helipads */ truelight@5754: static const byte _airport_terminal_state[] = {2, 3, 4, 5, 6, 7, 19, 20, 0, 0, 8, 9, 21, 22}; truelight@5754: static const byte _airport_terminal_flag[] = {0, 1, 2, 3, 4, 5, 22, 23, 0, 0, 6, 7, 24, 25}; truelight@5754: Darkvater@4842: static bool AirportMove(Vehicle *v, const AirportFTAClass *apc); tron@6087: 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: rubidium@8891: 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@6123: /** 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@6123: /** Find the nearest hangar to v rubidium@10207: * INVALID_STATION is returned, if the company does not have any suitable tron@1532: * airports (like helipads only) belugas@6123: * @param v vehicle looking for a hangar belugas@6123: * @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@6025: if (st->owner != v->owner || !(st->facilities & FACIL_AIRPORT)) continue; bjarni@1204: tron@6032: const AirportFTAClass *afc = st->Airport(); tron@6025: if (afc->nof_depots == 0 || ( tron@6025: /* don't crash the plane if we know it can't land at the airport */ tron@6025: afc->flags & AirportFTAClass::SHORT_STRIP && tron@6025: AircraftVehInfo(v->engine_type)->subtype & AIR_FAST && tron@6025: !_cheats.no_jetcrash.value tron@6025: )) { tron@6025: continue; tron@6025: } tron@1532: belugas@6123: /* v->tile can't be used here, when aircraft is flying v->tile is set to 0 */ tron@6025: uint distance = DistanceSquare(vtile, st->airport_tile); tron@6025: if (distance < best || index == INVALID_STATION) { tron@6025: best = distance; tron@6025: index = st->index; bjarni@1194: } bjarni@1194: } tron@1532: return index; bjarni@1194: } bjarni@1194: Darkvater@1614: #if 0 belugas@6123: /** Check if given vehicle has a goto hangar in his orders belugas@6123: * @param v vehicle to inquiry belugas@6123: * @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@6123: /* If an airport doesn't have a hangar, skip it */ tron@6032: 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: peter1138@9022: SpriteID Aircraft::GetImage(Direction direction) const truelight@0: { peter1138@9022: uint8 spritenum = this->spritenum; truelight@0: truelight@0: if (is_custom_sprite(spritenum)) { peter1138@9022: SpriteID sprite = GetCustomVehicleSprite(this, direction); peter1138@9022: if (sprite != 0) return sprite; truelight@0: peter1138@9070: spritenum = GetEngine(this->engine_type)->image_index; truelight@0: } peter1138@9022: truelight@0: return direction + _aircraft_sprite[spritenum]; truelight@0: } truelight@0: peter1138@3710: SpriteID GetRotorImage(const Vehicle *v) peter1138@3710: { Darkvater@5854: assert(v->subtype == AIR_HELICOPTER); peter1138@3710: rubidium@7492: const Vehicle *w = v->Next()->Next(); peter1138@3710: if (is_custom_sprite(v->spritenum)) { peter1138@9022: SpriteID sprite = GetCustomRotorSprite(v, false); peter1138@9022: if (sprite != 0) return sprite; 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@9022: static SpriteID GetAircraftIcon(EngineID engine) truelight@0: { peter1138@9022: uint8 spritenum = AircraftVehInfo(engine)->image_index; truelight@0: darkvater@381: if (is_custom_sprite(spritenum)) { peter1138@9022: SpriteID sprite = GetCustomVehicleIcon(engine, DIR_W); peter1138@9022: if (sprite != 0) return sprite; peter1138@9022: peter1138@9070: spritenum = GetEngine(engine)->image_index; peter1138@9012: } darkvater@381: peter1138@9022: return 6 + _aircraft_sprite[spritenum]; peter1138@9022: } darkvater@381: peter1138@9022: void DrawAircraftEngine(int x, int y, EngineID engine, SpriteID pal) peter1138@9022: { peter1138@9022: DrawSprite(GetAircraftIcon(engine), pal, x, y); peter1138@9022: peter1138@9022: if (!(AircraftVehInfo(engine)->subtype & AIR_CTOL)) { peter1138@3710: SpriteID rotor_sprite = GetCustomRotorIcon(engine); peter1138@3710: if (rotor_sprite == 0) rotor_sprite = SPR_ROTOR_STOPPED; peter1138@5668: DrawSprite(rotor_sprite, PAL_NONE, x, y - 5); dominik@1200: } truelight@0: } truelight@0: bjarni@5972: /** Get the size of the sprite of an aircraft sprite heading west (used for lists) bjarni@5972: * @param engine The engine to get the sprite from belugas@6409: * @param width The width of the sprite belugas@6409: * @param height The height of the sprite bjarni@5972: */ bjarni@5972: void GetAircraftSpriteSize(EngineID engine, uint &width, uint &height) bjarni@5972: { rubidium@10056: const Sprite *spr = GetSprite(GetAircraftIcon(engine), ST_NORMAL); bjarni@5972: peter1138@9022: width = spr->width; bjarni@5972: height = spr->height; bjarni@5972: } bjarni@5972: rubidium@6943: static CommandCost EstimateAircraftCost(EngineID engine, const AircraftVehicleInfo *avi) truelight@0: { peter1138@9923: return CommandCost(EXPENSES_NEW_VEHICLES, GetEngineProperty(engine, 0x0B, avi->cost_factor) * (_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. belugas@6409: * @param avi Which engine to find a cargo capacity for. peter1138@3973: * @return New cargo capacity value. peter1138@3973: */ tron@6087: 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: Darkvater@1793: /** Build an aircraft. tron@3491: * @param tile tile of depot where aircraft is built belugas@6123: * @param flags for command Darkvater@1793: * @param p1 aircraft type being built (engine) smatz@9628: * @param p2 unused belugas@6123: * return result of operation. Could be cost, error Darkvater@1793: */ rubidium@6943: CommandCost CmdBuildAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2) truelight@0: { rubidium@10207: if (!IsEngineBuildable(p1, VEH_AIRCRAFT, _current_company)) return_cmd_error(STR_AIRCRAFT_NOT_AVAILABLE); bjarni@1196: tron@5920: const AircraftVehicleInfo *avi = AircraftVehInfo(p1); rubidium@6943: CommandCost value = EstimateAircraftCost(p1, avi); bjarni@1226: belugas@6123: /* 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: rubidium@10207: if (!IsHangarTile(tile) || !IsTileOwner(tile, _current_company)) return CMD_ERROR; bjarni@1226: belugas@6123: /* Prevent building aircraft types at places which can't handle them */ glx@7683: if (!CanAircraftUseStation(p1, tile)) return CMD_ERROR; tron@4161: Darkvater@5854: /* Allocate 2 or 3 vehicle structs, depending on type Darkvater@5854: * vl[0] = aircraft, vl[1] = shadow, [vl[2] = rotor] */ tron@6087: Vehicle *vl[3]; rubidium@7398: if (!Vehicle::AllocateList(vl, avi->subtype & AIR_CTOL ? 2 : 3)) { tron@2639: return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME); tron@2639: } truelight@0: smatz@9628: UnitID unit_num = (flags & DC_AUTOREPLACE) ? 0 : GetFreeUnitNumber(VEH_AIRCRAFT); rubidium@9413: if (unit_num > _settings_game.vehicle.max_aircraft) truelight@0: return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME); truelight@0: truelight@0: if (flags & DC_EXEC) { Darkvater@5854: Vehicle *v = vl[0]; // aircraft Darkvater@5854: Vehicle *u = vl[1]; // shadow truelight@0: rubidium@6552: v = new (v) Aircraft(); rubidium@6552: u = new (u) Aircraft(); rubidium@7782: v->unitnumber = unit_num; rubidium@5587: v->direction = DIR_SE; truelight@0: rubidium@10207: v->owner = u->owner = _current_company; truelight@0: truelight@0: v->tile = tile; truelight@0: // u->tile = 0; truelight@0: tron@6087: uint x = TileX(tile) * TILE_SIZE + 5; tron@6087: 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: smatz@8556: v->running_ticks = 0; smatz@8556: truelight@0: // u->delta_x = u->delta_y = 0; 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: peter1138@8258: v->name = NULL; 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; frosch@10419: u->engine_type = p1; truelight@0: Darkvater@5854: v->subtype = (avi->subtype & AIR_CTOL ? AIR_AIRCRAFT : AIR_HELICOPTER); rubidium@6558: v->UpdateDeltaXY(INVALID_DIR); rubidium@6990: v->value = value.GetCost(); truelight@0: Darkvater@5854: u->subtype = AIR_SHADOW; rubidium@6558: u->UpdateDeltaXY(INVALID_DIR); 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@6087: 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: skidd13@7928: if (HasBit(EngInfo(p1)->callbackmask, CBM_VEHICLE_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@6087: 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@5854: 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@5921: for (uint i = 0;; i++) { bjarni@6237: const Station *st = GetStationByTile(tile); bjarni@6237: const AirportFTAClass *apc = st->Airport(); bjarni@6237: tron@5921: assert(i != apc->nof_depots); tron@5921: if (st->airport_tile + ToTileIndexDiff(apc->airport_depots[i]) == tile) { tron@5921: assert(apc->layout[i].heading == HANGAR); tron@5921: v->u.air.pos = apc->layout[i].position; tron@5921: 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); rubidium@7493: v->SetNext(u); truelight@0: rubidium@9413: v->service_interval = _settings_game.vehicle.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@6176: v->vehicle_flags = 0; skidd13@7931: if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SetBit(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE); maedhros@6176: peter1138@6490: UpdateAircraftCache(v); peter1138@6490: truelight@0: VehiclePositionChanged(v); truelight@0: VehiclePositionChanged(u); truelight@0: belugas@6123: /* Aircraft with 3 vehicles (chopper)? */ Darkvater@5854: if (v->subtype == AIR_HELICOPTER) { Darkvater@5854: Vehicle *w = vl[2]; truelight@0: rubidium@6552: w = new (w) Aircraft(); frosch@10419: w->engine_type = p1; rubidium@5587: w->direction = DIR_N; rubidium@10207: w->owner = _current_company; 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->vehstatus = VS_HIDDEN | VS_UNCLICKABLE; peter1138@3710: w->spritenum = 0xFF; Darkvater@5854: 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; rubidium@6558: w->UpdateDeltaXY(INVALID_DIR); rubidium@7493: rubidium@7493: u->SetNext(w); truelight@0: VehiclePositionChanged(w); truelight@0: } truelight@0: bjarni@4739: InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile); rubidium@9297: InvalidateWindowClassesData(WC_AIRCRAFT_LIST, 0); truelight@0: InvalidateWindow(WC_COMPANY, v->owner); rubidium@10207: if (IsLocalCompany()) bjarni@7425: InvalidateAutoreplaceWindow(v->engine_type, v->group_id); //updates the replace Aircraft window bjarni@5944: rubidium@10207: GetCompany(_current_company)->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); truelight@0: InvalidateWindow(WC_COMPANY, v->owner); bjarni@5256: DeleteDepotHighlightOfVehicle(v); truelight@0: DeleteVehicleChain(v); rubidium@9297: InvalidateWindowClassesData(WC_AIRCRAFT_LIST, 0); truelight@0: } truelight@0: Darkvater@1786: /** Sell an aircraft. tron@3491: * @param tile unused belugas@6123: * @param flags for command type Darkvater@1786: * @param p1 vehicle ID to be sold Darkvater@1786: * @param p2 unused belugas@6123: * @return result of operation. Error or sold value Darkvater@1786: */ rubidium@6943: CommandCost CmdSellAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2) truelight@0: { truelight@4352: if (!IsValidVehicleID(p1)) return CMD_ERROR; truelight@0: tron@6087: Vehicle *v = GetVehicle(p1); truelight@0: rubidium@6259: if (v->type != VEH_AIRCRAFT || !CheckOwnership(v->owner)) return CMD_ERROR; rubidium@7490: if (!v->IsStoppedInDepot()) return_cmd_error(STR_A01B_AIRCRAFT_MUST_BE_STOPPED); truelight@0: rubidium@7695: if (HASBITS(v->vehstatus, VS_CRASHED)) return_cmd_error(STR_CAN_T_SELL_DESTROYED_VEHICLE); rubidium@7695: rubidium@8230: CommandCost ret(EXPENSES_NEW_VEHICLES, -v->value); rubidium@7782: 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: rubidium@7782: return ret; truelight@0: } truelight@0: rubidium@8890: bool Aircraft::FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse) rubidium@8890: { smatz@10154: const Station *st = GetTargetAirportIfValid(this); rubidium@8890: /* If the station is not a valid airport or if it has no hangars */ smatz@10154: if (st == NULL || st->Airport()->nof_depots == 0) { rubidium@8890: /* the aircraft has to search for a hangar on its own */ rubidium@8890: StationID station = FindNearestHangar(this); rubidium@8890: rubidium@8890: if (station == INVALID_STATION) return false; rubidium@8890: rubidium@8890: st = GetStation(station); rubidium@8890: } rubidium@8890: rubidium@8890: if (location != NULL) *location = st->xy; rubidium@8890: if (destination != NULL) *destination = st->index; rubidium@8890: rubidium@8890: return true; rubidium@8890: } rubidium@8890: Darkvater@1793: /** Send an aircraft to the hangar. tron@3491: * @param tile unused belugas@6123: * @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@6123: * @return o if everything went well Darkvater@1793: */ rubidium@6943: CommandCost 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; rubidium@10207: return SendAllVehiclesToDepot(VEH_AIRCRAFT, flags, p2 & DEPOT_SERVICE, _current_company, (p2 & VLW_MASK), p1); bjarni@4463: } bjarni@4463: bjarni@4506: if (!IsValidVehicleID(p1)) return CMD_ERROR; bjarni@1237: tron@6087: Vehicle *v = GetVehicle(p1); truelight@0: rubidium@8891: if (v->type != VEH_AIRCRAFT) return CMD_ERROR; rubidium@8843: rubidium@8891: return v->SendToDepot(flags, (DepotCommand)(p2 & DEPOT_COMMAND_MASK)); truelight@0: } truelight@0: truelight@0: Darkvater@1802: /** Refits an aircraft to the specified cargo type. tron@3491: * @param tile unused belugas@6123: * @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 maedhros@6546: * - p2 = (bit 16) - refit only this vehicle (ignored) belugas@6123: * @return cost of refit or error Darkvater@1802: */ rubidium@6943: CommandCost 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@6087: Vehicle *v = GetVehicle(p1); bjarni@1237: rubidium@6259: if (v->type != VEH_AIRCRAFT || !CheckOwnership(v->owner)) return CMD_ERROR; rubidium@7490: if (!v->IsStoppedInDepot()) return_cmd_error(STR_A01B_AIRCRAFT_MUST_BE_STOPPED); smatz@8145: if (v->vehstatus & VS_CRASHED) return_cmd_error(STR_CAN_T_REFIT_DESTROYED_VEHICLE); bjarni@1237: Darkvater@1802: /* Check cargo */ tron@6087: CargoID new_cid = GB(p2, 0, 8); peter1138@6316: if (new_cid >= NUM_CARGO || !CanRefitTo(v->engine_type, new_cid)) return CMD_ERROR; truelight@0: peter1138@3974: /* Check the refit capacity callback */ tron@6087: uint16 callback = CALLBACK_FAILED; skidd13@7928: if (HasBit(EngInfo(v->engine_type)->callbackmask, CBM_VEHICLE_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@6087: const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type); tron@6087: tron@6087: 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@6087: pass = AircraftDefaultCargoCapacity(new_cid, avi); peter1138@3974: } else { peter1138@3974: pass = callback; truelight@0: } peter1138@3008: _returned_refit_capacity = pass; truelight@0: rubidium@6950: CommandCost cost; rubidium@10207: if (IsHumanCompany(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: rubidium@7492: Vehicle *u = v->Next(); peter1138@6340: uint mail = IsCargoInClass(new_cid, CC_PASSENGERS) ? avi->mail_capacity : 0; truelight@0: u->cargo_cap = mail; rubidium@7010: v->cargo.Truncate(v->cargo_type == new_cid ? pass : 0); rubidium@7010: u->cargo.Truncate(v->cargo_type == new_cid ? mail : 0); 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); rubidium@9297: InvalidateWindowClassesData(WC_AIRCRAFT_LIST, 0); truelight@0: } truelight@0: truelight@0: return cost; truelight@0: } truelight@0: truelight@0: truelight@0: static void CheckIfAircraftNeedsService(Vehicle *v) truelight@0: { rubidium@9413: if (_settings_game.vehicle.servint_aircraft == 0 || !v->NeedsAutomaticServicing()) return; rubidium@7502: if (v->IsInDepot()) { bjarni@4529: VehicleServiceInDepot(v); bjarni@4529: return; bjarni@4529: } bjarni@4529: rubidium@8840: const Station *st = GetStation(v->current_order.GetDestination()); belugas@6123: /* only goto depot if the target airport has terminals (eg. it is airport) */ tron@6032: 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; rubidium@8864: v->current_order.MakeGoToDepot(st->index, ODTFB_SERVICE); smatz@8350: InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH); rubidium@8836: } else if (v->current_order.IsType(OT_GOTO_DEPOT)) { rubidium@8836: v->current_order.MakeDummy(); smatz@8350: InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH); truelight@0: } truelight@0: } truelight@0: glx@8467: void Aircraft::OnNewDay() truelight@0: { glx@8467: if (!IsNormalAircraft(this)) return; dominik@19: glx@8467: if ((++this->day_counter & 7) == 0) DecreaseVehicleValue(this); truelight@0: glx@8467: CheckOrders(this); truelight@0: glx@8467: CheckVehicleBreakdown(this); glx@8467: AgeVehicle(this); glx@8467: CheckIfAircraftNeedsService(this); truelight@0: smatz@8556: if (this->running_ticks == 0) return; truelight@0: smatz@8556: CommandCost cost(EXPENSES_AIRCRAFT_RUN, GetVehicleProperty(this, 0x0E, AircraftVehInfo(this->engine_type)->running_cost) * _price.aircraft_running * this->running_ticks / (364 * DAY_TICKS)); glx@8467: smatz@8556: this->profit_this_year -= cost.GetCost(); smatz@8556: this->running_ticks = 0; glx@8467: rubidium@10207: SubtractMoneyFromCompanyFract(this->owner, cost); glx@8467: glx@8467: InvalidateWindow(WC_VEHICLE_DETAILS, this->index); Celestar@1055: InvalidateWindowClasses(WC_AIRCRAFT_LIST); truelight@0: } truelight@0: rubidium@6247: void AircraftYearlyLoop() truelight@0: { truelight@0: Vehicle *v; truelight@0: truelight@0: FOR_ALL_VEHICLES(v) { rubidium@6259: 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 { rubidium@7010: v->cargo.AgeCargo(); rubidium@7492: v = v->Next(); tron@2639: } while (v != NULL); truelight@0: } truelight@0: truelight@0: static void HelicopterTickHandler(Vehicle *v) truelight@0: { rubidium@7492: Vehicle *u = v->Next()->Next(); truelight@0: tron@2639: if (u->vehstatus & VS_HIDDEN) return; truelight@0: belugas@6123: /* if true, helicopter rotors do not rotate. This should only be the case if a helicopter is belugas@6123: * loading/unloading at a terminal or stopped */ rubidium@8836: if (v->current_order.IsType(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@6087: int tick = ++u->tick_counter; tron@6087: int spd = u->cur_speed >> 4; truelight@0: tron@6087: 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: rubidium@7134: v->cur_image = v->GetImage(v->direction); rubidium@7492: 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: rubidium@7492: Vehicle *u = v->Next(); truelight@0: skidd13@7922: int safe_x = Clamp(x, 0, MapMaxX() * TILE_SIZE); skidd13@7922: 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: skidd13@7922: 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: rubidium@7492: 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: rubidium@7492: Vehicle *u = v->Next(); truelight@0: u->vehstatus |= VS_HIDDEN; rubidium@7492: 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: peter1138@6490: peter1138@6490: void UpdateAircraftCache(Vehicle *v) peter1138@6490: { peter1138@6490: uint max_speed = GetVehicleProperty(v, 0x0C, 0); peter1138@6490: if (max_speed != 0) { peter1138@6490: /* Convert from original units to (approx) km/h */ peter1138@6490: max_speed = (max_speed * 129) / 10; peter1138@6490: peter1138@6490: v->u.air.cached_max_speed = max_speed; peter1138@6490: } else { peter1138@6490: v->u.air.cached_max_speed = 0xFFFF; peter1138@6490: } peter1138@6490: } peter1138@6490: peter1138@6490: celestar@6193: /** celestar@6193: * Special velocities for aircraft celestar@5945: */ celestar@5945: enum AircraftSpeedLimits { celestar@6193: SPEED_LIMIT_TAXI = 50, ///< Maximum speed of an aircraft while taxiing celestar@6193: SPEED_LIMIT_APPROACH = 230, ///< Maximum speed of an aircraft on finals celestar@6193: SPEED_LIMIT_BROKEN = 320, ///< Maximum speed of an aircraft that is broken celestar@6193: SPEED_LIMIT_HOLD = 425, ///< Maximum speed of an aircraft that flies the holding pattern celestar@6193: SPEED_LIMIT_NONE = 0xFFFF ///< No environmental speed limit. Speed limit is type dependent celestar@5945: }; celestar@5945: celestar@6193: /** celestar@6193: * Sets the new speed for an aircraft celestar@6193: * @param v The vehicle for which the speed should be obtained celestar@6193: * @param speed_limit The maximum speed the vehicle may have. celestar@6193: * @param hard_limit If true, the limit is directly enforced, otherwise the plane is slowed down gradually celestar@6193: * @return The number of position updates needed within the tick celestar@6193: */ celestar@6193: static int UpdateAircraftSpeed(Vehicle *v, uint speed_limit = SPEED_LIMIT_NONE, bool hard_limit = true) truelight@0: { celestar@6193: uint spd = v->acceleration * 16; truelight@0: byte t; truelight@0: peter1138@8648: /* Adjust speed limits by plane speed factor to prevent taxiing peter1138@8648: * and take-off speeds being too low. */ rubidium@9413: speed_limit *= _settings_game.vehicle.plane_speed; peter1138@8648: peter1138@6490: if (v->u.air.cached_max_speed < speed_limit) { peter1138@6490: if (v->cur_speed < speed_limit) hard_limit = false; peter1138@6490: speed_limit = v->u.air.cached_max_speed; peter1138@6490: } peter1138@6490: celestar@6193: speed_limit = min(speed_limit, v->max_speed); celestar@6193: truelight@0: v->subspeed = (t=v->subspeed) + (byte)spd; celestar@6193: peter1138@8566: /* Aircraft's current speed is used twice so that very fast planes are peter1138@8566: * forced to slow down rapidly in the short distance needed. The magic peter1138@8566: * value 16384 was determined to give similar results to the old speed/48 peter1138@8566: * method at slower speeds. This also results in less reduction at slow peter1138@8566: * speeds to that aircraft do not get to taxi speed straight after peter1138@8566: * touchdown. */ peter1138@8648: if (!hard_limit && v->cur_speed > speed_limit) { rubidium@9413: speed_limit = v->cur_speed - max(1, ((v->cur_speed * v->cur_speed) / 16384) / _settings_game.vehicle.plane_speed); peter1138@8648: } celestar@6193: celestar@5945: spd = min(v->cur_speed + (spd >> 8) + (v->subspeed < t), speed_limit); truelight@193: belugas@6123: /* adjust speed for broken vehicles */ celestar@5945: if (v->vehstatus & VS_AIRCRAFT_BROKEN) spd = min(spd, SPEED_LIMIT_BROKEN); truelight@0: belugas@6123: /* updates statusbar only if speed have changed to save CPU time */ truelight@0: if (spd != v->cur_speed) { truelight@0: v->cur_speed = spd; rubidium@9413: if (_settings_client.gui.vehicle_speed) smatz@8350: InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH); truelight@0: } truelight@0: peter1138@8648: /* Adjust distance moved by plane speed setting */ rubidium@9413: if (_settings_game.vehicle.plane_speed > 1) spd /= _settings_game.vehicle.plane_speed; peter1138@8648: tron@2639: if (!(v->direction & 1)) spd = spd * 3 / 4; truelight@0: celestar@6193: spd += v->progress; celestar@6193: v->progress = (byte)spd; celestar@6193: return spd >> 8; truelight@0: } truelight@0: celestar@5908: /** celestar@5908: * Gets the cruise altitude of an aircraft. celestar@5908: * The cruise altitude is determined by the velocity of the vehicle celestar@5908: * and the direction it is moving celestar@5908: * @param v The vehicle. Should be an aircraft celestar@5908: * @returns Altitude in pixel units celestar@5908: */ truelight@0: static byte GetAircraftFlyingAltitude(const Vehicle *v) truelight@0: { celestar@5908: /* Make sure Aircraft fly no lower so that they don't conduct celestar@5908: * CFITs (controlled flight into terrain) celestar@5908: */ celestar@5908: byte base_altitude = 150; celestar@5908: celestar@5908: /* Make sure eastbound and westbound planes do not "crash" into each celestar@5908: * other by providing them with vertical seperation celestar@5908: */ celestar@5908: switch (v->direction) { tron@6087: case DIR_N: tron@6087: case DIR_NE: tron@6087: case DIR_E: tron@6087: case DIR_SE: celestar@6193: base_altitude += 10; tron@6087: break; tron@6087: celestar@5908: default: break; truelight@0: } celestar@5908: celestar@5908: /* Make faster planes fly higher so that they can overtake slower ones */ celestar@6193: base_altitude += min(20 * (v->max_speed / 200), 90); celestar@5908: celestar@5908: return base_altitude; truelight@0: } truelight@0: celestar@6193: /** celestar@6394: * Find the entry point to an airport depending on direction which celestar@6394: * the airport is being approached from. Each airport can have up to celestar@6394: * four entry points for its approach system so that approaching celestar@6394: * aircraft do not fly through each other or are forced to do 180 celestar@6394: * degree turns during the approach. The arrivals are grouped into celestar@6394: * four sectors dependent on the DiagDirection from which the airport celestar@6394: * is approached. celestar@6394: * celestar@6394: * @param v The vehicle that is approaching the airport celestar@6394: * @param apc The Airport Class being approached. celestar@6394: * @returns The index of the entry point celestar@6394: */ celestar@6394: static byte AircraftGetEntryPoint(const Vehicle *v, const AirportFTAClass *apc) celestar@6394: { celestar@6394: assert(v != NULL); celestar@6394: assert(apc != NULL); celestar@6394: smatz@10154: /* In the case the station doesn't exit anymore, set target tile 0. smatz@10154: * It doesn't hurt much, aircraft will go to next order, nearest hangar smatz@10154: * or it will simply crash in next tick */ smatz@10154: TileIndex tile = 0; smatz@10154: smatz@10154: if (IsValidStationID(v->u.air.targetairport)) { smatz@10154: const Station *st = GetStation(v->u.air.targetairport); smatz@10154: /* Make sure we don't go to 0,0 if the airport has been removed. */ smatz@10154: tile = (st->airport_tile != 0) ? st->airport_tile : st->xy; smatz@10154: } celestar@6394: celestar@6394: int delta_x = v->x_pos - TileX(tile) * TILE_SIZE; celestar@6394: int delta_y = v->y_pos - TileY(tile) * TILE_SIZE; celestar@6394: celestar@6394: DiagDirection dir; celestar@6394: if (abs(delta_y) < abs(delta_x)) { celestar@6394: /* We are northeast or southwest of the airport */ celestar@6394: dir = delta_x < 0 ? DIAGDIR_NE : DIAGDIR_SW; celestar@6394: } else { celestar@6394: /* We are northwest or southeast of the airport */ celestar@6394: dir = delta_y < 0 ? DIAGDIR_NW : DIAGDIR_SE; celestar@6394: } celestar@6394: return apc->entry_points[dir]; celestar@6394: } celestar@6394: celestar@6394: /** celestar@6193: * Controls the movement of an aircraft. This function actually moves the vehicle celestar@6193: * on the map and takes care of minor things like sound playback. celestar@6193: * @todo De-mystify the cur_speed values for helicopter rotors. celestar@6193: * @param v The vehicle that is moved. Must be the first vehicle of the chain celestar@6193: * @return Whether the position requested by the State Machine has been reached celestar@6193: */ Darkvater@1401: static bool AircraftController(Vehicle *v) truelight@0: { celestar@6193: int count; smatz@10154: smatz@10154: /* NULL if station is invalid */ smatz@10177: const Station *st = IsValidStationID(v->u.air.targetairport) ? GetStation(v->u.air.targetairport) : NULL; smatz@10154: /* 0 if there is no station */ smatz@10154: TileIndex tile = 0; smatz@10154: if (st != NULL) { smatz@10154: tile = st->airport_tile; smatz@10154: if (tile == 0) tile = st->xy; smatz@10154: } smatz@10154: /* DUMMY if there is no station or no airport */ smatz@10154: const AirportFTAClass *afc = tile == 0 ? GetAirport(AT_DUMMY) : st->Airport(); truelight@0: belugas@6123: /* prevent going to 0,0 if airport is deleted. */ smatz@10154: if (st == NULL || st->airport_tile == 0) { celestar@6394: /* Jump into our "holding pattern" state machine if possible */ belugas@7990: if (v->u.air.pos >= afc->nofelements) { belugas@7990: v->u.air.pos = v->u.air.previous_pos = AircraftGetEntryPoint(v, afc); rubidium@8840: } else if (v->u.air.targetairport != v->current_order.GetDestination()) { belugas@7990: /* If not possible, just get out of here fast */ belugas@7990: v->u.air.state = FLYING; belugas@7990: UpdateAircraftCache(v); belugas@7990: AircraftNextAirportPos_and_Order(v); belugas@7990: /* get aircraft back on running altitude */ belugas@7990: SetAircraftPosition(v, v->x_pos, v->y_pos, GetAircraftFlyingAltitude(v)); belugas@7990: return false; belugas@7990: } celestar@6394: } celestar@6394: celestar@6394: /* get airport moving data */ smatz@10154: const AirportMovingData *amd = afc->MovingData(v->u.air.pos); celestar@6394: tron@6087: int x = TileX(tile) * TILE_SIZE; tron@6087: int y = TileY(tile) * TILE_SIZE; truelight@0: belugas@6123: /* Helicopter raise */ truelight@0: if (amd->flag & AMED_HELI_RAISE) { rubidium@7492: Vehicle *u = v->Next()->Next(); truelight@0: belugas@6123: /* 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@6193: count = UpdateAircraftSpeed(v); celestar@6193: if (count > 0) { truelight@0: v->tile = 0; truelight@0: belugas@6123: /* Reached altitude? */ truelight@0: if (v->z_pos >= 184) { truelight@0: v->cur_speed = 0; truelight@0: return true; truelight@0: } celestar@6193: 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@6123: /* Helicopter landing. */ truelight@0: if (amd->flag & AMED_HELI_LOWER) { smatz@10154: if (st == NULL) { peter1138@8677: /* FIXME - AircraftController -> if station no longer exists, do not land peter1138@8677: * helicopter will circle until sign disappears, then go to next order peter1138@8677: * what to do when it is the only order left, right now it just stays in 1 place */ peter1138@8677: v->u.air.state = FLYING; peter1138@8677: UpdateAircraftCache(v); peter1138@8677: AircraftNextAirportPos_and_Order(v); peter1138@8677: return false; peter1138@8677: } truelight@0: peter1138@8677: /* Vehicle is now at the airport. */ smatz@10154: v->tile = tile; truelight@0: peter1138@8677: /* Find altitude of landing position. */ peter1138@8677: int z = GetSlopeZ(x, y) + 1 + afc->delta_z; truelight@0: peter1138@8677: if (z == v->z_pos) { peter1138@8677: Vehicle *u = v->Next()->Next(); peter1138@8677: peter1138@8677: /* Increase speed of rotors. When speed is 80, we've landed. */ peter1138@8677: if (u->cur_speed >= 80) return true; peter1138@8677: u->cur_speed += 4; peter1138@8677: } else { peter1138@8677: count = UpdateAircraftSpeed(v); peter1138@8677: if (count > 0) { peter1138@8677: if (v->z_pos > z) { peter1138@8677: SetAircraftPosition(v, v->x_pos, v->y_pos, max(v->z_pos - count, z)); peter1138@8677: } else { peter1138@8677: SetAircraftPosition(v, v->x_pos, v->y_pos, min(v->z_pos + count, z)); peter1138@8677: } truelight@0: } truelight@0: } truelight@0: return false; truelight@0: } truelight@0: belugas@6123: /* Get distance from destination pos to current pos. */ skidd13@7923: uint dist = abs(x + amd->x - v->x_pos) + abs(y + amd->y - v->y_pos); truelight@0: belugas@6123: /* Need exact position? */ celestar@6193: if (!(amd->flag & AMED_EXACTPOS) && dist <= (amd->flag & AMED_SLOWTURN ? 8U : 4U)) return true; truelight@0: belugas@6123: /* At final pos? */ truelight@0: if (dist == 0) { belugas@6123: /* Change direction smoothly to final direction. */ tron@6087: DirDiff dirdiff = DirDifference(amd->direction, v->direction); belugas@6123: /* if distance is 0, and plane points in right direction, no point in calling belugas@6123: * 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@5945: 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@6193: uint speed_limit = SPEED_LIMIT_TAXI; celestar@6193: bool hard_limit = true; celestar@6193: celestar@6193: if (amd->flag & AMED_NOSPDCLAMP) speed_limit = SPEED_LIMIT_NONE; celestar@6193: if (amd->flag & AMED_HOLD) { speed_limit = SPEED_LIMIT_HOLD; hard_limit = false; } celestar@6193: if (amd->flag & AMED_LAND) { speed_limit = SPEED_LIMIT_APPROACH; hard_limit = false; } celestar@6193: if (amd->flag & AMED_BRAKE) { speed_limit = SPEED_LIMIT_TAXI; hard_limit = false; } celestar@6193: celestar@6193: count = UpdateAircraftSpeed(v, speed_limit, hard_limit); celestar@6193: if (count == 0) return false; truelight@0: tron@2639: if (v->load_unload_time_rem != 0) v->load_unload_time_rem--; truelight@0: celestar@6193: do { richk@6327: richk@6327: GetNewVehiclePosResult gp; richk@6327: rubidium@7900: if (dist < 4 || amd->flag & AMED_LAND) { richk@6327: /* move vehicle one pixel towards target */ richk@6327: gp.x = (v->x_pos != (x + amd->x)) ? richk@6327: v->x_pos + ((x + amd->x > v->x_pos) ? 1 : -1) : richk@6327: v->x_pos; richk@6327: gp.y = (v->y_pos != (y + amd->y)) ? richk@6327: v->y_pos + ((y + amd->y > v->y_pos) ? 1 : -1) : richk@6327: v->y_pos; richk@6327: richk@6327: /* Oilrigs must keep v->tile as st->airport_tile, since the landing pad is in a non-airport tile */ richk@6327: gp.new_tile = (st->airport_type == AT_OILRIG) ? st->airport_tile : TileVirtXY(gp.x, gp.y); richk@6327: richk@6327: } else { richk@6327: richk@6327: /* Turn. Do it slowly if in the air. */ richk@6327: Direction newdir = GetDirectionTowards(v, x + amd->x, y + amd->y); richk@6327: if (newdir != v->direction) { richk@6327: v->direction = newdir; richk@6327: if (amd->flag & AMED_SLOWTURN) { richk@6327: if (v->load_unload_time_rem == 0) v->load_unload_time_rem = 8; richk@6327: } else { richk@6327: v->cur_speed >>= 1; richk@6327: } celestar@6193: } richk@6327: richk@6327: /* Move vehicle. */ richk@6327: gp = GetNewVehiclePos(v); truelight@0: } truelight@0: celestar@6193: v->tile = gp.new_tile; celestar@6193: /* If vehicle is in the air, use tile coordinate 0. */ smatz@8534: if (amd->flag & (AMED_TAKEOFF | AMED_SLOWTURN | AMED_LAND)) v->tile = 0; truelight@0: celestar@6193: /* Adjust Z for land or takeoff? */ celestar@6193: uint z = v->z_pos; truelight@0: celestar@6193: if (amd->flag & AMED_TAKEOFF) { celestar@6193: z = min(z + 2, GetAircraftFlyingAltitude(v)); tron@2639: } truelight@0: celestar@6193: if ((amd->flag & AMED_HOLD) && (z > 150)) z--; truelight@0: celestar@6193: if (amd->flag & AMED_LAND) { celestar@6193: if (st->airport_tile == 0) { celestar@6193: /* Airport has been removed, abort the landing procedure */ celestar@6193: v->u.air.state = FLYING; peter1138@6590: UpdateAircraftCache(v); celestar@6193: AircraftNextAirportPos_and_Order(v); celestar@6193: /* get aircraft back on running altitude */ celestar@6193: SetAircraftPosition(v, gp.x, gp.y, GetAircraftFlyingAltitude(v)); celestar@6193: continue; celestar@6193: } celestar@6193: celestar@6193: uint curz = GetSlopeZ(x, y) + 1; celestar@6193: celestar@6193: if (curz > z) { celestar@6193: z++; celestar@6193: } else { celestar@6193: int t = max(1U, dist - 4); celestar@6193: celestar@6193: z -= ((z - curz) + t - 1) / t; celestar@6193: if (z < curz) z = curz; celestar@6193: } celestar@6193: } celestar@6193: celestar@6193: /* We've landed. Decrase speed when we're reaching end of runway. */ celestar@6193: if (amd->flag & AMED_BRAKE) { celestar@6193: uint curz = GetSlopeZ(x, y) + 1; celestar@6193: celestar@6193: if (z > curz) { celestar@6193: z--; celestar@6193: } else if (z < curz) { celestar@6193: z++; celestar@6193: } celestar@6193: celestar@6193: } celestar@6193: celestar@6193: SetAircraftPosition(v, gp.x, gp.y, z); celestar@6193: } 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: smatz@10154: Station *st = GetTargetAirportIfValid(v); dominik@899: belugas@6123: /* make aircraft crash down to the ground */ smatz@10154: if (v->u.air.crashed_counter < 500 && st == NULL && ((v->u.air.crashed_counter % 3) == 0) ) { tron@6087: 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@6087: uint32 r; skidd13@7967: 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, rubidium@7700: GB(r, 0, 4) - 4, rubidium@7700: 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@6123: /* remove rubble of crashed airplane */ truelight@0: belugas@6123: /* clear runway-in on all airports, set by crashing plane belugas@6123: * small airports use AIRPORT_BUSY, city airports use RUNWAY_IN_OUT_block, etc. belugas@6123: * but they all share the same number */ smatz@10154: if (st != NULL) { smatz@10154: CLRBITS(st->airport_flags, RUNWAY_IN_block); smatz@10154: CLRBITS(st->airport_flags, RUNWAY_IN_OUT_block); // commuter airport smatz@10154: CLRBITS(st->airport_flags, RUNWAY_IN2_block); // intercontinental smatz@10154: } truelight@0: smatz@8317: MarkSingleVehicleDirty(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: rubidium@8830: void HandleMissingAircraftOrders(Vehicle *v) truelight@0: { rubidium@8830: /* rubidium@8830: * We do not have an order. This can be divided into two cases: rubidium@8830: * 1) we are heading to an invalid station. In this case we must rubidium@8830: * find another airport to go to. If there is nowhere to go, rubidium@8830: * we will destroy the aircraft as it otherwise will enter rubidium@8830: * the holding pattern for the first airport, which can cause rubidium@8830: * the plane to go into an undefined state when building an rubidium@8830: * airport with the same StationID. rubidium@8830: * 2) we are (still) heading to a (still) valid airport, then we rubidium@8830: * can continue going there. This can happen when you are rubidium@8830: * changing the aircraft's orders while in-flight or in for rubidium@8830: * example a depot. However, when we have a current order to rubidium@8830: * go to a depot, we have to keep that order so the aircraft rubidium@8830: * actually stops. rubidium@8830: */ smatz@10154: const Station *st = GetTargetAirportIfValid(v); smatz@10154: if (st == NULL) { rubidium@8830: CommandCost ret; rubidium@10207: CompanyID old_company = _current_company; tron@3005: rubidium@10207: _current_company = v->owner; rubidium@8830: ret = DoCommand(v->tile, v->index, 0, DC_EXEC, CMD_SEND_AIRCRAFT_TO_HANGAR); rubidium@10207: _current_company = old_company; truelight@4351: rubidium@8830: if (CmdFailed(ret)) CrashAirplane(v); rubidium@8836: } else if (!v->current_order.IsType(OT_GOTO_DEPOT)) { rubidium@8830: v->current_order.Free(); rubidium@8830: } rubidium@8830: } rubidium@8830: rubidium@8830: rubidium@8830: TileIndex Aircraft::GetOrderStationLocation(StationID station) rubidium@8830: { rubidium@8830: /* Orders are changed in flight, ensure going to the right station. */ rubidium@8830: if (this->u.air.state == FLYING) { rubidium@8830: AircraftNextAirportPos_and_Order(this); bjarni@1151: } truelight@193: rubidium@8830: /* Aircraft do not use dest-tile */ rubidium@8830: return 0; truelight@0: } truelight@0: rubidium@6553: void Aircraft::MarkDirty() peter1138@3722: { rubidium@7134: this->cur_image = this->GetImage(this->direction); rubidium@7492: if (this->subtype == AIR_HELICOPTER) this->Next()->Next()->cur_image = GetRotorImage(this); smatz@8317: MarkSingleVehicleDirty(this); peter1138@3722: } peter1138@3722: 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@6087: uint amt = 2; rubidium@7010: if (IsCargoInClass(v->cargo_type, CC_PASSENGERS)) amt += v->cargo.Count(); dominik@899: SetDParam(0, amt); dominik@899: rubidium@7010: v->cargo.Truncate(0); rubidium@7492: v->Next()->cargo.Truncate(0); smatz@10154: const Station *st = GetTargetAirportIfValid(v); tron@6087: StringID newsitem; smatz@10154: if (st == NULL) { 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: AddNewsItem(newsitem, rubidium@9234: NS_ACCIDENT_VEHICLE, 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@6087: Station *st = GetStation(v->u.air.targetairport); truelight@0: belugas@6123: /* FIXME -- MaybeCrashAirplane -> increase crashing chances of very modern airplanes on smaller than AT_METROPOLITAN airports */ tron@6087: uint16 prob = 0x10000 / 1500; tron@6032: if (st->Airport()->flags & AirportFTAClass::SHORT_STRIP && tron@6025: AircraftVehInfo(v->engine_type)->subtype & AIR_FAST && tron@6025: !_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@6123: /* Crash the airplane. Remove all goods stored at the station. */ peter1138@6350: for (CargoID i = 0; i < NUM_CARGO; i++) { truelight@0: st->goods[i].rating = 1; rubidium@7010: st->goods[i].cargo.Truncate(0); truelight@0: } truelight@0: dominik@899: CrashAirplane(v); truelight@0: } truelight@0: belugas@6123: /** we've landed and just arrived at a terminal */ truelight@0: static void AircraftEntersTerminal(Vehicle *v) truelight@0: { rubidium@8836: if (v->current_order.IsType(OT_GOTO_DEPOT)) return; truelight@0: tron@6087: 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: st->had_vehicle_of_type |= HVOT_AIRCRAFT; tron@534: SetDParam(0, st->index); belugas@6123: /* show newsitem of celebrating citizens */ truelight@0: AddNewsItem( truelight@0: STR_A033_CITIZENS_CELEBRATE_FIRST, rubidium@10207: (v->owner == _local_company) ? NS_ARRIVAL_COMPANY : NS_ARRIVAL_OTHER, truelight@0: v->index, smatz@10123: st->index smatz@10123: ); truelight@0: } truelight@0: KUDr@5651: v->BeginLoading(); truelight@0: } truelight@0: truelight@0: static void AircraftLandAirplane(Vehicle *v) truelight@0: { rubidium@6558: v->UpdateDeltaXY(INVALID_DIR); rubidium@6558: 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@6036: belugas@6123: /** set the right pos when heading to other airports after takeoff */ rubidium@8891: void AircraftNextAirportPos_and_Order(Vehicle *v) truelight@0: { smatz@10154: if (v->current_order.IsType(OT_GOTO_STATION) || v->current_order.IsType(OT_GOTO_DEPOT)) { rubidium@8840: v->u.air.targetairport = v->current_order.GetDestination(); smatz@10154: } truelight@0: smatz@10154: const Station *st = GetTargetAirportIfValid(v); smatz@10154: const AirportFTAClass *apc = st == NULL ? GetAirport(AT_DUMMY) : st->Airport(); celestar@6036: 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@5587: v->direction = DIR_SE; truelight@0: v->vehstatus &= ~VS_HIDDEN; truelight@0: { rubidium@7492: Vehicle *u = v->Next(); truelight@0: u->vehstatus &= ~VS_HIDDEN; truelight@0: belugas@6123: /* Rotor blades */ rubidium@7492: 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: bjarni@8310: /** Checks if an aircraft should head towards a hangar because it needs replacement bjarni@8310: * @param *v the vehicle to test bjarni@8310: * @return true if the aircraft should head towards a hangar bjarni@8310: */ bjarni@8310: static inline bool CheckSendAircraftToHangarForReplacement(const Vehicle *v) bjarni@8310: { bjarni@8310: EngineID new_engine; rubidium@10207: Company *c = GetCompany(v->owner); bjarni@8310: bjarni@8310: if (VehicleHasDepotOrders(v)) return false; // The aircraft will end up in the hangar eventually on it's own bjarni@8310: rubidium@10207: new_engine = EngineReplacementForCompany(c, v->engine_type, v->group_id); bjarni@8310: bjarni@8310: if (new_engine == INVALID_ENGINE) { bjarni@8310: /* There is no autoreplace assigned to this EngineID so we will set it to renew to the same type if needed */ bjarni@8310: new_engine = v->engine_type; bjarni@8310: rubidium@10207: if (!v->NeedsAutorenewing(c)) { bjarni@8310: /* No need to replace the aircraft */ bjarni@8310: return false; bjarni@8310: } bjarni@8310: } bjarni@8310: rubidium@10207: if (!HasBit(GetEngine(new_engine)->company_avail, v->owner)) { bjarni@8310: /* Engine is not buildable anymore */ bjarni@8310: return false; bjarni@8310: } bjarni@8310: rubidium@10207: if (c->money < (c->engine_renew_money + (2 * DoCommand(0, new_engine, 0, DC_QUERY_COST, CMD_BUILD_AIRCRAFT).GetCost()))) { bjarni@8310: /* We lack enough money to request the replacement right away. bjarni@8310: * We want 2*(the price of the new vehicle) and not looking at the value of the vehicle we are going to sell. bjarni@8310: * The reason is that we don't want to send a whole lot of vehicles to the hangars when we only have enough money to replace a single one. bjarni@8310: * Remember this happens in the background so the user can't stop this. */ bjarni@8310: return false; bjarni@8310: } bjarni@8310: bjarni@8310: /* We found no reason NOT to send the aircraft to a hangar so we will send it there at once */ bjarni@8310: return true; bjarni@8310: } 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@6123: /** In an Airport Hangar */ Darkvater@4842: static void AircraftEventHandler_InHangar(Vehicle *v, const AirportFTAClass *apc) truelight@0: { belugas@6123: /* 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@6123: /* if we were sent to the depot, stay there */ rubidium@8836: if (v->current_order.IsType(OT_GOTO_DEPOT) && (v->vehstatus & VS_STOPPED)) { bjarni@6263: v->current_order.Free(); truelight@0: return; truelight@0: } truelight@0: rubidium@8836: if (!v->current_order.IsType(OT_GOTO_STATION) && rubidium@8836: !v->current_order.IsType(OT_GOTO_DEPOT)) truelight@0: return; truelight@0: belugas@6123: /* 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@6123: /* We are already at the target airport, we need to find a terminal */ rubidium@8840: if (v->current_order.GetDestination() == v->u.air.targetairport) { belugas@6123: /* FindFreeTerminal: belugas@6123: * 1. Find a free terminal, 2. Occupy it, 3. Set the vehicle's state to that terminal */ Darkvater@5854: if (v->subtype == AIR_HELICOPTER) { Darkvater@5854: if (!AirportFindFreeHelipad(v, apc)) return; // helicopter Darkvater@5854: } else { Darkvater@4842: if (!AirportFindFreeTerminal(v, apc)) return; // airplane tron@2549: } tron@2549: } else { // Else prepare for launch. belugas@6123: /* airplane goto state takeoff, helicopter to helitakeoff */ Darkvater@5854: 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@6123: /** At one of the Airport's Terminals */ Darkvater@4842: static void AircraftEventHandler_AtTerminal(Vehicle *v, const AirportFTAClass *apc) truelight@0: { belugas@6123: /* 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@6123: /* on an airport with helipads, a helicopter will always land there belugas@6123: * and get serviced at the same time - patch setting */ rubidium@9413: if (_settings_game.order.serviceathelipad) { Darkvater@5854: if (v->subtype == AIR_HELICOPTER && apc->helipads != NULL) { belugas@6123: /* 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: bjarni@6263: if (!v->current_order.IsValid()) return; truelight@0: belugas@6123: /* 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@6123: /* airport-road is free. We either have to go to another airport, or to the hangar belugas@6123: * ---> start moving */ truelight@0: rubidium@10125: bool go_to_hangar = false; rubidium@8836: switch (v->current_order.GetType()) { truelight@0: case OT_GOTO_STATION: // ready to fly to another airport truelight@0: break; truelight@0: case OT_GOTO_DEPOT: // visit hangar for serivicing, sale, etc. rubidium@10125: go_to_hangar = v->current_order.GetDestination() == v->u.air.targetairport; truelight@0: break; rubidium@9688: case OT_CONDITIONAL: rubidium@9688: /* In case of a conditional order we just have to wait a tick rubidium@9688: * longer, so the conditional order can actually be processed; rubidium@9688: * we should not clear the order as that makes us go nowhere. */ rubidium@9688: return; truelight@0: default: // orders have been deleted (no orders), goto depot and don't bother us bjarni@6263: v->current_order.Free(); rubidium@10125: go_to_hangar = GetStation(v->u.air.targetairport)->Airport()->nof_depots != 0; rubidium@10125: } rubidium@10125: rubidium@10125: if (go_to_hangar) { rubidium@10125: v->u.air.state = HANGAR; rubidium@10125: } else { rubidium@10125: /* airplane goto state takeoff, helicopter to helitakeoff */ rubidium@10125: v->u.air.state = (v->subtype == AIR_HELICOPTER) ? HELITAKEOFF : TAKEOFF; 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@5380: assert("OK, you shouldn't be here, check your Airport Scheme!" && 0); truelight@0: } truelight@0: tron@6087: static void AircraftEventHandler_TakeOff(Vehicle *v, const AirportFTAClass *apc) tron@6087: { 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->u.air.state = ENDTAKEOFF; rubidium@6558: v->UpdateDeltaXY(INVALID_DIR); 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@6123: /* 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: { truelight@0: v->u.air.state = FLYING; rubidium@6558: v->UpdateDeltaXY(INVALID_DIR); rubidium@6558: belugas@6123: /* get the next position to go to, differs per airport */ truelight@0: AircraftNextAirportPos_and_Order(v); bjarni@1135: bjarni@8310: /* Send the helicopter to a hangar if needed for replacement */ bjarni@8310: if (CheckSendAircraftToHangarForReplacement(v)) { rubidium@10207: _current_company = v->owner; bjarni@8310: DoCommand(v->tile, v->index, DEPOT_SERVICE | DEPOT_LOCATE_HANGAR, DC_EXEC, CMD_SEND_AIRCRAFT_TO_HANGAR); rubidium@10207: _current_company = OWNER_NONE; bjarni@1135: } truelight@0: } truelight@0: Darkvater@4842: static void AircraftEventHandler_Flying(Vehicle *v, const AirportFTAClass *apc) truelight@0: { tron@6087: Station *st = GetStation(v->u.air.targetairport); truelight@0: belugas@6123: /* runway busy or not allowed to use this airstation, circle */ KUDr@6027: 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@6087: byte landingtype = (v->subtype == AIR_HELICOPTER) ? HELILANDING : LANDING; tron@6087: const AirportFTA *current = apc->layout[v->u.air.pos].next; truelight@0: while (current != NULL) { truelight@0: if (current->heading == landingtype) { belugas@6123: /* save speed before, since if AirportHasBlock is false, it resets them to 0 belugas@6123: * we don't want that for plane in air belugas@6123: * hack for speed thingie */ tron@6087: uint16 tcur_speed = v->cur_speed; tron@6087: uint16 tsubspeed = v->subspeed; Darkvater@4842: if (!AirportHasBlock(v, current, apc)) { truelight@0: v->u.air.state = landingtype; // LANDING / HELILANDING belugas@6123: /* it's a bit dirty, but I need to set position to next position, otherwise belugas@6123: * if there are multiple runways, plane won't know which one it took (because belugas@6123: * 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: { rubidium@6558: v->u.air.state = ENDLANDING; truelight@0: AircraftLandAirplane(v); // maybe crash airplane rubidium@6558: belugas@6123: /* check if the aircraft needs to be replaced or renewed and send it to a hangar if needed */ bjarni@8310: if (CheckSendAircraftToHangarForReplacement(v)) { rubidium@10207: _current_company = v->owner; bjarni@8310: DoCommand(v->tile, v->index, DEPOT_SERVICE, DC_EXEC, CMD_SEND_AIRCRAFT_TO_HANGAR); rubidium@10207: _current_company = OWNER_NONE; bjarni@1195: } truelight@0: } truelight@0: Darkvater@4842: static void AircraftEventHandler_HeliLanding(Vehicle *v, const AirportFTAClass *apc) truelight@0: { truelight@0: v->u.air.state = HELIENDLANDING; rubidium@6558: v->UpdateDeltaXY(INVALID_DIR); truelight@0: } truelight@0: Darkvater@4842: static void AircraftEventHandler_EndLanding(Vehicle *v, const AirportFTAClass *apc) truelight@0: { belugas@6123: /* 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@6123: /* if going to terminal (OT_GOTO_STATION) choose one belugas@6123: * 1. in case all terminals are busy AirportFindFreeTerminal() returns false or belugas@6123: * 2. not going for terminal (but depot, no order), belugas@6123: * --> get out of the way to the hangar. */ rubidium@8836: if (v->current_order.IsType(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@6123: /* 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@6123: /* if going to helipad (OT_GOTO_STATION) choose one. If airport doesn't have helipads, choose terminal belugas@6123: * 1. in case all terminals/helipads are busy (AirportFindFreeHelipad() returns false) or belugas@6123: * 2. not going for terminal (but depot, no order), belugas@6123: * --> get out of the way to the hangar IF there are terminals on the airport. belugas@6123: * --> else TAKEOFF belugas@6123: * the reason behind this is that if an airport has a terminal, it also has a hangar. Airplanes belugas@6123: * must go to a hangar. */ rubidium@8836: if (v->current_order.IsType(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@6123: /* 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@6099: static void AirportGoToNextPosition(Vehicle *v) truelight@0: { belugas@6123: /* if aircraft is not in position, wait until it is */ tron@2549: if (!AircraftController(v)) return; truelight@0: tron@6099: const AirportFTAClass *apc = GetStation(v->u.air.targetairport)->Airport(); tron@6099: Darkvater@4842: AirportClearBlock(v, apc); Darkvater@4842: AirportMove(v, apc); // move aircraft to next position truelight@0: } truelight@0: belugas@6123: /* gets pos from vehicle and next orders */ Darkvater@4842: static bool AirportMove(Vehicle *v, const AirportFTAClass *apc) truelight@0: { belugas@6123: /* error handling */ Darkvater@4842: if (v->u.air.pos >= apc->nofelements) { Darkvater@5380: 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@6087: const AirportFTA *current = &apc->layout[v->u.air.pos]; belugas@6123: /* we have arrived in an important state (eg terminal, hangar, etc.) */ truelight@0: if (current->heading == v->u.air.state) { tron@6087: byte prev_pos = v->u.air.pos; // location could be changed in state, so save it before-hand peter1138@6490: byte prev_state = v->u.air.state; 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; peter1138@6590: if (v->u.air.state != prev_state || v->u.air.pos != prev_pos) UpdateAircraftCache(v); 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@6123: /* 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; peter1138@6590: UpdateAircraftCache(v); truelight@0: } // move to next position celestar@3579: return false; truelight@0: } truelight@0: belugas@6123: /* there are more choices to choose from, choose the one that belugas@6123: * 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; peter1138@6590: UpdateAircraftCache(v); 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@6036: 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@6123: /* 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@6123: /* 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@6011: uint64 airport_flags = next->block; tron@2630: belugas@6123: /* 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@6123: /** belugas@6409: * "reserve" a block for the plane belugas@6123: * @param v airplane that requires the operation belugas@6409: * @param current_pos of the vehicle in the list of blocks belugas@6123: * @param apc airport on which block is requsted to be set belugas@6123: * @returns true on success. Eg, next block was free and we have occupied it belugas@6123: */ tron@6087: static bool AirportSetBlocks(Vehicle *v, const AirportFTA *current_pos, const AirportFTAClass *apc) truelight@0: { tron@6087: const AirportFTA *next = &apc->layout[current_pos->next_position]; tron@6087: const AirportFTA *reference = &apc->layout[v->u.air.pos]; truelight@0: belugas@6123: /* 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@6011: uint64 airport_flags = next->block; belugas@6123: /* search for all all elements in the list with the same state, and blocks != N belugas@6123: * this means more blocks should be checked/set */ tron@6087: 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@6123: /* if the block to be checked is in the next position, then exclude that from belugas@6123: * 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@6087: 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++) { skidd13@7928: if (!HasBit(st->airport_flags, _airport_terminal_flag[i])) { belugas@6123: /* TERMINAL# HELIPAD# */ richk@4059: v->u.air.state = _airport_terminal_state[i]; // start moving to that terminal/helipad skidd13@7931: 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@6087: 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@6087: const Station *st = GetStation(v->u.air.targetairport); tron@6087: 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@6123: /* read which group do we want to go to? belugas@6123: * (the first free group) */ tron@6087: uint target_group = temp->next_position + 1; celestar@950: belugas@6123: /* at what terminal does the group start? belugas@6123: * that means, sum up all terminals of belugas@6123: * groups with lower number */ tron@6087: uint group_start = 0; tron@6087: for (uint i = 1; i < target_group; i++) { Darkvater@4842: group_start += apc->terminals[i]; tron@6087: } celestar@950: tron@6087: 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@6123: /* 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@6087: 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@6123: /* if an airport doesn't have helipads, use terminals */ Darkvater@4842: if (apc->helipads == NULL) return AirportFindFreeTerminal(v, apc); truelight@0: belugas@6123: /* 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@6123: /* read which group do we want to go to? belugas@6123: * (the first free group) */ tron@6087: uint target_group = temp->next_position + 1; celestar@950: belugas@6123: /* at what terminal does the group start? belugas@6123: * that means, sum up all terminals of belugas@6123: * groups with lower number */ tron@6087: uint group_start = 0; tron@6087: for (uint i = 1; i < target_group; i++) { Darkvater@4842: group_start += apc->helipads[i]; tron@6087: } celestar@950: tron@6087: 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@6123: /* only 1 helicoptergroup, check all helipads belugas@6123: * 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 { rubidium@9000: if (!v->current_order.IsType(OT_LOADING)) v->breakdown_ctr--; truelight@0: } truelight@0: } truelight@0: truelight@0: HandleAircraftSmoke(v); rubidium@8830: ProcessOrders(v); rubidium@6594: v->HandleLoading(loop != 0); truelight@0: rubidium@8836: if (v->current_order.IsType(OT_LOADING) || v->current_order.IsType(OT_LEAVESTATION)) return; truelight@0: tron@6099: AirportGoToNextPosition(v); truelight@0: } truelight@0: rubidium@7135: void Aircraft::Tick() truelight@0: { rubidium@7135: if (!IsNormalAircraft(this)) return; truelight@0: smatz@8556: if (!(this->vehstatus & VS_STOPPED)) this->running_ticks++; smatz@8556: rubidium@7135: if (this->subtype == AIR_HELICOPTER) HelicopterTickHandler(this); truelight@0: rubidium@7135: AgeAircraftCargo(this); truelight@0: rubidium@8778: this->current_order_time++; rubidium@8778: celestar@6193: for (uint i = 0; i != 2; i++) { rubidium@7135: AircraftEventHandler(this, i); rubidium@7135: if (this->type != VEH_AIRCRAFT) // In case it was deleted truelight@0: break; truelight@0: } truelight@0: } truelight@0: celestar@950: smatz@10154: /** Returns aircraft's target station if v->u.air.target_airport smatz@10154: * is a valid station with airport. smatz@10154: * @param v vehicle to get target airport for smatz@10154: * @return pointer to target station, NULL if invalid smatz@10154: */ smatz@10154: Station *GetTargetAirportIfValid(const Vehicle *v) smatz@10154: { smatz@10154: assert(v->type == VEH_AIRCRAFT); smatz@10154: smatz@10154: StationID sid = v->u.air.targetairport; smatz@10154: smatz@10154: if (!IsValidStationID(sid)) return NULL; smatz@10154: smatz@10154: Station *st = GetStation(sid); smatz@10154: smatz@10154: return st->airport_tile == 0 ? NULL : st; smatz@10154: } smatz@10154: belugas@6123: /** need to be called to load aircraft from old version */ rubidium@6247: void UpdateOldAircraft() truelight@0: { belugas@6123: /* 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@6087: Vehicle *v_oldstyle; truelight@0: FOR_ALL_VEHICLES(v_oldstyle) { belugas@6123: /* airplane has another vehicle with subtype 4 (shadow), helicopter also has 3 (rotor) belugas@6123: * skip those */ rubidium@6259: if (v_oldstyle->type == VEH_AIRCRAFT && IsNormalAircraft(v_oldstyle)) { belugas@6123: /* 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@6153: GetNewVehiclePosResult gp = GetNewVehiclePos(v_oldstyle); truelight@0: v_oldstyle->tile = 0; // aircraft in air is tile=0 truelight@193: belugas@6123: /* correct speed of helicopter-rotors */ rubidium@7492: if (v_oldstyle->subtype == AIR_HELICOPTER) v_oldstyle->Next()->Next()->cur_speed = 32; truelight@0: belugas@6123: /* 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: belugas@6415: /** belugas@6415: * Updates the status of the Aircraft heading or in the station belugas@6415: * @param st Station been updated belugas@6415: */ tron@6087: void UpdateAirplanesOnNewStation(const Station *st) truelight@0: { belugas@6123: /* only 1 station is updated per function call, so it is enough to get entry_point once */ tron@6032: const AirportFTAClass *ap = st->Airport(); tron@6087: tron@6087: Vehicle *v; truelight@0: FOR_ALL_VEHICLES(v) { rubidium@6259: 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@6415: * you cannot delete airport, so it doesn't matter */ rubidium@4434: if (v->u.air.state >= FLYING) { // circle around celestar@6036: v->u.air.pos = v->u.air.previous_pos = AircraftGetEntryPoint(v, ap); truelight@0: v->u.air.state = FLYING; peter1138@6590: UpdateAircraftCache(v); belugas@6123: /* landing plane needs to be reset to flying height (only if in pause mode upgrade, belugas@6123: * in normal mode, plane is reset in AircraftController. It doesn't hurt for FLYING */ tron@6153: GetNewVehiclePosResult gp = GetNewVehiclePos(v); belugas@6123: /* 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@6087: byte takeofftype = (v->subtype == AIR_HELICOPTER) ? HELITAKEOFF : ENDTAKEOFF; belugas@6123: /* search in airportdata for that heading belugas@6123: * easiest to do, since this doesn't happen a lot */ tron@6087: 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; peter1138@6590: UpdateAircraftCache(v); truelight@0: break; truelight@0: } truelight@0: } truelight@0: } truelight@0: } truelight@0: } truelight@0: } truelight@0: }