Moved Stars45 to StarsEx

1 files changed, 957 insertions, 0 deletions

diff --git a/StarsEx/TacticalAI.cpp b/StarsEx/TacticalAI.cpp
new file mode 100644
index 0000000..7f4e64d
--- /dev/null
+++ b/StarsEx/TacticalAI.cpp
@@ -0,0 +1,957 @@
+/*  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
+    ========
+    Generic Ship Tactical Level AI class
+*/
+
+#include "TacticalAI.h"
+#include "ShipAI.h"
+#include "CarrierAI.h"
+#include "Ship.h"
+#include "ShipDesign.h"
+#include "Element.h"
+#include "Instruction.h"
+#include "RadioMessage.h"
+#include "RadioTraffic.h"
+#include "Contact.h"
+#include "WeaponGroup.h"
+#include "Drive.h"
+#include "Hangar.h"
+#include "Sim.h"
+#include "Shot.h"
+#include "Drone.h"
+#include "StarSystem.h"
+
+#include "Clock.h"
+#include "Random.h"
+
+// +----------------------------------------------------------------------+
+
+static int exec_time_seed = 0;
+
+// +----------------------------------------------------------------------+
+
+TacticalAI::TacticalAI(ShipAI* ai)
+: ship(0), ship_ai(0), carrier_ai(0), navpt(0), orders(0),
+action(0), threat_level(0), support_level(1),
+directed_tgtid(0)
+{
+    if (ai) {
+        ship_ai     = ai;
+        ship        = ai->GetShip();
+
+        Sim* sim    = Sim::GetSim();
+
+        if (ship && ship->GetHangar() && ship->GetCommandAILevel() > 0 &&
+                ship != sim->GetPlayerShip())
+        carrier_ai = new CarrierAI(ship, ship_ai->GetAILevel());
+    }
+
+    agression      = 0;
+    roe            = FLEXIBLE;
+    element_index  = 1;
+    exec_time      = exec_time_seed;
+    exec_time_seed += 17;
+}
+
+TacticalAI::~TacticalAI()
+{
+    delete carrier_ai;
+}
+
+// +--------------------------------------------------------------------+
+
+void
+TacticalAI::ExecFrame(double secs)
+{
+    const int exec_period = 1000;
+
+    if (!ship || !ship_ai)
+    return;
+
+    navpt    = ship->GetNextNavPoint();
+    orders   = ship->GetRadioOrders();
+
+    if ((int) Clock::GetInstance()->GameTime() - exec_time > exec_period) {
+        element_index = ship->GetElementIndex();
+
+        CheckOrders();
+        SelectTarget();
+        FindThreat();
+        FindSupport();
+
+        if (element_index > 1) {
+            int formation = 0;
+
+            if (orders && orders->Formation() >= 0)
+            formation = orders->Formation();
+
+            else if (navpt)
+            formation = navpt->Formation();
+
+            FindFormationSlot(formation);
+        }
+
+        ship_ai->SetNavPoint(navpt);
+
+        if (carrier_ai)
+        carrier_ai->ExecFrame(secs);
+
+        exec_time += exec_period;
+    }
+}
+
+// +--------------------------------------------------------------------+
+
+void
+TacticalAI::CheckOrders()
+{
+    directed_tgtid = 0;
+
+    if (CheckShipOrders())
+    return;
+
+    if (CheckFlightPlan())
+    return;
+
+    if (CheckObjectives())
+    return;
+}
+
+// +--------------------------------------------------------------------+
+
+bool
+TacticalAI::CheckShipOrders()
+{
+    return ProcessOrders();
+}
+
+// +--------------------------------------------------------------------+
+
+bool
+TacticalAI::CheckObjectives()
+{
+    bool     processed = false;
+    Ship*    ward      = 0;
+    Element* elem      = ship->GetElement();
+
+    if (elem) {
+        Instruction* obj = elem->GetTargetObjective();
+
+        if (obj) {
+            ship_ai->ClearPatrol();
+
+            if (obj->Action()) {
+                switch (obj->Action()) {
+                case Instruction::INTERCEPT:
+                case Instruction::STRIKE:
+                case Instruction::ASSAULT:
+                    {
+                        SimObject* tgt = obj->GetTarget();
+                        if (tgt && tgt->Type() == SimObject::SIM_SHIP) {
+                            roe = DIRECTED;
+                            SelectTargetDirected((Ship*) tgt);
+                        }
+                    }
+                    break;
+
+                case Instruction::DEFEND:
+                case Instruction::ESCORT:
+                    {
+                        SimObject* tgt = obj->GetTarget();
+                        if (tgt && tgt->Type() == SimObject::SIM_SHIP) {
+                            roe = DEFENSIVE;
+                            ward = (Ship*) tgt;
+                        }
+                    }
+                    break;
+
+                default:
+                    break;
+                }
+            }
+
+            orders    = obj;
+            processed = true;
+        }
+    }
+
+    ship_ai->SetWard(ward);
+    return processed;
+}
+
+// +--------------------------------------------------------------------+
+
+bool
+TacticalAI::ProcessOrders()
+{
+    if (ship_ai)
+        ship_ai->ClearPatrol();
+
+    if (orders && orders->EMCON() > 0) {
+        int desired_emcon = orders->EMCON();
+
+        if (ship_ai && (ship_ai->GetThreat() || ship_ai->GetThreatMissile()))
+        desired_emcon = 3;
+
+        if (ship->GetEMCON() != desired_emcon)
+        ship->SetEMCON(desired_emcon);
+    }
+
+    if (orders && orders->Action()) {
+        switch (orders->Action()) {
+        case RadioMessage::ATTACK:
+        case RadioMessage::BRACKET:
+        case RadioMessage::IDENTIFY:
+            {
+                bool        tgt_ok   = false;
+                SimObject*  tgt      = orders->GetTarget();
+
+                if (tgt && tgt->Type() == SimObject::SIM_SHIP) {
+                    Ship* tgt_ship = (Ship*) tgt;
+
+                    if (CanTarget(tgt_ship)) {
+                        roe = DIRECTED;
+                        SelectTargetDirected((Ship*) tgt);
+
+                        ship_ai->SetBracket(orders->Action() == RadioMessage::BRACKET);
+                        ship_ai->SetIdentify(orders->Action() == RadioMessage::IDENTIFY);
+                        ship_ai->SetNavPoint(0);
+
+                        tgt_ok = true;
+                    }
+                }
+
+                if (!tgt_ok)
+                ClearRadioOrders();
+            }
+            break;
+
+        case RadioMessage::ESCORT:
+        case RadioMessage::COVER_ME:
+            {
+                SimObject* tgt = orders->GetTarget();
+                if (tgt && tgt->Type() == SimObject::SIM_SHIP) {
+                    roe = DEFENSIVE;
+                    ship_ai->SetWard((Ship*) tgt);
+                    ship_ai->SetNavPoint(0);
+                }
+                else {
+                    ClearRadioOrders();
+                }
+            }
+            break;
+
+        case RadioMessage::WEP_FREE:
+            roe = AGRESSIVE;
+            ship_ai->DropTarget(0.1);
+            break;
+
+        case RadioMessage::WEP_HOLD:
+        case RadioMessage::FORM_UP:
+            roe = NONE;
+            ship_ai->DropTarget(5);
+            break;
+
+        case RadioMessage::MOVE_PATROL:
+            roe = SELF_DEFENSIVE;
+            ship_ai->SetPatrol(orders->Location());
+            ship_ai->SetNavPoint(0);
+            ship_ai->DropTarget(Random(5, 10));
+            break;
+
+        case RadioMessage::RTB:
+        case RadioMessage::DOCK_WITH:
+            roe = NONE;
+
+            ship_ai->DropTarget(10);
+
+            if (!ship->GetInbound()) {
+                RadioMessage* msg = 0;
+                Ship* controller = ship->GetController();
+
+                if (orders->Action() == RadioMessage::DOCK_WITH && orders->GetTarget()) {
+                    controller = (Ship*) orders->GetTarget();
+                }
+
+                if (!controller) {
+                    Element* elem = ship->GetElement();
+                    if (elem && elem->GetCommander()) {
+                        Element* cmdr = elem->GetCommander();
+                        controller    = cmdr->GetShip(1);
+                    }
+                }
+
+                if (controller && controller->GetHangar() &&
+                        controller->GetHangar()->CanStow(ship)) {
+                    SimRegion*  self_rgn = ship->GetRegion();
+                    SimRegion*  rtb_rgn  = controller->GetRegion();
+
+                    if (self_rgn == rtb_rgn) {
+                        double range = Point(controller->Location() - ship->Location()).length();
+
+                        if (range < 50e3) {
+                            msg = new RadioMessage(controller, ship, RadioMessage::CALL_INBOUND);
+                            RadioTraffic::Transmit(msg);
+                        }
+                    }
+                }
+                else {
+                    ship->ClearRadioOrders();
+                }
+
+                ship_ai->SetNavPoint(0);
+            }
+            break;
+
+        case RadioMessage::QUANTUM_TO:
+        case RadioMessage::FARCAST_TO:
+            roe = NONE;
+            ship_ai->DropTarget(10);
+            break;
+
+        }
+
+        action = orders->Action();
+        return true;
+    }
+
+    // if we had an action before, this must be a "cancel orders"
+    else if (action) {
+        ClearRadioOrders();
+    }
+
+    return false;
+}
+
+void
+TacticalAI::ClearRadioOrders()
+{
+    action = 0;
+    roe = FLEXIBLE;
+
+    if (ship_ai)
+    ship_ai->DropTarget(0.1);
+
+    if (ship)
+    ship->ClearRadioOrders();
+
+}
+
+// +--------------------------------------------------------------------+
+
+bool
+TacticalAI::CheckFlightPlan()
+{
+    Ship* ward = 0;
+
+    // Find next Instruction:
+    navpt = ship->GetNextNavPoint();
+
+    roe = FLEXIBLE;
+
+    if (navpt) {
+        switch (navpt->Action())  {
+        case Instruction::LAUNCH:
+        case Instruction::DOCK:
+        case Instruction::RTB:     roe = NONE;
+            break;
+
+        case Instruction::VECTOR:  roe = SELF_DEFENSIVE;
+            break;
+
+        case Instruction::DEFEND:
+        case Instruction::ESCORT:  roe = DEFENSIVE;
+            break;
+
+        case Instruction::INTERCEPT:
+            roe = DIRECTED;
+            break;
+
+        case Instruction::RECON:
+        case Instruction::STRIKE:
+        case Instruction::ASSAULT: roe = DIRECTED;
+            break;
+
+        case Instruction::PATROL:
+        case Instruction::SWEEP:   roe = FLEXIBLE;
+            break;
+
+        default: break;
+        }
+
+        if (roe == DEFENSIVE) {
+            SimObject* tgt = navpt->GetTarget();
+
+            if (tgt && tgt->Type() == SimObject::SIM_SHIP)
+            ward = (Ship*) tgt;
+        }
+
+
+        if (navpt->EMCON() > 0) {
+            int desired_emcon = navpt->EMCON();
+
+            if (ship_ai && (ship_ai->GetThreat() || ship_ai->GetThreatMissile()))
+            desired_emcon = 3;
+
+            if (ship->GetEMCON() != desired_emcon)
+            ship->SetEMCON(desired_emcon);
+        }
+    }
+
+    if (ship_ai)
+    ship_ai->SetWard(ward);
+
+    return (navpt != 0);
+}
+
+// +--------------------------------------------------------------------+
+
+void
+TacticalAI::SelectTarget()
+{
+    if (!ship) {
+        roe = NONE;
+        return;
+    }
+
+    // unarmed vessels should never engage an enemy:
+    if (ship->Weapons().size() < 1)
+    roe = NONE;
+
+    SimObject* target = ship_ai->GetTarget();
+    SimObject* ward   = ship_ai->GetWard();
+
+    // if not allowed to engage, drop and return:
+    if (roe == NONE) {
+        if (target)
+        ship_ai->DropTarget();
+        return;
+    }
+
+    // if we have abandoned our ward, drop and return:
+    if (ward && roe != AGRESSIVE) {
+        double d = (ward->Location() - ship->Location()).length();
+        double safe_zone = 50e3;
+
+        if (target) {
+            if (ship->IsStarship())
+            safe_zone = 100e3;
+
+            if (d > safe_zone) {
+                ship_ai->DropTarget();
+                return;
+            }
+        }
+        else {
+            if (d > safe_zone) {
+                return;
+            }
+        }
+    }
+
+    // already have a target, keep it:
+    if (target) {
+        if (target->Life()) {
+            CheckTarget();
+
+            // frigates need to be ready to abandon ship-type targets
+            // in favor of drone-type targets, others should just go
+            // with what they have:
+            if (ship->Class() != Ship::CORVETTE && ship->Class() != Ship::FRIGATE)
+            return;
+
+            // in case the check decided to drop the target:
+            target = ship_ai->GetTarget();
+        }
+
+        // if the old target is dead, forget it:
+        else {
+            ship_ai->DropTarget();
+            target = 0;
+        }
+    }
+
+    // if not allowed to acquire, forget it:
+    if (ship_ai->DropTime() > 0)
+    return;
+
+    if (roe == DIRECTED) {
+        if (target && target->Type() == SimObject::SIM_SHIP)
+        SelectTargetDirected((Ship*) target);
+        else if (navpt && navpt->GetTarget() && navpt->GetTarget()->Type() == SimObject::SIM_SHIP)
+        SelectTargetDirected((Ship*) navpt->GetTarget());
+        else
+        SelectTargetDirected();
+    }
+
+    else {
+        SelectTargetOpportunity();
+
+        // don't switch one ship target for another...
+        if (ship->Class() == Ship::CORVETTE || ship->Class() == Ship::FRIGATE) {
+            SimObject* potential_target = ship_ai->GetTarget();
+            if (target && potential_target && target != potential_target) {
+                if (target->Type()           == SimObject::SIM_SHIP &&
+                        potential_target->Type() == SimObject::SIM_SHIP) {
+
+                    ship_ai->SetTarget(target);
+                }
+            }
+        }
+    }
+}
+
+// +--------------------------------------------------------------------+
+
+void
+TacticalAI::SelectTargetDirected(Ship* tgt)
+{
+    Ship* potential_target = tgt;
+
+    // try to target one of the element's objectives
+    // (if it shows up in the contact list)
+
+    if (!tgt) {
+        Element* elem = ship->GetElement();
+
+        if (elem) {
+            Instruction* objective = elem->GetTargetObjective();
+
+            if (objective) {
+                SimObject* obj_sim_obj = objective->GetTarget();
+                Ship*      obj_tgt     = 0;
+
+                if (obj_sim_obj && obj_sim_obj->Type() == SimObject::SIM_SHIP)
+                obj_tgt = (Ship*) obj_sim_obj;
+
+                if (obj_tgt) {
+                    ListIter<Contact> contact = ship->ContactList();
+                    while (++contact && !potential_target) {
+                        Ship* test = contact->GetShip();
+
+                        if (obj_tgt == test) {
+                            potential_target = test;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (!CanTarget(potential_target))
+    potential_target = 0;
+
+    ship_ai->SetTarget(potential_target);
+
+    if (tgt && tgt == ship_ai->GetTarget())
+    directed_tgtid = tgt->Identity();
+    else
+    directed_tgtid = 0;
+}
+
+// +--------------------------------------------------------------------+
+
+bool
+TacticalAI::CanTarget(Ship* tgt)
+{
+    bool result = false;
+
+    if (tgt && !tgt->InTransition()) {
+        if (tgt->IsRogue() || tgt->GetIFF() != ship->GetIFF())
+        result = true;
+    }
+
+    return result;
+}
+
+// +--------------------------------------------------------------------+
+
+void
+TacticalAI::SelectTargetOpportunity()
+{
+    // NON-COMBATANTS do not pick targets of opportunity:
+    if (ship->GetIFF() == 0)
+    return;
+
+    SimObject* potential_target = 0;
+
+    // pick the closest combatant ship with a different IFF code:
+    double target_dist = ship->Design()->commit_range;
+
+    SimObject* ward   = ship_ai->GetWard();
+
+    // FRIGATES are primarily anti-air platforms, but may
+    // also attack smaller starships:
+
+    if (ship->Class() == Ship::CORVETTE || ship->Class() == Ship::FRIGATE) {
+        Ship* current_ship_target = 0;
+        Shot* current_shot_target = 0;
+
+        // if we are escorting a larger warship, it is good to attack
+        // the same target as our ward:
+
+        if (ward) {
+            Ship* s = (Ship*) ward;
+
+            if (s->Class() > ship->Class()) {
+                SimObject* obj = s->GetTarget();
+
+                if (obj && obj->Type() == SimObject::SIM_SHIP) {
+                    current_ship_target = (Ship*) obj;
+                    target_dist = (ship->Location() - obj->Location()).length();
+                }
+            }
+        }
+
+        ListIter<Contact> contact = ship->ContactList();
+        while (++contact) {
+            Ship* c_ship = contact->GetShip();
+            Shot* c_shot = contact->GetShot();
+
+            if (!c_ship && !c_shot)
+            continue;
+
+            int   c_iff  = contact->GetIFF(ship);
+            bool  rogue  = c_ship && c_ship->IsRogue();
+            bool  tgt_ok = c_iff > 0               &&
+            c_iff != ship->GetIFF() &&
+            c_iff < 1000;
+
+            if (rogue || tgt_ok) {
+                if (c_ship && c_ship != ship && !c_ship->InTransition()) {
+                    if (c_ship->Class() <  Ship::DESTROYER ||
+                            (c_ship->Class() >= Ship::MINE && c_ship->Class() <= Ship::DEFSAT)) {
+                        // found an enemy, check distance:
+                        double dist = (ship->Location() - c_ship->Location()).length();
+
+                        if (dist < 0.75 * target_dist &&
+                                (!current_ship_target || c_ship->Class() <= current_ship_target->Class())) {
+                            current_ship_target = c_ship;
+                            target_dist = dist;
+                        }
+                    }
+                }
+
+                else if (c_shot) {
+                    // found an enemy shot, is there enough time to engage?
+                    if (c_shot->GetEta() < 3)
+                    continue;
+
+                    // found an enemy shot, check distance:
+                    double dist = (ship->Location() - c_shot->Location()).length();
+
+                    if (!current_shot_target) {
+                        current_shot_target = c_shot;
+                        target_dist = dist;
+                    }
+
+                    // is this shot a better target than the one we've found?
+                    else {
+                        Ship* ward = ship_ai->GetWard();
+
+                        if ((c_shot->IsTracking(ward) || c_shot->IsTracking(ship)) &&
+                                (!current_shot_target->IsTracking(ward) ||
+                                    !current_shot_target->IsTracking(ship))) {
+                            current_shot_target = c_shot;
+                            target_dist = dist;
+                        }
+                        else if (dist < target_dist) {
+                            current_shot_target = c_shot;
+                            target_dist = dist;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (current_shot_target)
+        potential_target = current_shot_target;
+        else
+        potential_target = current_ship_target;
+    }
+
+    // ALL OTHER SHIP CLASSES ignore fighters and only engage
+    // other starships:
+
+    else {
+        List<Ship> ward_threats;
+
+        ListIter<Contact> contact = ship->ContactList();
+        while (++contact) {
+            Ship* c_ship = contact->GetShip();
+
+            if (!c_ship)
+            continue;
+
+            int   c_iff  = contact->GetIFF(ship);
+            bool  rogue  = c_ship->IsRogue();
+            bool  tgt_ok = c_ship != ship          &&
+            c_iff > 0               &&
+            c_iff != ship->GetIFF() &&
+            !c_ship->InTransition();
+
+            if (rogue || tgt_ok) {
+                if (c_ship->IsStarship() || c_ship->IsStatic()) {
+                    // found an enemy, check distance:
+                    double dist = (ship->Location() - c_ship->Location()).length();
+
+                    if (dist < 0.75 * target_dist) {
+                        potential_target = c_ship;
+                        target_dist = dist;
+                    }
+
+                    if (ward && c_ship->IsTracking(ward)) {
+                        ward_threats.append(c_ship);
+                    }
+                }
+            }
+        }
+
+        // if this ship is protecting a ward,
+        // prefer targets that are threatening that ward:
+        if (potential_target && ward_threats.size() && !ward_threats.contains((Ship*)potential_target)) {
+            target_dist *= 2;
+
+            ListIter<Ship> iter = ward_threats;
+            while (++iter) {
+                Ship* threat = iter.value();
+
+                double dist = (ward->Location() - threat->Location()).length();
+
+                if (dist < target_dist) {
+                    potential_target = threat;
+                    target_dist = dist;
+                }
+            }
+        }
+    }
+
+    if (ship->Class() != Ship::CARRIER && ship->Class() != Ship::SWACS)
+    ship_ai->SetTarget(potential_target);
+}
+
+// +--------------------------------------------------------------------+
+
+void
+TacticalAI::CheckTarget()
+{
+    SimObject* tgt = ship_ai->GetTarget();
+
+    if (!tgt) return;
+
+    if (tgt->GetRegion() != ship->GetRegion()) {
+        ship_ai->DropTarget();
+        return;
+    }
+
+    if (tgt->Type() == SimObject::SIM_SHIP) {
+        Ship* target = (Ship*) tgt;
+
+        // has the target joined our side?
+        if (target->GetIFF() == ship->GetIFF() && !target->IsRogue()) {
+            ship_ai->DropTarget();
+            return;
+        }
+
+        // is the target already jumping/breaking/dying?
+        if (target->InTransition()) {
+            ship_ai->DropTarget();
+            return;
+        }
+
+        // have we been ordered to pursue the target?
+        if (directed_tgtid) {
+            if (directed_tgtid != target->Identity()) {
+                ship_ai->DropTarget();
+            }
+
+            return;
+        }
+
+        // can we catch the target?
+        if (target->Design()->vlimit  <= ship->Design()->vlimit ||
+                ship->Velocity().length() <= ship->Design()->vlimit)
+        return;
+
+        // is the target now out of range?
+        WeaponDesign* wep_dsn = ship->GetPrimaryDesign();
+        if (!wep_dsn)
+        return;
+
+        // compute the "give up" range:
+        double drop_range = 3 * wep_dsn->max_range;
+        if (drop_range > 0.75 * ship->Design()->commit_range)
+        drop_range = 0.75 * ship->Design()->commit_range;
+
+        double range = Point(target->Location() - ship->Location()).length();
+        if (range < drop_range)
+        return;
+
+        // is the target closing or separating?
+        Point  delta = (target->Location() + target->Velocity()) -
+        (ship->Location()   + ship->Velocity());
+
+        if (delta.length() < range)
+        return;
+
+        ship_ai->DropTarget();
+    }
+
+    else if (tgt->Type() == SimObject::SIM_DRONE) {
+        Drone* drone = (Drone*) tgt;
+
+        // is the target still a threat?
+        if (drone->GetEta() < 1 || drone->GetTarget() == 0)
+        ship_ai->DropTarget();
+    }
+}
+
+// +--------------------------------------------------------------------+
+
+void
+TacticalAI::FindThreat()
+{
+    // pick the closest contact on Threat Warning System:
+    Ship*       threat               = 0;
+    Shot*       threat_missile       = 0;
+    Ship*       rumor                = 0;
+    double      threat_dist          = 1e9;
+    const DWORD THREAT_REACTION_TIME = 1000; // 1 second
+
+    ListIter<Contact> iter = ship->ContactList();
+
+    while (++iter) {
+        Contact* contact = iter.value();
+
+        if (contact->Threat(ship) &&
+                (Clock::GetInstance()->GameTime() - contact->AcquisitionTime()) > THREAT_REACTION_TIME) {
+
+            if (contact->GetShot()) {
+                threat_missile = contact->GetShot();
+                rumor = (Ship*) threat_missile->Owner();
+            }
+            else {
+                double rng = contact->Range(ship);
+
+                Ship* c_ship = contact->GetShip();
+                if (c_ship && !c_ship->InTransition()    &&
+                        c_ship->Class() != Ship::FREIGHTER &&
+                        c_ship->Class() != Ship::FARCASTER) {
+
+                    if (c_ship->GetTarget() == ship) {
+                        if (!threat || c_ship->Class() > threat->Class()) {
+                            threat      = c_ship;
+                            threat_dist = 0;
+                        }
+                    }
+                    else if (rng < threat_dist) {
+                        threat      = c_ship;
+                        threat_dist = rng;
+                    }
+                }
+            }
+        }
+    }
+
+    if (rumor && !rumor->InTransition()) {
+        iter.reset();
+
+        while (++iter) {
+            if (iter->GetShip() == rumor) {
+                rumor = 0;
+                ship_ai->ClearRumor();
+                break;
+            }
+        }
+    }
+    else {
+        rumor = 0;
+        ship_ai->ClearRumor();
+    }
+
+    ship_ai->SetRumor(rumor);
+    ship_ai->SetThreat(threat);
+    ship_ai->SetThreatMissile(threat_missile);
+}
+
+// +--------------------------------------------------------------------+
+
+void
+TacticalAI::FindSupport()
+{
+    if (!ship_ai->GetThreat()) {
+        ship_ai->SetSupport(0);
+        return;
+    }
+
+    // pick the biggest friendly contact in the sector:
+    Ship*       support        = 0;
+    double      support_dist   = 1e9;
+
+    ListIter<Contact> contact = ship->ContactList();
+
+    while (++contact) {
+        if (contact->GetShip() && contact->GetIFF(ship) == ship->GetIFF()) {
+            Ship* c_ship = contact->GetShip();
+
+            if (c_ship != ship && c_ship->Class() >= ship->Class() && !c_ship->InTransition()) {
+                if (!support || c_ship->Class() > support->Class())
+                support = c_ship;
+            }
+        }
+    }
+
+    ship_ai->SetSupport(support);
+}
+
+// +--------------------------------------------------------------------+
+
+void
+TacticalAI::FindFormationSlot(int formation)
+{
+    // find the formation delta:
+    int s = element_index - 1;
+    Point delta(10*s, 0, 10*s);
+
+    // diamond:
+    if (formation == Instruction::DIAMOND) {
+        switch (element_index) {
+        case 2:  delta = Point( 10,  0, -12); break;
+        case 3:  delta = Point(-10,  0, -12); break;
+        case 4:  delta = Point(  0,  0, -24); break;
+        }
+    }
+
+    // spread:
+    if (formation == Instruction::SPREAD) {
+        switch (element_index) {
+        case 2:  delta = Point( 15, 0, 0); break;
+        case 3:  delta = Point(-15, 0, 0); break;
+        case 4:  delta = Point(-30, 0, 0); break;
+        }
+    }
+
+    // box:
+    if (formation == Instruction::BOX) {
+        switch (element_index) {
+        case 2:  delta = Point(15,  0,   0); break;
+        case 3:  delta = Point( 0, -1, -15); break;
+        case 4:  delta = Point(15, -1, -15); break;
+        }
+    }
+
+    // trail:
+    if (formation == Instruction::TRAIL) {
+        delta = Point(0, 0, -15*s);
+    }
+
+    ship_ai->SetFormationDelta(delta * ship->Radius() * 2);
+}