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