From 3c487c5cd69c53d6fea948643c0a76df03516605 Mon Sep 17 00:00:00 2001 From: Aki Date: Fri, 1 Apr 2022 21:23:39 +0200 Subject: Moved Stars45 to StarsEx --- StarsEx/FlightDeck.cpp | 1185 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1185 insertions(+) create mode 100644 StarsEx/FlightDeck.cpp (limited to 'StarsEx/FlightDeck.cpp') diff --git a/StarsEx/FlightDeck.cpp b/StarsEx/FlightDeck.cpp new file mode 100644 index 0000000..8b2d070 --- /dev/null +++ b/StarsEx/FlightDeck.cpp @@ -0,0 +1,1185 @@ +/* Starshatter: The Open Source Project + Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors + Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors + Copyright (c) 1997-2006, Destroyer Studios LLC. + + AUTHOR: John DiCamillo + + + OVERVIEW + ======== + Everything needed to launch and recover space craft... +*/ + +#include "FlightDeck.h" +#include "Ship.h" +#include "ShipCtrl.h" +#include "ShipDesign.h" +#include "Element.h" +#include "Mission.h" +#include "MissionEvent.h" +#include "Drive.h" +#include "Sim.h" +#include "Instruction.h" +#include "Hoop.h" +#include "LandingGear.h" +#include "RadioMessage.h" +#include "RadioTraffic.h" +#include "SimEvent.h" +#include "AudioConfig.h" +#include "CameraDirector.h" +#include "Combatant.h" +#include "CombatGroup.h" +#include "CombatUnit.h" + +#include "NetData.h" +#include "NetUtil.h" + +#include "Game.h" +#include "ContentBundle.h" +#include "Solid.h" +#include "Light.h" +#include "Sound.h" +#include "DataLoader.h" + +static Sound* tire_sound = 0; +static Sound* catapult_sound = 0; + +// +======================================================================+ + +class FlightDeckSlot +{ +public: + FlightDeckSlot() : ship(0), state(0), sequence(0), time(0), filter(0xf) { } + int operator == (const FlightDeckSlot& that) const { return this == &that; } + + Ship* ship; + Point spot_rel; + Point spot_loc; + + int state; + int sequence; + double time; + double clearance; + DWORD filter; +}; + +// +======================================================================+ + +InboundSlot::InboundSlot(Ship* s, FlightDeck* d, int squad, int index) +: ship(s), deck(d), squadron(squad), slot(index), cleared(0), final(0), approach(0) +{ + if (ship) + Observe(ship); + + if (deck && deck->GetCarrier()) + Observe((SimObject*) deck->GetCarrier()); +} + +int InboundSlot::operator < (const InboundSlot& that) const +{ + double dthis = 0; + double dthat = 0; + + if (ship == that.ship) { + return false; + } + + if (cleared && !that.cleared) { + return true; + } + + if (!cleared && that.cleared) { + return false; + } + + if (ship && deck && that.ship) { + dthis = Point(ship->Location() - deck->MountLocation()).length(); + dthat = Point(that.ship->Location() - deck->MountLocation()).length(); + } + + if (dthis == dthat) { + return (DWORD) this < (DWORD) &that; + } + + return dthis < dthat; +} + +int InboundSlot::operator <= (const InboundSlot& that) const +{ + double dthis = 0; + double dthat = 0; + + if (ship == that.ship) + return true; + + if (cleared && !that.cleared) + return true; + + if (!cleared && that.cleared) + return false; + + if (ship && deck && that.ship) { + dthis = Point(ship->Location() - deck->MountLocation()).length(); + dthat = Point(that.ship->Location() - deck->MountLocation()).length(); + } + + return dthis <= dthat; +} + +int InboundSlot::operator == (const InboundSlot& that) const +{ + return this == &that; +} + +void InboundSlot::Clear(bool c) +{ + if (ship) + cleared = c; +} + +double InboundSlot::Distance() +{ + if (ship && deck) { + return Point(ship->Location() - deck->MountLocation()).length(); + } + + return 1e9; +} + +// +----------------------------------------------------------------------+ + +bool +InboundSlot::Update(SimObject* obj) +{ + if (obj->Type() == SimObject::SIM_SHIP) { + Ship* s = (Ship*) obj; + + if (s == ship) { + ship = 0; + } + + // Actually, this can't happen. The flight deck + // owns the slot. When the carrier is destroyed, + // the flight decks and slots are destroyed before + // the carrier updates the observers. + + // I'm leaving this block in, just in case. + + else if (deck && s == deck->GetCarrier()) { + ship = 0; + deck = 0; + } + } + + return SimObserver::Update(obj); +} + +const char* +InboundSlot::GetObserverName() const +{ + return "InboundSlot"; +} + +// +======================================================================+ + +FlightDeck::FlightDeck() +: System(FLIGHT_DECK, FLIGHT_DECK_LAUNCH, "Flight Deck", 1, 1), +carrier(0), index(0), num_slots(0), slots(0), cycle_time(5), num_hoops(0), hoops(0), +azimuth(0), light(0), num_catsounds(0), num_approach_pts(0) +{ + name = ContentBundle::GetInstance()->GetText("sys.flight-deck"); + abrv = ContentBundle::GetInstance()->GetText("sys.flight-deck.abrv"); +} + +// +----------------------------------------------------------------------+ + +FlightDeck::FlightDeck(const FlightDeck& s) +: System(s), +carrier(0), index(0), start_rel(s.start_rel), +end_rel(s.end_rel), cam_rel(s.cam_rel), +cycle_time(s.cycle_time), +num_slots(s.num_slots), slots(0), +num_hoops(0), hoops(0), azimuth(s.azimuth), light(0), +num_catsounds(0), num_approach_pts(s.num_approach_pts) +{ + Mount(s); + + slots = new FlightDeckSlot[num_slots]; + for (int i = 0; i < num_slots; i++) { + slots[i].spot_rel = s.slots[i].spot_rel; + slots[i].filter = s.slots[i].filter; + } + + for (int i = 0; i < NUM_APPROACH_PTS; i++) + approach_rel[i] = s.approach_rel[i]; + + for (int i = 0; i < 2; i++) + runway_rel[i] = s.runway_rel[i]; + + if (s.light) { + light = new Light(*s.light); + } +} + +// +--------------------------------------------------------------------+ + +FlightDeck::~FlightDeck() +{ + if (hoops && num_hoops) { + for (int i = 0; i < num_hoops; i++) { + Hoop* h = &hoops[i]; + Scene* scene = h->GetScene(); + if (scene) + scene->DelGraphic(h); + } + } + + delete [] slots; + delete [] hoops; + + LIGHT_DESTROY(light); + + recovery_queue.destroy(); +} + +// +--------------------------------------------------------------------+ + +void +FlightDeck::Initialize() +{ + static int initialized = 0; + if (initialized) return; + + DataLoader* loader = DataLoader::GetLoader(); + loader->SetDataPath("Sounds/"); + + const int SOUND_FLAGS = Sound::LOCALIZED | + Sound::LOC_3D; + + loader->LoadSound("Tires.wav", tire_sound, SOUND_FLAGS); + loader->LoadSound("Catapult.wav", catapult_sound, SOUND_FLAGS); + loader->SetDataPath(0); + + if (tire_sound) + tire_sound->SetMaxDistance(2.5e3f); + + if (catapult_sound) + catapult_sound->SetMaxDistance(0.5e3f); + + initialized = 1; +} + +// +--------------------------------------------------------------------+ + +void +FlightDeck::Close() +{ + delete tire_sound; + delete catapult_sound; + + tire_sound = 0; + catapult_sound = 0; +} + +// +--------------------------------------------------------------------+ + +void +FlightDeck::ExecFrame(double seconds) +{ + System::ExecFrame(seconds); + + bool advance_queue = false; + long max_vol = AudioConfig::EfxVolume(); + long volume = -1000; + Sim* sim = Sim::GetSim(); + + if (volume > max_vol) + volume = max_vol; + + // update ship status: + for (int i = 0; i < num_slots; i++) { + FlightDeckSlot* slot = &slots[i]; + Ship* slot_ship = 0; + + if (slot->ship == 0) { + slot->state = CLEAR; + } + else { + slot_ship = slot->ship; + slot_ship->SetThrottle(0); + } + + switch (slot->state) { + case CLEAR: + if (slot->time > 0) { + slot->time -= seconds; + } + else if (IsRecoveryDeck()) { + GrantClearance(); + } + break; + + case READY: { + Camera c; + c.Clone(carrier->Cam()); + c.Yaw(azimuth); + + if (slot_ship) { + slot_ship->CloneCam(c); + slot_ship->MoveTo(slot->spot_loc); + slot_ship->TranslateBy(carrier->Cam().vup() * slot->clearance); + slot_ship->SetVelocity(carrier->Velocity()); + } + slot->time = 0; + } + break; + + case QUEUED: + if (slot->time > 0) { + Camera c; + c.Clone(carrier->Cam()); + c.Yaw(azimuth); + + slot->time -= seconds; + if (slot_ship) { + slot_ship->CloneCam(c); + slot_ship->MoveTo(slot->spot_loc); + slot_ship->TranslateBy(carrier->Cam().vup() * slot->clearance); + slot_ship->SetFlightPhase(Ship::ALERT); + } + } + + if (slot->sequence == 1 && slot->time <= 0) { + bool clear_for_launch = true; + for (int i = 0; i < num_slots; i++) + if (slots[i].state == LOCKED) + clear_for_launch = false; + + if (clear_for_launch) { + slot->sequence = 0; + slot->state = LOCKED; + slot->time = cycle_time; + if (slot_ship) + slot_ship->SetFlightPhase(Ship::LOCKED); + num_catsounds = 0; + + advance_queue = true; + } + } + break; + + case LOCKED: + if (slot->time > 0) { + slot->time -= seconds; + + if (slot_ship) { + double ct4 = cycle_time/4; + + double dx = start_rel.x - slot->spot_rel.x; + double dy = start_rel.z - slot->spot_rel.z; + double dyaw = atan2(dx,dy) - azimuth; + + Camera c; + c.Clone(carrier->Cam()); + c.Yaw(azimuth); + + // rotate: + if (slot->time > 3*ct4) { + double step = 1 - (slot->time - 3*ct4) / ct4; + c.Yaw(dyaw * step); + slot_ship->CloneCam(c); + slot_ship->MoveTo(slot->spot_loc); + slot_ship->TranslateBy(carrier->Cam().vup() * slot->clearance); + + if (carrier->IsGroundUnit()) { + slot_ship->SetThrottle(25); + } + + else if (num_catsounds < 1) { + if (catapult_sound) { + Sound* sound = catapult_sound->Duplicate(); + sound->SetLocation(slot_ship->Location()); + sound->SetVolume(volume); + sound->Play(); + } + num_catsounds = 1; + } + } + + // translate: + else if (slot->time > 2*ct4) { + double step = (slot->time - 2*ct4) / ct4; + + Point loc = start_point + + (slot->spot_loc - start_point) * step; + + c.Yaw(dyaw); + slot_ship->CloneCam(c); + slot_ship->MoveTo(loc); + slot_ship->TranslateBy(carrier->Cam().vup() * slot->clearance); + + if (carrier->IsGroundUnit()) { + slot_ship->SetThrottle(25); + } + + else if (num_catsounds < 2) { + if (catapult_sound) { + Sound* sound = catapult_sound->Duplicate(); + sound->SetLocation(slot_ship->Location()); + sound->SetVolume(volume); + sound->Play(); + } + num_catsounds = 2; + } + } + + // rotate: + else if (slot->time > ct4) { + double step = (slot->time - ct4) / ct4; + c.Yaw(dyaw*step); + slot_ship->CloneCam(c); + slot_ship->MoveTo(start_point); + slot_ship->TranslateBy(carrier->Cam().vup() * slot->clearance); + + if (carrier->IsGroundUnit()) { + slot_ship->SetThrottle(25); + } + + else if (num_catsounds < 3) { + if (catapult_sound) { + Sound* sound = catapult_sound->Duplicate(); + sound->SetLocation(slot_ship->Location()); + sound->SetVolume(volume); + sound->Play(); + } + num_catsounds = 3; + } + } + + // wait: + else { + slot_ship->SetThrottle(100); + slot_ship->CloneCam(c); + slot_ship->MoveTo(start_point); + slot_ship->TranslateBy(carrier->Cam().vup() * slot->clearance); + } + + slot_ship->SetFlightPhase(Ship::LOCKED); + } + } + else { + slot->state = LAUNCH; + slot->time = 0; + + } + break; + + case LAUNCH: + LaunchShip(slot_ship); + break; + + case DOCKING: + if (slot_ship && !slot_ship->IsAirborne()) { + // do arresting gear stuff: + if (slot_ship->GetFlightModel() == Ship::FM_ARCADE) + slot_ship->ArcadeStop(); + + slot_ship->SetVelocity(carrier->Velocity()); + } + + if (slot->time > 0) { + slot->time -= seconds; + } + else { + if (slot_ship) { + slot_ship->SetFlightPhase(Ship::DOCKED); + slot_ship->Stow(); + + NetUtil::SendObjKill(slot_ship, carrier, NetObjKill::KILL_DOCK, index); + } + + Clear(i); + } + break; + + default: + break; + } + } + + if (advance_queue) { + for (int i = 0; i < num_slots; i++) { + FlightDeckSlot* slot = &slots[i]; + if (slot->state == QUEUED && slot->sequence > 1) + slot->sequence--; + } + } +} + +bool +FlightDeck::LaunchShip(Ship* slot_ship) +{ + FlightDeckSlot* slot = 0; + Sim* sim = Sim::GetSim(); + + if (slot_ship) { + for (int i = 0; i < num_slots; i++) { + if (slots[i].ship == slot_ship) + slot = &(slots[i]); + } + + // only suggest a launch point if no flight plan has been filed... + if (slot_ship->GetElement()->FlightPlanLength() == 0) { + Point departure = end_point; + departure = departure.OtherHand(); + + Instruction* launch_point = new + Instruction(carrier->GetRegion(), departure, Instruction::LAUNCH); + launch_point->SetSpeed(350); + + slot_ship->SetLaunchPoint(launch_point); + } + + if (!slot_ship->IsAirborne()) { + Point cat; + if (fabs(azimuth) < 5*DEGREES) { + cat = carrier->Heading() * 300; + } + else { + Camera c; + c.Clone(carrier->Cam()); + c.Yaw(azimuth); + cat = c.vpn() * 300; + } + + slot_ship->SetVelocity(carrier->Velocity() + cat); + slot_ship->SetFlightPhase(Ship::LAUNCH); + } + else { + slot_ship->SetFlightPhase(Ship::TAKEOFF); + } + + Director* dir = slot_ship->GetDirector(); + if (dir && dir->Type() == ShipCtrl::DIR_TYPE) { + ShipCtrl* ctrl = (ShipCtrl*) dir; + ctrl->Launch(); + } + + ShipStats* c = ShipStats::Find(carrier->Name()); + if (c) c->AddEvent(SimEvent::LAUNCH_SHIP, slot_ship->Name()); + + ShipStats* stats = ShipStats::Find(slot_ship->Name()); + if (stats) { + stats->SetRegion(carrier->GetRegion()->Name()); + stats->SetType(slot_ship->Design()->name); + + if (slot_ship->GetElement()) { + Element* elem = slot_ship->GetElement(); + stats->SetRole(Mission::RoleName(elem->Type())); + stats->SetCombatGroup(elem->GetCombatGroup()); + stats->SetCombatUnit(elem->GetCombatUnit()); + stats->SetElementIndex(slot_ship->GetElementIndex()); + } + + stats->SetIFF(slot_ship->GetIFF()); + stats->AddEvent(SimEvent::LAUNCH, carrier->Name()); + + if (slot_ship == sim->GetPlayerShip()) + stats->SetPlayer(true); + } + + sim->ProcessEventTrigger(MissionEvent::TRIGGER_LAUNCH, 0, slot_ship->Name()); + + if (slot) { + slot->ship = 0; + slot->state = CLEAR; + slot->sequence = 0; + slot->time = 0; + } + + return true; + } + + return false; +} + +// +----------------------------------------------------------------------+ + +void +FlightDeck::SetLight(double l) +{ + LIGHT_DESTROY(light); + light = new Light((float) l); +} + +void +FlightDeck::SetApproachPoint(int i, Point loc) +{ + if (i >= 0 && i < NUM_APPROACH_PTS) { + approach_rel[i] = loc; + + if (i >= num_approach_pts) + num_approach_pts = i+1; + } +} + +void +FlightDeck::SetRunwayPoint(int i, Point loc) +{ + if (i >= 0 && i < 2) + runway_rel[i] = loc; +} + +void +FlightDeck::SetStartPoint(Point loc) +{ + start_rel = loc; +} + +void +FlightDeck::SetEndPoint(Point loc) +{ + end_rel = loc; +} + +void +FlightDeck::SetCamLoc(Point loc) +{ + cam_rel = loc; +} + +// +----------------------------------------------------------------------+ + +void +FlightDeck::AddSlot(const Point& spot, DWORD filter) +{ + if (!slots) + slots = new FlightDeckSlot[10]; + + slots[num_slots].spot_rel = spot; + slots[num_slots].filter = filter; + num_slots++; +} + +// +----------------------------------------------------------------------+ + +void +FlightDeck::SetCycleTime(double t) +{ + cycle_time = t; +} + +// +----------------------------------------------------------------------+ + +void +FlightDeck::Orient(const Physical* rep) +{ + System::Orient(rep); + + Matrix orientation = rep->Cam().Orientation(); + Point loc = rep->Location(); + + start_point = (start_rel * orientation) + loc; + end_point = (end_rel * orientation) + loc; + cam_loc = (cam_rel * orientation) + loc; + + for (int i = 0; i < num_approach_pts; i++) + approach_point[i] = (approach_rel[i] * orientation) + loc; + + for (int i = 0; i < num_slots; i++) + slots[i].spot_loc = (slots[i].spot_rel * orientation) + loc; + + if (IsRecoveryDeck()) { + if (carrier->IsAirborne()) { + runway_point[0] = (runway_rel[0] * orientation) + loc; + runway_point[1] = (runway_rel[1] * orientation) + loc; + } + + if (num_hoops < 1) { + num_hoops = 4; + hoops = new Hoop[num_hoops]; + } + + Point hoop_vec = start_point - end_point; + double hoop_d = hoop_vec.Normalize() / num_hoops; + + orientation.Yaw(azimuth); + + for (int i = 0; i < num_hoops; i++) { + hoops[i].MoveTo(end_point + hoop_vec * (i+1) * hoop_d); + hoops[i].SetOrientation(orientation); + } + } + + if (light) + light->MoveTo(mount_loc); +} + +// +----------------------------------------------------------------------+ + +int +FlightDeck::SpaceLeft(int type) const +{ + int space_left = 0; + + for (int i = 0; i < num_slots; i++) + if (slots[i].ship == 0 && (slots[i].filter & type)) + space_left++; + + return space_left; +} + +// +----------------------------------------------------------------------+ + +bool +FlightDeck::Spot(Ship* s, int& index) +{ + if (!s) + return false; + + if (index < 0) { + for (int i = 0; i < num_slots; i++) { + if (slots[i].ship == 0 && (slots[i].filter & s->Class())) { + index = i; + break; + } + } + } + + if (index >= 0 && index < num_slots && slots[index].ship == 0) { + slots[index].state = READY; + slots[index].ship = s; + slots[index].clearance = 0; + + if (s->GetGear()) + slots[index].clearance = s->GetGear()->GetClearance(); + + if (IsRecoveryDeck() && !s->IsAirborne()) { + s->SetVelocity(s->Velocity() * 0.01); // hit the brakes! + } + + if (!IsRecoveryDeck()) { + Camera work; + work.Clone(carrier->Cam()); + work.Yaw(azimuth); + + s->CloneCam(work); + s->MoveTo(slots[index].spot_loc); + + LandingGear* g = s->GetGear(); + if (g) { + g->SetState(LandingGear::GEAR_DOWN); + g->ExecFrame(0); + s->TranslateBy(carrier->Cam().vup() * slots[index].clearance); + } + + s->SetFlightPhase(Ship::ALERT); + } + + s->SetCarrier(carrier, this); + Observe(s); + + return true; + } + + return false; +} + +bool +FlightDeck::Clear(int index) +{ + if (index >= 0 && index < num_slots && slots[index].ship != 0) { + Ship* s = slots[index].ship; + + slots[index].ship = 0; + slots[index].time = cycle_time; + slots[index].state = CLEAR; + + ListIter iter = recovery_queue; + while (++iter) { + if (iter->GetShip() == s) { + delete iter.removeItem(); // ??? SHOULD DELETE HERE ??? + break; + } + } + + return true; + } + + return false; +} + +// +----------------------------------------------------------------------+ + +bool +FlightDeck::Launch(int index) +{ + if (subtype == FLIGHT_DECK_LAUNCH && index >= 0 && index < num_slots) { + FlightDeckSlot* slot = &slots[index]; + + if (slot->ship && slot->state == READY) { + int last = 0; + FlightDeckSlot* last_slot = 0; + FlightDeckSlot* lock_slot = 0; + + for (int i = 0; i < num_slots; i++) { + FlightDeckSlot* s = &slots[i]; + + if (s->state == QUEUED && s->sequence > last) { + last = s->sequence; + last_slot = s; + } + + else if (s->state == LOCKED) { + lock_slot = s; + } + } + + // queue the slot for launch: + slot->state = QUEUED; + slot->sequence = last + 1; + slot->time = 0; + + if (last_slot) + slot->time = last_slot->time + cycle_time; + + else if (lock_slot) + slot->time = lock_slot->time; + + return true; + } + } + + return false; +} + +// +----------------------------------------------------------------------+ + +bool +FlightDeck::Recover(Ship* s) +{ + if (s && subtype == FLIGHT_DECK_RECOVERY) { + if (OverThreshold(s)) { + if (s->GetFlightPhase() < Ship::RECOVERY) { + s->SetFlightPhase(Ship::RECOVERY); + s->SetCarrier(carrier, this); // let ship know which flight deck it's in (needed for dock cam) + } + + // are we there yet? + if (s->GetFlightPhase() >= Ship::ACTIVE && s->GetFlightPhase() < Ship::DOCKING) { + if (slots[0].ship == 0) { // only need to ask this on approach + double dock_distance = (s->Location() - MountLocation()).length(); + + if (s->IsAirborne()) { + double altitude = s->Location().y - MountLocation().y; + if (dock_distance < Radius()*3 && altitude < s->Radius()) + Dock(s); + } + else { + if (dock_distance < s->Radius()) + Dock(s); + } + } + } + + return true; + } + else { + if (s->GetFlightPhase() == Ship::RECOVERY) + s->SetFlightPhase(Ship::ACTIVE); + } + } + + return false; +} + +bool +FlightDeck::Dock(Ship* s) +{ + if (s && subtype == FLIGHT_DECK_RECOVERY && slots[0].time <= 0) { + int index = 0; + if (Spot(s, index)) { + s->SetFlightPhase(Ship::DOCKING); + s->SetCarrier(carrier, this); + + // hard landings? + if (Ship::GetLandingModel() == 0) { + double base_damage = s->Design()->integrity; + + // did player do something stupid? + if (s->GetGear() && !s->IsGearDown()) { + Print("FlightDeck::Dock(%s) Belly landing!\n", s->Name()); + s->InflictDamage(0.5 * base_damage); + } + + double docking_deflection = fabs(carrier->Cam().vup().y - s->Cam().vup().y); + + if (docking_deflection > 0.35) { + Print("Landing upside down? y = %.3f\n", docking_deflection); + s->InflictDamage(0.8 * base_damage); + } + + // did incoming ship exceed safe landing parameters? + if (s->IsAirborne()) { + if (s->Velocity().y < -20) { + Print("FlightDeck::Dock(%s) Slammed it!\n", s->Name()); + s->InflictDamage(0.1 * base_damage); + } + } + + // did incoming ship exceed safe docking speed? + else { + Point delta_v = s->Velocity() - carrier->Velocity(); + double excess = (delta_v.length() - 100); + + if (excess > 0) + s->InflictDamage(excess); + } + } + + if (s->IsAirborne()) { + if (s == Sim::GetSim()->GetPlayerShip() && tire_sound) { + Sound* sound = tire_sound->Duplicate(); + sound->Play(); + } + } + + if (s->GetDrive()) + s->GetDrive()->PowerOff(); + + slots[index].state = DOCKING; + slots[index].time = 5; + + if (s->IsAirborne()) + slots[index].time = 7.5; + return true; + } + } + + return false; +} + +int +FlightDeck::Inbound(InboundSlot*& s) +{ + if (s && s->GetShip()) { + Ship* inbound = s->GetShip(); + + if (recovery_queue.contains(s)) { + InboundSlot* orig = s; + s = recovery_queue.find(s); + delete orig; + } + else { + recovery_queue.append(s); + Observe(s->GetShip()); + } + + inbound->SetInbound(s); + + // find the best initial approach point for this ship: + double current_distance = 1e9; + for (int i = 0; i < num_approach_pts; i++) { + double distance = Point(inbound->Location() - approach_point[i]).length(); + if (distance < current_distance) { + current_distance = distance; + s->SetApproach(i); + } + } + + Point offset(rand()-16000, rand()-16000, rand()-16000); + offset.Normalize(); + offset *= 200; + + s->SetOffset(offset); + + // *** DEBUG *** + // PrintQueue(); + + // if the new guy is first in line, and the deck is almost ready, + // go ahead and clear him for approach now + recovery_queue.sort(); + if (recovery_queue[0] == s && !s->Cleared() && slots[0].time <= 3) + s->Clear(); + + return recovery_queue.index(s) + 1; + } + + return 0; +} + +void +FlightDeck::GrantClearance() +{ + if (recovery_queue.size() > 0) { + if (recovery_queue[0]->Cleared() && recovery_queue[0]->Distance() > 45e3) { + recovery_queue[0]->Clear(false); + } + + if (!recovery_queue[0]->Cleared()) { + recovery_queue.sort(); + + if (recovery_queue[0]->Distance() < 35e3) { + recovery_queue[0]->Clear(); + + Ship* dst = recovery_queue[0]->GetShip(); + + RadioMessage* clearance = new RadioMessage(dst, carrier, RadioMessage::CALL_CLEARANCE); + clearance->SetInfo(Text("for final approach to ") + Name()); + RadioTraffic::Transmit(clearance); + } + } + } +} + +// +----------------------------------------------------------------------+ + +void +FlightDeck::PrintQueue() +{ + Print("\nRecovery Queue for %s\n", Name()); + if (recovery_queue.size() < 1) { + Print(" (empty)\n\n"); + return; + } + + for (int i = 0; i < recovery_queue.size(); i++) { + InboundSlot* s = recovery_queue.at(i); + + if (!s) { + Print(" %2d. null\n", i); + } + else if (!s->GetShip()) { + Print(" %2d. ship is null\n", i); + } + else { + double d = Point(s->GetShip()->Location() - MountLocation()).length(); + Print(" %2d. %c %-20s %8d km\n", i, s->Cleared()?'*':' ', s->GetShip()->Name(), (int) (d/1000)); + } + } + + Print("\n"); +} + +// +----------------------------------------------------------------------+ + +Ship* +FlightDeck::GetShip(int index) const +{ + if (index >= 0 && index < num_slots) + return slots[index].ship; + + return 0; +} + +double +FlightDeck::TimeRemaining(int index) const +{ + if (index >= 0 && index < num_slots) + return slots[index].time; + + return 0; +} + + +int +FlightDeck::State(int index) const +{ + if (index >= 0 && index < num_slots) + return slots[index].state; + + return 0; +} + +int +FlightDeck::Sequence(int index) const +{ + if (index >= 0 && index < num_slots) + return slots[index].sequence; + + return 0; +} + +// +----------------------------------------------------------------------+ + +bool +FlightDeck::Update(SimObject* obj) +{ + if (obj->Type() == SimObject::SIM_SHIP) { + Ship* s = (Ship*) obj; + + ListIter iter = recovery_queue; + while (++iter) { + InboundSlot* recovery_slot = iter.value(); + + if (recovery_slot->GetShip() == s || recovery_slot->GetShip() == 0) { + delete iter.removeItem(); + } + } + + for (int i = 0; i < num_slots; i++) { + FlightDeckSlot* slot = &slots[i]; + + if (slot->ship == s) { + slot->ship = 0; + slot->state = 0; + slot->sequence = 0; + slot->time = 0; + break; + } + } + } + + return SimObserver::Update(obj); +} + +const char* +FlightDeck::GetObserverName() const +{ + return Name(); +} + +// +----------------------------------------------------------------------+ + +bool +FlightDeck::OverThreshold(Ship* s) const +{ + if (carrier->IsAirborne()) { + if (s->AltitudeAGL() > s->Radius() * 4) + return false; + + const Point& sloc = s->Location(); + + // is ship between the markers? + double distance = 1e9; + + Point d0 = runway_point[0] - sloc; + Point d1 = runway_point[1] - sloc; + double d = d0 * d1; + bool between = (d0 * d1) < 0; + + if (between) { + // distance from point to line: + Point src = runway_point[0]; + Point dir = runway_point[1] - src; + Point w = (sloc - src).cross(dir); + + distance = w.length() / dir.length(); + } + + return distance < Radius(); + } + + else { + return (s->Location() - MountLocation()).length() < (s->Radius() + Radius()); + } +} + +// +----------------------------------------------------------------------+ + +bool +FlightDeck::ContainsPoint(const Point& p) const +{ + return (p - MountLocation()).length() < Radius(); +} -- cgit v1.1