1117 lines
50 KiB
C
1117 lines
50 KiB
C
class ERR_HQUnit
|
|
{
|
|
int Id;
|
|
SCR_AIGroup Group;
|
|
SCR_AIGroupUtilityComponent Utility;
|
|
IEntity Radio;
|
|
float NextReport;
|
|
ref ERR_HQRoute Uplink;
|
|
ref ERR_HQReport PendingReport;
|
|
ref ERR_HQReportSelection ReportSelection = new ERR_HQReportSelection();
|
|
ref ERR_HQObservationHistory SentObservations = new ERR_HQObservationHistory();
|
|
ref ERR_HQRoute Downlink;
|
|
ref ERR_HQReport PendingOrder;
|
|
ref ERR_HQReport Assignment;
|
|
AIWaypoint Waypoint;
|
|
ref ERR_HQTask Task;
|
|
ref ERR_HQTask PendingTask;
|
|
ref ERR_HQSearchReport PendingSweep;
|
|
ref ERR_HQStatusReport PendingStatus;
|
|
ref ERR_HQStatusSampler StatusSampler = new ERR_HQStatusSampler();
|
|
ref ERR_HQAmmoReporting AmmoReporting = new ERR_HQAmmoReporting();
|
|
string ForceSourceId;
|
|
float NextStatus;
|
|
bool PendingCheckin;
|
|
bool HomeGuard;
|
|
string HomeId;
|
|
bool PlanEligible;
|
|
bool PlanFighting;
|
|
vector PlanPosition;
|
|
bool ReservedForSupport;
|
|
int LogisticsReservation;
|
|
ref ERR_MortarSupplyStatus PendingSupplyStatus;
|
|
ref ERR_ConvoyCombatOrder PendingConvoyOrder;
|
|
|
|
bool Eligible(ERR_GameMode mode)
|
|
{
|
|
if (ReservedForSupport || LogisticsReservation > 0 || !Group || !Utility || Group.GetPlayerCount(true) > 0 || Group.IsSlave() || Group.GetFaction() != mode.EnemyFaction()) return false;
|
|
array<AIAgent> agents = {};
|
|
Group.GetAgents(agents);
|
|
bool survivor;
|
|
foreach (AIAgent agent : agents)
|
|
{
|
|
if (!agent || !ERR_Actors.CanFight(agent.GetControlledEntity())) continue;
|
|
survivor = true;
|
|
if (CompartmentAccessComponent.GetVehicleIn(agent.GetControlledEntity())) return false;
|
|
}
|
|
return survivor;
|
|
}
|
|
|
|
void CancelPending()
|
|
{
|
|
PendingOrder = null;
|
|
PendingConvoyOrder = null;
|
|
PendingCheckin = false;
|
|
PendingTask = null;
|
|
Downlink = null;
|
|
}
|
|
ERR_HQTask PlannedTask()
|
|
{
|
|
if (PendingTask) return PendingTask;
|
|
return Task;
|
|
}
|
|
void ReleaseAssignment()
|
|
{
|
|
ERR_GameMode mode = ERR_GameMode.Get();
|
|
ERR_ForceRecord record;
|
|
if (mode && Group) record = mode.Forces().FindGroup(Group);
|
|
if (record && !record.Eliminated)
|
|
{
|
|
record.Duty = record.HomeDuty;
|
|
record.DutyTarget = record.HomePosition;
|
|
}
|
|
if (Waypoint)
|
|
{
|
|
if (Group) Group.RemoveWaypoint(Waypoint);
|
|
SCR_EntityHelper.DeleteEntityAndChildren(Waypoint);
|
|
}
|
|
Waypoint = null;
|
|
Assignment = null;
|
|
Task = null;
|
|
}
|
|
void Release() { ReleaseAssignment(); CancelPending(); }
|
|
|
|
}
|
|
|
|
class ERR_HQ : ERR_CommandService
|
|
{
|
|
protected ERR_GameMode m_Mode;
|
|
protected ref ERR_MortarSystem m_Mortars;
|
|
protected ref ERR_EnemyEquipment m_Equipment;
|
|
protected ref ERR_ConvoyPool m_ConvoyPool;
|
|
protected ref ERR_ConvoyService m_Convoys;
|
|
protected ref ERR_ConvoyTask m_ConvoyTask;
|
|
protected ref array<vector> m_ConvoyPositions = {};
|
|
protected ref array<vector> m_ConvoyAngles = {};
|
|
protected ref ERR_ForceRoute m_ConvoyRoute;
|
|
protected string m_ConvoyFailure;
|
|
protected ref ERR_HQBodyObserver m_Bodies = new ERR_HQBodyObserver();
|
|
protected ref ERR_HQWatch m_Watch = new ERR_HQWatch();
|
|
protected ref ERR_MortarLogistics m_Logistics;
|
|
protected ref ERR_InfantryResupply m_Resupply;
|
|
protected ref ERR_ConvoyStartup m_ConvoyStartup;
|
|
protected ref array<ref ERR_HQUnit> m_Units = {};
|
|
protected ref array<ref ERR_HQReport> m_Contacts = {};
|
|
protected ref ERR_HQMemory m_Memory = new ERR_HQMemory();
|
|
protected ref ERR_HQCoverage m_Coverage = new ERR_HQCoverage();
|
|
protected ref array<ref ERR_HQHuntWindow> m_Hunts = {};
|
|
protected ref array<ref ERR_HQBelief> m_PlanBeliefs = {};
|
|
protected ref map<string, int> m_HomeAvailable = new map<string, int>();
|
|
protected ref ERR_HQNetwork m_Network = new ERR_HQNetwork();
|
|
protected ref ERR_HQJournal m_Journal = new ERR_HQJournal();
|
|
protected int m_NextId;
|
|
protected float m_NextNetwork;
|
|
protected float m_NextAssignment;
|
|
|
|
void ERR_HQ(ERR_GameMode mode) { m_Mode = mode; m_Equipment = new ERR_EnemyEquipment(mode); m_ConvoyPool = new ERR_ConvoyPool(mode, 1); m_Convoys = new ERR_ConvoyService(mode, m_ConvoyPool); m_Mortars = new ERR_MortarSystem(this); m_Logistics = new ERR_MortarLogistics(this, mode); m_Resupply = new ERR_InfantryResupply(this, mode); m_ConvoyStartup = new ERR_ConvoyStartup(mode.Settings().Get("automaticConvoyEnabled") == 1); }
|
|
static ERR_HQ Get()
|
|
{
|
|
ERR_GameMode mode = ERR_GameMode.Get();
|
|
if (!mode) return null;
|
|
return ERR_HQ.Cast(mode.Command());
|
|
}
|
|
static bool MissionActive()
|
|
{
|
|
ERR_GameMode mode = ERR_GameMode.Get();
|
|
return mode && mode.Active();
|
|
}
|
|
static void Event(string kind, string message, int messageId = 0)
|
|
{
|
|
ERR_HQ hq = Get();
|
|
if (hq) hq.Journal().Write(kind, message, messageId);
|
|
}
|
|
ERR_ConvoyStartup ConvoyStartup() { return m_ConvoyStartup; }
|
|
ERR_ConvoyPool ConvoyPool() { return m_ConvoyPool; }
|
|
ERR_ConvoyService Convoys() { return m_Convoys; }
|
|
ERR_ConvoyTask ConvoyTask() { return m_ConvoyTask; }
|
|
bool PrepareConvoy(vector seed)
|
|
{
|
|
if (!Replication.IsServer() || !MissionActive() || m_ConvoyTask) return false;
|
|
m_ConvoyPositions.Clear(); m_ConvoyAngles.Clear(); m_ConvoyRoute = null;
|
|
if (!ERR_ConvoyRoadPlan.Build(seed, m_ConvoyPositions, m_ConvoyAngles, m_ConvoyRoute))
|
|
{
|
|
m_ConvoyPositions.Clear(); m_ConvoyAngles.Clear(); m_ConvoyRoute = null;
|
|
m_ConvoyFailure = "No sufficiently long, wide and clear road near the deployment site.";
|
|
return false;
|
|
}
|
|
m_ConvoyFailure = "";
|
|
return true;
|
|
}
|
|
bool StartConvoy()
|
|
{
|
|
if (!Replication.IsServer() || !MissionActive() || m_ConvoyTask || !m_ConvoyRoute) return false;
|
|
// Every existing formation must be admitted before the additional 19 bodies
|
|
// are budgeted. In particular, asynchronous mortar startup cannot be skipped.
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (unit.Group && !m_Mode.Forces().FindGroup(unit.Group))
|
|
{
|
|
m_ConvoyFailure = "Existing force admission is still pending; convoy deployment withheld.";
|
|
return false;
|
|
}
|
|
}
|
|
ERR_ConvoyReceipt receipt = m_ConvoyPool.Reserve("everon-supply-convoy-1");
|
|
if (!receipt || receipt.Consumed)
|
|
{
|
|
m_ConvoyFailure = "The finite convoy allowance or physical force budget is unavailable.";
|
|
return false;
|
|
}
|
|
m_ConvoyTask = m_Convoys.Dispatch(receipt, m_ConvoyPositions, m_ConvoyAngles, m_ConvoyRoute, GetGame().GetWorld().GetWorldTime());
|
|
if (!m_ConvoyTask)
|
|
{
|
|
m_ConvoyFailure = "Deployment preflight failed; no convoy created.";
|
|
return false;
|
|
}
|
|
m_ConvoyFailure = "";
|
|
return !m_ConvoyTask.Stopped;
|
|
}
|
|
protected bool ConvoyAdmissionReady()
|
|
{
|
|
if (m_Units.IsEmpty() || !m_Mode.Forces()) return false;
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
if (unit.Group && !m_Mode.Forces().FindGroup(unit.Group)) return false;
|
|
array<ref ERR_MortarBattery> batteries = {}; m_Mortars.Batteries(batteries);
|
|
foreach (ERR_MortarBattery battery : batteries)
|
|
if (battery && !battery.Stopped() && !battery.StartupActivated) return false;
|
|
return true;
|
|
}
|
|
protected void AutomaticConvoy(float now)
|
|
{
|
|
if (!Replication.IsServer() || !m_Mode || m_Mode != ERR_GameMode.Get() || !m_Mode.Active()) return;
|
|
if (!m_ConvoyStartup || m_ConvoyStartup.Finished()) return;
|
|
string previous = m_ConvoyStartup.Status();
|
|
if (m_ConvoyStartup.Decide(now, m_ConvoyTask != null, ConvoyAdmissionReady()))
|
|
m_ConvoyStartup.Complete(StartScenarioConvoy());
|
|
if (previous != m_ConvoyStartup.Status())
|
|
m_Journal.Write("CONVOY STARTUP", m_ConvoyStartup.Status() + "; " + m_ConvoyFailure);
|
|
}
|
|
bool StartScenarioConvoy()
|
|
{
|
|
if (!m_Mode || !m_Mode.Sites()) return false;
|
|
ERR_SiteRuntime site = m_Mode.Sites().Find("everon-supply-1");
|
|
if (!site || !site.Definition) return false;
|
|
return PrepareConvoy(site.Definition.Position) && StartConvoy();
|
|
}
|
|
string ConvoyStatus()
|
|
{
|
|
string detail = m_Convoys.Status();
|
|
if (m_ConvoyStartup) detail += "; automatic startup: " + m_ConvoyStartup.Status();
|
|
if (!m_ConvoyFailure.IsEmpty()) detail += "; " + m_ConvoyFailure;
|
|
return detail;
|
|
}
|
|
ERR_MortarSystem Mortars() { return m_Mortars; }
|
|
bool PrepareSupport() { return m_Mortars.Prepare() && m_Logistics.Prepare(); }
|
|
ERR_MortarLogistics Logistics() { return m_Logistics; }
|
|
void ReserveGroup(SCR_AIGroup group)
|
|
{
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (unit.Group != group) continue;
|
|
ReleaseUnit(unit, GetGame().GetWorld().GetWorldTime());
|
|
unit.ReservedForSupport = true;
|
|
}
|
|
}
|
|
// Temporary reservations never alter the permanent support reservation.
|
|
int LogisticsToken(SCR_AIGroup group)
|
|
{
|
|
foreach (ERR_HQUnit unit : m_Units) if (unit.Group == group) return unit.LogisticsReservation;
|
|
return 0;
|
|
}
|
|
bool ReserveLogistics(SCR_AIGroup group, int token)
|
|
{
|
|
if (!Replication.IsServer() || token <= 0 || !MissionActive()) return false;
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (unit.Group != group || !unit.Eligible(m_Mode) || !unit.Radio || unit.Assignment || unit.PendingOrder || unit.Downlink || unit.Waypoint) continue;
|
|
if (unit.Utility.m_Perception && !unit.Utility.m_Perception.m_aTargets.IsEmpty()) continue;
|
|
unit.LogisticsReservation = token;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
void ReleaseLogistics(SCR_AIGroup group, int token)
|
|
{
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
if (unit.Group == group && unit.LogisticsReservation == token) unit.LogisticsReservation = 0;
|
|
}
|
|
bool QueueSupplyStatus(ERR_MortarBattery battery, float now)
|
|
{
|
|
if (!Replication.IsServer() || !MissionActive() || !battery || !battery.StartupActivated || !battery.Operational() || !m_Logistics.CanSample(battery) || !ERR_MortarLogisticsRules.Need(battery.CountShells())) return false;
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (unit.Group != battery.Group || unit.Uplink || !unit.Radio || unit.Radio != battery.RadioOperator || OriginOccupied(unit.Radio, unit)) continue;
|
|
ERR_HQRoute route = m_Network.Route(unit.Radio);
|
|
if (!route) return false;
|
|
ERR_MortarSupplyStatus report = new ERR_MortarSupplyStatus();
|
|
report.Group = battery.Group; report.Gun = battery.Gun; report.Position = battery.Gun.GetOrigin();
|
|
report.Shells = battery.CountShells(); report.ObservedAt = now; report.MessageId = m_Journal.Message();
|
|
route.MessageId = report.MessageId;
|
|
route.Payload = string.Format("mortar supply status; usable HE=%1; position=%2; sampled=%3", report.Shells, report.Position, report.ObservedAt);
|
|
unit.PendingSupplyStatus = report; unit.Uplink = route;
|
|
m_Journal.Write("SUPPLY REPORT", route.Payload, route.MessageId);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
void PhysicalForces(out array<IEntity> entities)
|
|
{
|
|
entities.Clear();
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (!unit.Group) continue;
|
|
array<AIAgent> agents = {};
|
|
unit.Group.GetAgents(agents);
|
|
foreach (AIAgent agent : agents)
|
|
{
|
|
if (!agent || !agent.GetControlledEntity()) continue;
|
|
IEntity actor = agent.GetControlledEntity();
|
|
if (!entities.Contains(actor)) entities.Insert(actor);
|
|
IEntity vehicle = CompartmentAccessComponent.GetVehicleIn(actor);
|
|
if (vehicle && !entities.Contains(vehicle)) entities.Insert(vehicle);
|
|
}
|
|
}
|
|
m_Mortars.AppendGuns(entities);
|
|
}
|
|
bool MortarConnected(SCR_AIGroup group)
|
|
{
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
if (unit.Group == group && unit.Radio) return m_Network.Route(unit.Radio) != null;
|
|
return false;
|
|
}
|
|
ERR_HQRoute Downlink(SCR_AIGroup group, string kind, string detail, int sourceId)
|
|
{
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (unit.Group != group || !unit.Radio) continue;
|
|
ERR_HQRoute route = m_Network.Route(unit.Radio, true);
|
|
if (!route) return null;
|
|
route.MessageId = m_Journal.Message();
|
|
route.Payload = string.Format("%1 from report M%2; %3", kind, sourceId, detail);
|
|
m_Journal.Write("ORDER QUEUED", route.Payload, route.MessageId);
|
|
return route;
|
|
}
|
|
return null;
|
|
}
|
|
void SupportContacts(out array<ref ERR_HQReport> contacts, float now)
|
|
{
|
|
contacts.Clear();
|
|
foreach (ERR_HQReport contact : m_Contacts)
|
|
if (ERR_MortarPrediction.Fresh(contact, now)) contacts.Insert(contact.Snapshot());
|
|
}
|
|
|
|
ERR_HQWatch Watch() { return m_Watch; }
|
|
ERR_InfantryResupply Resupply() { return m_Resupply; }
|
|
ERR_HQMemory Memory() { return m_Memory; }
|
|
ERR_HQCoverage Coverage() { return m_Coverage; }
|
|
ERR_HQJournal Journal() { return m_Journal; }
|
|
string Status()
|
|
{
|
|
return string.Format("HQ: %1 groups, %2 delivered contacts, %3 assignments", m_Units.Count(), m_Contacts.Count(), Assigned()) + string.Format("; %1 remembered tracks, %2 swept cells", m_Memory.Count(), m_Coverage.Count()) + "; " + m_Mode.Forces().Status() + "; " + m_Mortars.Status() + "; " + m_Logistics.Status() + "; " + m_Resupply.Status();
|
|
}
|
|
|
|
protected void BindPhysical(ERR_HQUnit unit)
|
|
{
|
|
if (!unit || !unit.Group) return;
|
|
ERR_ForceRecord record = m_Mode.Forces().FindGroup(unit.Group);
|
|
if (!record || !record.Physical || record.Eliminated) return;
|
|
unit.ForceSourceId = record.SourceId;
|
|
if (!unit.StatusSampler.Bound()) unit.StatusSampler.Bind(unit.Group, record.SourceId, record.InitialStrength, m_Mode.EnemyFaction());
|
|
if (unit.StatusSampler.Bound()) m_Bodies.RegisterGroup(unit.Group, unit.StatusSampler);
|
|
}
|
|
override void RegisterGroup(SCR_AIGroup group)
|
|
{
|
|
if (!Replication.IsServer() || !group) return;
|
|
foreach (ERR_HQUnit known : m_Units) if (known.Group == group) { BindPhysical(known); return; }
|
|
if (m_Units.Count() >= 128) return;
|
|
SCR_AIGroupUtilityComponent utility = SCR_AIGroupUtilityComponent.Cast(group.FindComponent(SCR_AIGroupUtilityComponent));
|
|
if (!utility || group.GetFaction() != m_Mode.EnemyFaction()) return;
|
|
ERR_HQUnit unit = new ERR_HQUnit();
|
|
unit.Id = ++m_NextId;
|
|
unit.Group = group;
|
|
unit.Utility = utility;
|
|
ERR_SiteService sites = m_Mode.Sites();
|
|
ERR_SiteRuntime home;
|
|
if (sites) home = sites.FindGroup(group);
|
|
if (home)
|
|
{
|
|
unit.HomeId = home.Definition.Id;
|
|
unit.HomeGuard = !home.Definition.Patrol || home.Definition.Patrol.IsEmpty();
|
|
}
|
|
int phase = unit.Id % 5;
|
|
unit.NextReport = GetGame().GetWorld().GetWorldTime() + phase * 1000;
|
|
m_Units.Insert(unit);
|
|
m_Equipment.RegisterGroup(group, unit.Id, !m_Mortars || !m_Mortars.FindGroup(group));
|
|
BindPhysical(unit);
|
|
unit.NextStatus = GetGame().GetWorld().GetWorldTime() + 10000 + phase * 1000;
|
|
unit.AmmoReporting.Initialize(unit.Id, GetGame().GetWorld().GetWorldTime());
|
|
m_Journal.Write("REGISTER", string.Format("group %1", unit.Id));
|
|
}
|
|
|
|
override void UnregisterGroup(SCR_AIGroup group)
|
|
{
|
|
m_Equipment.UnregisterGroup(group);
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (unit.Group != group) continue;
|
|
ReleaseUnit(unit, GetGame().GetWorld().GetWorldTime());
|
|
unit.Group = null;
|
|
unit.Utility = null;
|
|
}
|
|
}
|
|
|
|
protected int HuntingAssigned()
|
|
{
|
|
int count;
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (!unit.Assignment && !unit.PendingOrder) continue;
|
|
ERR_HQTask planned = unit.PlannedTask();
|
|
if (planned && planned.ReleaseOnly) planned = planned.ReplacesTask;
|
|
if (planned && !planned.Investigation()) count++;
|
|
}
|
|
return count;
|
|
}
|
|
protected int Assigned()
|
|
{
|
|
int total;
|
|
foreach (ERR_HQUnit unit : m_Units) if (unit.Assignment || unit.PendingOrder) total++;
|
|
return total;
|
|
}
|
|
|
|
protected void IndexRadios()
|
|
{
|
|
m_Network.Clear();
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
unit.Radio = null;
|
|
if (!unit.Group || unit.Group.GetPlayerCount(true) > 0 || unit.Group.GetFaction() != m_Mode.EnemyFaction()) continue;
|
|
array<AIAgent> agents = {};
|
|
unit.Group.GetAgents(agents);
|
|
int best;
|
|
foreach (AIAgent agent : agents)
|
|
{
|
|
if (!agent) continue;
|
|
IEntity actor = agent.GetControlledEntity();
|
|
int capability = ERR_HQRadio.Capability(actor);
|
|
if (capability <= 0) continue;
|
|
m_Network.Add(actor, unit.Group, unit.Id, capability);
|
|
if (capability > best) { unit.Radio = actor; best = capability; }
|
|
}
|
|
}
|
|
m_Network.Build();
|
|
}
|
|
|
|
protected bool OriginOccupied(IEntity caller, ERR_HQUnit owner)
|
|
{
|
|
if (!caller) return false;
|
|
foreach (ERR_HQUnit other : m_Units)
|
|
{
|
|
if (other == owner || !other.Uplink || other.Uplink.Failed || other.Uplink.Originated || other.Uplink.Nodes.IsEmpty()) continue;
|
|
if (other.Uplink.Nodes[0].Carrier == caller) return true;
|
|
}
|
|
return false;
|
|
}
|
|
protected ERR_HQRoute ObservationRoute(ERR_HQUnit unit)
|
|
{
|
|
ERR_HQRoute own;
|
|
if (unit.Radio && !OriginOccupied(unit.Radio, unit)) own = m_Network.Route(unit.Radio);
|
|
if (own && !own.Nodes.IsEmpty() && own.Nodes[0].Valid(own.Nodes.Count() == 1)) return own;
|
|
array<IEntity> busy = {};
|
|
foreach (ERR_HQUnit other : m_Units)
|
|
{
|
|
if (!other.Uplink || other.Uplink.Failed) continue;
|
|
if (other.Radio && !busy.Contains(other.Radio)) busy.Insert(other.Radio);
|
|
if (!other.Uplink.Originated && !other.Uplink.Nodes.IsEmpty())
|
|
{
|
|
IEntity caller = other.Uplink.Nodes[0].Carrier;
|
|
if (caller && !busy.Contains(caller)) busy.Insert(caller);
|
|
}
|
|
}
|
|
return m_Network.LocalRoute(unit.Group, unit.StatusSampler, busy);
|
|
}
|
|
|
|
protected void Observe(ERR_HQUnit unit, float now)
|
|
{
|
|
if (!unit.Utility || unit.Uplink || now < unit.NextReport) return;
|
|
unit.NextReport = now + m_Mode.Settings().Get("reportIntervalSeconds") * 1000;
|
|
array<ref ERR_HQVisualContact> samples = {};
|
|
ERR_HQObservation.Gather(unit.Utility, now, samples);
|
|
if (samples.IsEmpty()) return;
|
|
ERR_HQVisualContact seen = unit.ReportSelection.Select(samples);
|
|
if (!seen || !unit.SentObservations.CanQueue(seen.Entity, seen.ObservedAt, now)) return;
|
|
ERR_HQRoute route = ObservationRoute(unit);
|
|
if (!route) return;
|
|
ERR_HQReport report = new ERR_HQReport();
|
|
report.MessageId = m_Journal.Message();
|
|
report.Target = seen.Entity;
|
|
report.Source = unit.Group;
|
|
report.Position = seen.Position;
|
|
report.ObservedAt = seen.ObservedAt;
|
|
ERR_HQObservation.Describe(report, samples, now);
|
|
route.MessageId = report.MessageId;
|
|
route.Payload = report.Description(now);
|
|
unit.PendingReport = report;
|
|
unit.Uplink = route;
|
|
unit.ReportSelection.Queued(seen.Entity);
|
|
unit.SentObservations.Queued(seen.Entity, seen.ObservedAt, now);
|
|
if (route.LocalSource) m_Journal.Write("LOCAL HANDOFF", "original squad sighting queued for nearby physical radio caller; three-second origin hold required", report.MessageId);
|
|
m_Journal.Write("REPORT", route.Payload, report.MessageId);
|
|
}
|
|
|
|
protected void ObserveBody(ERR_HQUnit unit, float now)
|
|
{
|
|
if (unit.Uplink || !unit.Radio || !unit.Group) return;
|
|
ERR_HQReport report;
|
|
if (!m_Bodies.Observe(unit.Group, now, report)) return;
|
|
ERR_HQRoute route = m_Network.Route(unit.Radio);
|
|
if (!route) return;
|
|
report.MessageId = m_Journal.Message(); report.Source = unit.Group;
|
|
route.MessageId = report.MessageId;
|
|
route.Payload = "visible casualty evidence; cause unknown; " + report.Description(now);
|
|
unit.PendingReport = report.Snapshot(); unit.Uplink = route;
|
|
m_Journal.Write("BODY REPORT", route.Payload, route.MessageId);
|
|
}
|
|
protected void StatusReport(ERR_HQUnit unit, float now)
|
|
{
|
|
unit.StatusSampler.ObserveDeaths();
|
|
if (unit.Uplink || !unit.Radio) return;
|
|
bool routine = now >= unit.NextStatus;
|
|
if (!routine && !unit.AmmoReporting.ScanDue(now)) return;
|
|
unit.AmmoReporting.Scanned(now);
|
|
ERR_HQRoute route = m_Network.Route(unit.Radio);
|
|
if (!route) return;
|
|
// A local sample reserves an identifier; a healthy early sample creates no frame.
|
|
ERR_HQStatusReport report = unit.StatusSampler.Sample(now, m_Journal.Message(), unit.Radio);
|
|
if (!report || (!routine && !unit.AmmoReporting.Urgent(report, now))) return;
|
|
route.MessageId = report.MessageId;
|
|
route.Payload = string.Format("status %1: %2 living, %3 fit, %4 confirmed losses; sampled=%5", report.SourceId, report.Count, report.Fit, report.ConfirmedLosses, report.ObservedAt);
|
|
string ammunition = "unknown";
|
|
if (report.AmmoState && report.AmmoState.Complete) ammunition = string.Format("%1 magazine rounds, %2 chambered", report.AmmoState.SmallArmsRounds, report.AmmoState.SmallArmsChambers);
|
|
route.Payload += "; small-arms ammunition=" + ammunition;
|
|
unit.PendingStatus = report; unit.Uplink = route; unit.NextStatus = now + 180000;
|
|
unit.AmmoReporting.Queued(now);
|
|
m_Journal.Write("STATUS REPORT", route.Payload, route.MessageId);
|
|
}
|
|
// Due routine status and requested check-ins get the next free uplink.
|
|
// Positive observations precede a negative search report.
|
|
protected void QueueReports(ERR_HQUnit unit, float now)
|
|
{
|
|
if (OriginOccupied(unit.Radio, unit)) { if (unit.Task) unit.Task.ArrivedAt = -1; return; }
|
|
StatusReport(unit, now);
|
|
Observe(unit, now);
|
|
ObserveBody(unit, now);
|
|
Sweep(unit, now);
|
|
}
|
|
protected bool WatchTaskValid(ERR_HQTask task)
|
|
{
|
|
if (!task || !task.Investigation()) return false;
|
|
ERR_HQWatchEntry entry = m_Watch.Find(task.WatchSourceId);
|
|
return entry && !entry.Closed && entry.Investigating && entry.MessageId == task.WatchMessageId && entry.RequestId == task.WatchRequestId;
|
|
}
|
|
protected void FinishWatch(ERR_HQTask task, float now)
|
|
{
|
|
if (task && task.Investigation()) m_Watch.FinishInvestigation(task.WatchSourceId, task.WatchMessageId, task.WatchRequestId, now);
|
|
}
|
|
protected void ReleaseUnit(ERR_HQUnit unit, float now)
|
|
{
|
|
FinishWatch(unit.Task, now); FinishWatch(unit.PendingTask, now);
|
|
unit.Release();
|
|
}
|
|
protected void CancelResolvedInvestigation(ERR_HQUnit unit, float now)
|
|
{
|
|
if (unit.PendingTask && unit.PendingTask.Investigation() && !WatchTaskValid(unit.PendingTask)) LostOrder(unit, now);
|
|
if (!unit.Task || !unit.Task.Investigation() || WatchTaskValid(unit.Task) || unit.Downlink || !unit.Radio) return;
|
|
ERR_HQRoute route = m_Network.Route(unit.Radio, true);
|
|
if (!route) return;
|
|
ERR_HQTask cancel = new ERR_HQTask();
|
|
cancel.ReleaseOnly = true; cancel.ReplacesTask = unit.Task; cancel.QueuedAt = now; cancel.ExpiresAt = now + 30000;
|
|
cancel.ApproachBearing = unit.Task.ApproachBearing; cancel.Destination = unit.Task.Destination;
|
|
unit.PendingTask = cancel; unit.PendingOrder = unit.Assignment.Snapshot(); unit.Downlink = route;
|
|
route.MessageId = m_Journal.Message(); route.Payload = "cancel resolved missing-patrol investigation; group " + unit.Id.ToString();
|
|
m_Journal.Write("ORDER QUEUED", route.Payload, route.MessageId);
|
|
}
|
|
protected void RequestCheckins(float now)
|
|
{
|
|
for (int i = 0; i < m_Watch.Count(); i++)
|
|
{
|
|
ERR_HQWatchEntry entry = m_Watch.At(i);
|
|
if (!m_Watch.MarkRequested(entry.SourceId, entry.MessageId, now)) continue;
|
|
m_Journal.Write("CHECK-IN OVERDUE", string.Format("%1 missed two check-ins; last reported position=%2, status M%3; cause unknown", entry.SourceId, entry.Position, entry.MessageId));
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (unit.ForceSourceId != entry.SourceId || unit.Downlink || !unit.Radio) continue;
|
|
ERR_HQRoute route = m_Network.Route(unit.Radio, true);
|
|
if (!route) break;
|
|
route.MessageId = m_Journal.Message();
|
|
route.Payload = "HQ requests current status from " + entry.SourceId;
|
|
unit.PendingCheckin = true; unit.Downlink = route;
|
|
m_Journal.Write("STATUS REQUEST", route.Payload, route.MessageId);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
protected void Investigate(float now, int limit)
|
|
{
|
|
if (Assigned() >= limit) return;
|
|
// One missing-patrol investigation at a time shares the same finite units.
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
if (unit.PlannedTask() && unit.PlannedTask().Investigation()) return;
|
|
for (int i = 0; i < m_Watch.Count(); i++)
|
|
{
|
|
ERR_HQWatchEntry entry = m_Watch.At(i);
|
|
if (!m_Watch.InvestigationDue(entry.SourceId, now)) continue;
|
|
ERR_HQUnit best;
|
|
ERR_HQRoute bestRoute;
|
|
float distance = m_Mode.Settings().Get("responseRadiusMetres") + 1;
|
|
int first = -1;
|
|
int second = -1;
|
|
foreach (ERR_HQUnit existing : m_Units)
|
|
{
|
|
ERR_HQTask planned = existing.PlannedTask();
|
|
if (!planned) continue;
|
|
if (first < 0) first = planned.ApproachBearing;
|
|
else if (planned.ApproachBearing != first) second = planned.ApproachBearing;
|
|
}
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (unit.ForceSourceId == entry.SourceId || !unit.Radio || !unit.PlanEligible || unit.PlanFighting || unit.Assignment || unit.PendingOrder || unit.Downlink) continue;
|
|
if (m_Watch.ArmedSearchBlocked(unit.ForceSourceId, now)) continue;
|
|
if (unit.HomeGuard && HomeAvailable(unit) <= 1) continue;
|
|
if (!ERR_HQPursuitRules.BearingAllowed(ERR_HQPursuitRules.Bearing(unit.PlanPosition, entry.Position), first, second)) continue;
|
|
float candidate = vector.DistanceXZ(unit.PlanPosition, entry.Position);
|
|
if (candidate >= distance) continue;
|
|
ERR_HQRoute route = m_Network.Route(unit.Radio, true);
|
|
if (!route) continue;
|
|
best = unit; bestRoute = route; distance = candidate;
|
|
}
|
|
if (!best || !m_Watch.MarkInvestigating(entry.SourceId, entry.MessageId, entry.RequestId, now)) continue;
|
|
ERR_HQTask task = new ERR_HQTask();
|
|
task.WatchSourceId = entry.SourceId; task.WatchMessageId = entry.MessageId; task.WatchRequestId = entry.RequestId;
|
|
task.Role = ERR_HQPursuitRole.SEARCH; task.Destination = entry.Position; task.QueuedAt = now;
|
|
task.ExpiresAt = now + ERR_HQPursuitRules.TaskLifetimeSeconds(task.Role, distance) * 1000;
|
|
task.ApproachBearing = ERR_HQPursuitRules.Bearing(best.PlanPosition, entry.Position);
|
|
ERR_HQReport lineage = new ERR_HQReport();
|
|
lineage.MessageId = entry.MessageId; lineage.ObservedAt = entry.ObservedAt; lineage.Position = entry.Position; lineage.Distress = true;
|
|
best.PendingTask = task; best.PendingOrder = lineage; best.Downlink = bestRoute;
|
|
bestRoute.MessageId = m_Journal.Message();
|
|
bestRoute.Payload = string.Format("group %1 investigate %2 at last delivered status position %3; source M%4", best.Id, entry.SourceId, entry.Position, entry.MessageId);
|
|
m_Journal.Write("ORDER QUEUED", bestRoute.Payload, bestRoute.MessageId);
|
|
if (best.HomeGuard) m_HomeAvailable.Set(best.HomeId, HomeAvailable(best) - 1);
|
|
return;
|
|
}
|
|
}
|
|
protected void Accept(ERR_HQReport report, float now)
|
|
{
|
|
if (!report || !ERR_MissionRules.ContactFresh(report.ObservedAt, now)) return;
|
|
// Delivered scalar body evidence survives native corpse cleanup during radio transit.
|
|
// Memory still applies its own entity-identity rules; casualty accounting needs no live target.
|
|
if (ERR_HQMemoryRules.Kind(report) == ERR_HQMemoryKind.BODY && m_Watch.IngestBody(report, now))
|
|
m_Bodies.ConfirmDelivered(report.Target);
|
|
if (!m_Memory.Ingest(report, now)) return;
|
|
if (ERR_HQMemoryRules.Kind(report) == ERR_HQMemoryKind.SIGHTING) m_Coverage.Forget(report.Position);
|
|
m_Journal.Write("BELIEF", string.Format("delivered report M%1 retained; tracks=%2", report.MessageId, m_Memory.Count()), report.MessageId);
|
|
// A reported corpse or distress call can justify investigation, never fire.
|
|
if (ERR_HQMemoryRules.Kind(report) != ERR_HQMemoryKind.SIGHTING) return;
|
|
for (int i = 0; i < m_Contacts.Count(); i++)
|
|
{
|
|
ERR_HQReport previous = m_Contacts[i];
|
|
if (previous.Target != report.Target) continue;
|
|
if (previous.ObservedAt >= report.ObservedAt) return;
|
|
float seconds = (report.ObservedAt - previous.ObservedAt) / 1000;
|
|
if (seconds > 0 && seconds < 30 && vector.DistanceXZ(previous.Position, report.Position) < 500)
|
|
{
|
|
report.Velocity = (report.Position - previous.Position) / seconds;
|
|
report.HasVelocity = report.Velocity.Length() <= 100;
|
|
}
|
|
m_Contacts[i] = report.Snapshot();
|
|
return;
|
|
}
|
|
if (m_Contacts.Count() >= 64) m_Contacts.Remove(0);
|
|
m_Contacts.Insert(report.Snapshot());
|
|
}
|
|
|
|
// Current combat suspends a sweep without deleting its native queued orders.
|
|
protected bool Fighting(ERR_HQUnit unit)
|
|
{
|
|
return unit.Utility && unit.Utility.m_Perception && !unit.Utility.m_Perception.m_aTargets.IsEmpty();
|
|
}
|
|
protected int HomeAvailable(ERR_HQUnit candidate) { return m_HomeAvailable.Get(candidate.HomeId); }
|
|
protected ERR_HQHuntWindow Hunt(int beliefId)
|
|
{
|
|
foreach (ERR_HQHuntWindow known : m_Hunts) if (known.BeliefId == beliefId) return known;
|
|
if (m_Hunts.Count() >= 64) return null;
|
|
ERR_HQHuntWindow created = new ERR_HQHuntWindow();
|
|
created.BeliefId = beliefId;
|
|
m_Hunts.Insert(created);
|
|
return created;
|
|
}
|
|
protected void LostOrder(ERR_HQUnit unit, float now)
|
|
{
|
|
ERR_HQTask task = unit.PendingTask;
|
|
unit.CancelPending();
|
|
if (!task || task.ReleaseOnly) return;
|
|
if (task.Investigation()) { FinishWatch(task, now); return; }
|
|
foreach (ERR_HQUnit other : m_Units)
|
|
{
|
|
ERR_HQTask planned = other.PlannedTask();
|
|
if (planned && planned.BeliefId == task.BeliefId) return;
|
|
}
|
|
// A call that never arrived did not begin a hunt. Retry through the network
|
|
// after a short backoff, without bypassing another unit's active hunt window.
|
|
ERR_HQHuntWindow hunt = Hunt(task.BeliefId);
|
|
if (hunt) hunt.NextHunt = Math.Min(hunt.NextHunt, now + 15000);
|
|
}
|
|
protected void DeliverOrder(ERR_HQUnit unit, float now)
|
|
{
|
|
ERR_HQReport order = unit.PendingOrder;
|
|
ERR_HQTask task = unit.PendingTask;
|
|
if (!order || !task || now >= task.ExpiresAt || !unit.Eligible(m_Mode)) { LostOrder(unit, now); return; }
|
|
if (task.ReleaseOnly)
|
|
{
|
|
if (unit.Task == task.ReplacesTask) { ReleaseUnit(unit, now); m_Journal.Write("ORDER DELIVERED", "resolved investigation released through radio"); }
|
|
else unit.CancelPending();
|
|
return;
|
|
}
|
|
if (m_Watch.ArmedSearchBlocked(unit.ForceSourceId, now)) { LostOrder(unit, now); return; }
|
|
if (task.Investigation())
|
|
{
|
|
if (!WatchTaskValid(task)) { LostOrder(unit, now); return; }
|
|
}
|
|
else
|
|
{
|
|
ERR_HQBelief belief = m_Memory.GetById(task.BeliefId);
|
|
if (!belief || belief.BeliefRevision != task.BeliefRevision
|
|
|| !ERR_HQPursuitRules.Actionable(belief.Confidence, (now - belief.ObservedAt) / 1000, belief.Radius))
|
|
{ LostOrder(unit, now); return; }
|
|
if (task.RoadIntercept && !ERR_HQRoadIntercept.Eligible(belief, now)) { LostOrder(unit, now); return; }
|
|
}
|
|
if (Fighting(unit)) { LostOrder(unit, now); return; }
|
|
int deliveryId;
|
|
if (unit.Downlink) deliveryId = unit.Downlink.MessageId;
|
|
ResourceName waypointResource = ERR_Resources.SearchWaypoint();
|
|
if (task.RoadIntercept) waypointResource = ERR_Resources.DefendWaypoint();
|
|
AIWaypoint waypoint = AIWaypoint.Cast(ERR_Actors.Spawn(waypointResource, ERR_Actors.Ground(task.Destination)));
|
|
if (!waypoint) { LostOrder(unit, now); m_Journal.Write("ORDER FAILED", "waypoint spawn failed", order.MessageId); return; }
|
|
unit.Release();
|
|
unit.Task = task;
|
|
unit.Waypoint = waypoint;
|
|
unit.Assignment = order;
|
|
unit.Group.AddWaypointAt(waypoint, 0);
|
|
ERR_ForceRecord record = m_Mode.Forces().FindGroup(unit.Group);
|
|
if (record)
|
|
{
|
|
record.Duty = ERR_ForceDuty.SEARCH;
|
|
record.DutyTarget = task.Destination;
|
|
}
|
|
m_Journal.Write("ORDER DELIVERED", string.Format("group %1 %2 from report M%3; belief=%4 destination=%5", unit.Id, task.Name(), order.MessageId, task.BeliefId, task.Destination), deliveryId);
|
|
}
|
|
protected void Sweep(ERR_HQUnit unit, float now)
|
|
{
|
|
ERR_HQTask task = unit.Task;
|
|
if (!task || task.RoadIntercept || !unit.Assignment || task.SweepQueued || !unit.Waypoint || !unit.Eligible(m_Mode)) return;
|
|
if (Fighting(unit) || vector.DistanceXZ(unit.Group.GetOrigin(), task.Destination) > 40)
|
|
{ task.ArrivedAt = -1; return; }
|
|
// Quiet combat state alone does not establish a negative search. Use this
|
|
// physical group's native perception, also while its uplink is occupied.
|
|
array<ref ERR_HQVisualContact> samples = {};
|
|
ERR_HQObservation.Gather(unit.Utility, now, samples);
|
|
if (!samples.IsEmpty()) { task.ArrivedAt = -1; return; }
|
|
if (task.ArrivedAt < 0) task.ArrivedAt = now;
|
|
if (now - task.ArrivedAt < 30000 || unit.Uplink || !unit.Radio) return;
|
|
ERR_HQRoute route = m_Network.Route(unit.Radio);
|
|
if (!route) return;
|
|
ERR_HQSearchReport report = new ERR_HQSearchReport();
|
|
report.SourceId = unit.Id;
|
|
report.MessageId = m_Journal.Message();
|
|
report.WatchSourceId = task.WatchSourceId; report.WatchMessageId = task.WatchMessageId; report.WatchRequestId = task.WatchRequestId;
|
|
report.BeliefId = task.BeliefId;
|
|
report.BeliefRevision = task.BeliefRevision;
|
|
report.Position = task.Destination;
|
|
report.ObservedAt = now;
|
|
report.SweepCompleted = true;
|
|
report.ContactFound = false;
|
|
route.MessageId = report.MessageId;
|
|
route.Payload = string.Format("group %1 searched belief %2 at %3; no contact", unit.Id, task.BeliefId, task.Destination);
|
|
unit.PendingSweep = report;
|
|
unit.Uplink = route;
|
|
task.SweepQueued = true;
|
|
m_Journal.Write("SEARCH REPORT", route.Payload, report.MessageId);
|
|
}
|
|
protected void AcceptSweep(ERR_HQSearchReport report, float now)
|
|
{
|
|
if (!report) return;
|
|
if (!report.WatchSourceId.IsEmpty())
|
|
{
|
|
if (!ERR_HQMemoryRules.DeliveryFresh(report.ObservedAt, now) || !report.SweepCompleted || report.ContactFound) return;
|
|
if (m_Watch.FinishInvestigation(report.WatchSourceId, report.WatchMessageId, report.WatchRequestId, now))
|
|
m_Journal.Write("INVESTIGATION", "physical search reported no contact; missing patrol remains unconfirmed: " + report.WatchSourceId, report.MessageId);
|
|
return;
|
|
}
|
|
ERR_HQBelief belief = m_Memory.GetById(report.BeliefId);
|
|
if (!belief || belief.BeliefRevision != report.BeliefRevision) return;
|
|
if (!m_Coverage.Ingest(report, now)) return;
|
|
m_Memory.NegativeSearch(report.BeliefId, report.BeliefRevision, now);
|
|
m_Journal.Write("AREA SWEPT", string.Format("group %1 reported no contact at %2; belief=%3", report.SourceId, report.Position, report.BeliefId), report.MessageId);
|
|
}
|
|
protected vector Containment(ERR_HQBelief belief, vector fallback)
|
|
{
|
|
array<ERR_LocationComponent> locations = {};
|
|
m_Mode.Locations(locations);
|
|
float best = -1;
|
|
vector result = fallback;
|
|
foreach (ERR_LocationComponent location : locations)
|
|
{
|
|
if (!location || (location.Kind() != ERR_LocationKind.RADIO && location.Kind() != ERR_LocationKind.EXTRACTION)) continue;
|
|
vector objective = location.Position();
|
|
if (!ERR_HQDoctrine.Forward(objective, belief.PredictedPosition, belief.Velocity, belief.HasVelocity)) continue;
|
|
float threat = ERR_HQDoctrine.Threat(objective, belief.Position, belief.Velocity, belief.HasVelocity, belief.Confidence, belief.Radius);
|
|
if (threat <= best) continue;
|
|
best = threat;
|
|
result = ERR_HQDoctrine.Approach(objective, belief.PredictedPosition);
|
|
}
|
|
return result;
|
|
}
|
|
void MemoryStatus(array<string> replies)
|
|
{
|
|
replies.Insert(string.Format("HQ memory: %1 tracks; %2 searched cells. Predictions use delivered reports only.", m_Memory.Count(), m_Coverage.Count()));
|
|
for (int i = 0; i < m_Memory.Count() && i < 6; i++)
|
|
{
|
|
ERR_HQBelief belief = m_Memory.At(i);
|
|
replies.Insert(string.Format("Track %1: confidence %2%%, uncertainty %3m, age %4s, samples %5; %6", belief.BeliefId, Math.Round(belief.Confidence * 100), Math.Round(belief.Radius), Math.Round((belief.EvaluatedAt - belief.ObservedAt) / 1000), belief.SampleCount, belief.PredictionSource));
|
|
}
|
|
}
|
|
protected void Retask(float now)
|
|
{
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (!unit.Assignment || !unit.Task || unit.Task.Investigation() || unit.PendingOrder || unit.Downlink || !unit.Radio || unit.PlanFighting || !unit.PlanEligible) continue;
|
|
if (m_Watch.ArmedSearchBlocked(unit.ForceSourceId, now)) continue;
|
|
ERR_HQBelief belief = m_Memory.GetById(unit.Task.BeliefId);
|
|
if (!belief || belief.BeliefRevision == unit.Task.BeliefRevision || now - belief.ObservedAt > 45000) continue;
|
|
// Nearby updates refine memory without churning native movement orders.
|
|
if (vector.DistanceXZ(unit.Assignment.Position, belief.Position) < Math.Max(100, belief.Radius)) continue;
|
|
ERR_HQRoute route = m_Network.Route(unit.Radio, true);
|
|
if (!route) continue;
|
|
array<vector> reserved = {};
|
|
int first = -1;
|
|
int second = -1;
|
|
foreach (ERR_HQUnit other : m_Units)
|
|
{
|
|
ERR_HQTask planned = other.PlannedTask();
|
|
if (other == unit || !planned) continue;
|
|
reserved.Insert(planned.Destination);
|
|
if (first < 0) first = planned.ApproachBearing;
|
|
else if (planned.ApproachBearing != first) second = planned.ApproachBearing;
|
|
}
|
|
int bearing = ERR_HQPursuitRules.Bearing(unit.Group.GetOrigin(), belief.PredictedPosition);
|
|
if (!ERR_HQPursuitRules.BearingAllowed(bearing, first, second)) continue;
|
|
vector destination;
|
|
if (!m_Coverage.Select(belief.PredictedPosition, belief.Radius, belief.Position, now, destination, reserved)) continue;
|
|
ERR_HQTask task = new ERR_HQTask();
|
|
task.BeliefId = belief.BeliefId; task.BeliefRevision = belief.BeliefRevision; task.Role = ERR_HQPursuitRole.SEARCH;
|
|
task.Destination = destination; task.QueuedAt = now;
|
|
task.ExpiresAt = now + ERR_HQPursuitRules.TaskLifetimeSeconds(task.Role, vector.DistanceXZ(unit.PlanPosition, destination)) * 1000;
|
|
task.ApproachBearing = bearing;
|
|
unit.PendingTask = task; unit.PendingOrder = belief.Report.Snapshot(); unit.Downlink = route;
|
|
route.MessageId = m_Journal.Message();
|
|
route.Payload = string.Format("group %1 retask from report M%2; belief=%3 destination=%4", unit.Id, belief.MessageId, belief.BeliefId, destination);
|
|
m_Journal.Write("ORDER QUEUED", route.Payload, route.MessageId);
|
|
ERR_HQHuntWindow hunt = Hunt(belief.BeliefId);
|
|
if (hunt) hunt.NextHunt = Math.Max(hunt.NextHunt, task.ExpiresAt + 180000);
|
|
}
|
|
}
|
|
// Convoy planning reads delivered own-position status and delivered sightings.
|
|
// A silent convoy keeps its last order; no target or vehicle position is queried.
|
|
protected bool ConvoyPositionKnown(ERR_HQUnit unit, float now)
|
|
{
|
|
ERR_HQWatchEntry entry = m_Watch.Find(unit.ForceSourceId);
|
|
return entry && !entry.Closed && entry.Count > 0 && entry.ObservedAt >= 0
|
|
&& ERR_HQPursuitRules.Finite(now) && now >= entry.ObservedAt
|
|
&& now - entry.ObservedAt <= 180000;
|
|
}
|
|
protected ERR_HQReport ConvoyContact(ERR_HQUnit unit, float now)
|
|
{
|
|
if (!ConvoyPositionKnown(unit, now)) return null;
|
|
ERR_HQWatchEntry entry = m_Watch.Find(unit.ForceSourceId);
|
|
ERR_HQReport best;
|
|
foreach (ERR_HQReport report : m_Contacts)
|
|
{
|
|
if (report.ObservedAt < 0 || now < report.ObservedAt || now - report.ObservedAt >= 60000
|
|
|| vector.DistanceXZ(entry.Position, report.Position) > 400) continue;
|
|
if (!best || report.ObservedAt > best.ObservedAt
|
|
|| (report.ObservedAt == best.ObservedAt && report.MessageId > best.MessageId)) best = report;
|
|
}
|
|
return best;
|
|
}
|
|
protected void PlanResupply(float now)
|
|
{
|
|
if (!m_Resupply || m_Resupply.State() != 1 || !m_ConvoyTask || m_ConvoyTask.Stopped
|
|
|| !m_ConvoyTask.Ready || m_ConvoyTask.Vehicles.Count() != 6) return;
|
|
ERR_HQUnit donor;
|
|
foreach (ERR_HQUnit unit : m_Units) if (unit.Group == m_ConvoyTask.Vehicles[1].Group) donor = unit;
|
|
if (!donor || ConvoyContact(donor, now)) return;
|
|
ERR_HQWatchEntry donorStatus = m_Watch.Find(donor.ForceSourceId);
|
|
foreach (ERR_HQUnit recipient : m_Units)
|
|
if (m_Resupply.TryPlan(recipient, donor, m_Watch.Find(recipient.ForceSourceId), donorStatus, now)) return;
|
|
}
|
|
protected void PlanConvoy(float now)
|
|
{
|
|
if (!m_ConvoyTask || m_ConvoyTask.Stopped || !m_ConvoyTask.Ready) return;
|
|
foreach (ERR_ConvoyVehicle vehicle : m_ConvoyTask.Vehicles)
|
|
{
|
|
if (vehicle.Released || vehicle.Arrived || vehicle.SupplyToken > 0 || !vehicle.Registered || !vehicle.Group) continue;
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (unit.Group != vehicle.Group || !unit.ReservedForSupport || unit.Downlink || !unit.Radio) continue;
|
|
if (!ConvoyPositionKnown(unit, now)) break;
|
|
ERR_HQReport contact = ConvoyContact(unit, now);
|
|
if (contact)
|
|
{
|
|
if (vehicle.Combat.Held && contact.MessageId == vehicle.Combat.ReportId) break;
|
|
if (contact.ObservedAt < vehicle.Combat.ObservedAt) break;
|
|
}
|
|
else if (!vehicle.Combat.Held || now - vehicle.Combat.ObservedAt < 60000) break;
|
|
ERR_HQRoute route = m_Network.Route(unit.Radio, true);
|
|
if (!route) break;
|
|
ERR_ConvoyCombatOrder order = new ERR_ConvoyCombatOrder();
|
|
order.CommandId = m_Journal.Message(); order.SourceId = m_ConvoyTask.Receipt.SourceId;
|
|
order.VehicleIndex = vehicle.Index; order.Group = unit.Group;
|
|
order.Hold = contact != null; order.IssuedAt = now; order.ExpiresAt = now + 30000;
|
|
order.ReportId = vehicle.Combat.ReportId; order.ObservedAt = vehicle.Combat.ObservedAt;
|
|
string action = "resume authored route";
|
|
if (contact)
|
|
{
|
|
order.ReportId = contact.MessageId; order.ObservedAt = contact.ObservedAt;
|
|
action = "suspend travel for mounted cover";
|
|
}
|
|
route.MessageId = order.CommandId;
|
|
route.Payload = string.Format("convoy vehicle %1: %2; delivered sighting M%3", vehicle.Index, action, order.ReportId);
|
|
unit.PendingConvoyOrder = order; unit.Downlink = route;
|
|
m_Journal.Write("CONVOY ORDER QUEUED", route.Payload, route.MessageId);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
protected void DeliverConvoyOrder(ERR_HQUnit unit, float now)
|
|
{
|
|
ERR_ConvoyCombatOrder order = unit.PendingConvoyOrder;
|
|
bool accepted;
|
|
if (order && order.Group == unit.Group && ConvoyPositionKnown(unit, now))
|
|
{
|
|
ERR_HQReport contact = ConvoyContact(unit, now);
|
|
// A newer nearby sighting still justifies HOLD: frequent reports must not
|
|
// starve a slower radio downlink. New threat evidence always invalidates RESUME.
|
|
bool current = !order.Hold && !contact;
|
|
if (order.Hold && contact) current = contact.ObservedAt >= order.ObservedAt;
|
|
if (current) accepted = m_Convoys.ApplyCombatOrder(m_ConvoyTask, order, now);
|
|
}
|
|
if (accepted) m_Journal.Write("CONVOY ORDER DELIVERED", "original crew applied radio travel command", order.CommandId);
|
|
else if (order) m_Journal.Write("CONVOY ORDER REJECTED", "stale evidence or unavailable original crew; current order retained", order.CommandId);
|
|
unit.CancelPending();
|
|
}
|
|
|
|
protected void Assign(float now)
|
|
{
|
|
int globalLimit = m_Watch.SquadLimit(m_Mode.Settings().Get("supportSquadLimit"));
|
|
int limit = ERR_HQPursuitRules.Limit(globalLimit);
|
|
int radius = m_Mode.Settings().Get("responseRadiusMetres");
|
|
int assigned = Assigned();
|
|
int roadQueries;
|
|
// Snapshot bounded own-force eligibility once per five-second planning pass.
|
|
m_PlanBeliefs.Clear();
|
|
for (int index = 0; index < m_Memory.Count(); index++) m_PlanBeliefs.Insert(m_Memory.At(index));
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
unit.PlanEligible = unit.Eligible(m_Mode);
|
|
unit.PlanFighting = Fighting(unit);
|
|
if (unit.Group) unit.PlanPosition = unit.Group.GetOrigin();
|
|
}
|
|
for (int h = m_Hunts.Count() - 1; h >= 0; h--)
|
|
if (!m_Memory.GetById(m_Hunts[h].BeliefId)) m_Hunts.Remove(h);
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (!unit.Assignment && !unit.PendingOrder) continue;
|
|
if (!unit.PlanEligible || assigned > globalLimit) { FinishWatch(unit.Task, now); FinishWatch(unit.PendingTask, now); unit.Release(); assigned--; continue; }
|
|
if (unit.Task && now >= unit.Task.ExpiresAt) { FinishWatch(unit.Task, now); unit.ReleaseAssignment(); }
|
|
if (unit.PendingTask && now >= unit.PendingTask.ExpiresAt) { FinishWatch(unit.PendingTask, now); unit.CancelPending(); }
|
|
if (unit.Task && !unit.Task.Investigation() && !m_Memory.GetById(unit.Task.BeliefId)) unit.ReleaseAssignment();
|
|
if (unit.PendingTask && !unit.PendingTask.ReleaseOnly && !unit.PendingTask.Investigation() && !m_Memory.GetById(unit.PendingTask.BeliefId)) unit.CancelPending();
|
|
}
|
|
assigned = Assigned();
|
|
m_HomeAvailable.Clear();
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
if (unit.HomeGuard && unit.PlanEligible && !unit.Assignment && !unit.PendingOrder)
|
|
m_HomeAvailable.Set(unit.HomeId, m_HomeAvailable.Get(unit.HomeId) + 1);
|
|
foreach (ERR_HQUnit unit : m_Units) CancelResolvedInvestigation(unit, now);
|
|
RequestCheckins(now);
|
|
Retask(now);
|
|
Investigate(now, globalLimit);
|
|
assigned = HuntingAssigned();
|
|
array<vector> reserved = {};
|
|
int first = -1;
|
|
int second = -1;
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
ERR_HQTask planned = unit.PlannedTask();
|
|
if (!planned || (!unit.Assignment && !unit.PendingOrder)) continue;
|
|
reserved.Insert(planned.Destination);
|
|
int bearing = planned.ApproachBearing;
|
|
if (first < 0) first = bearing;
|
|
else if (bearing != first && second < 0) second = bearing;
|
|
}
|
|
// Strongest delivered track first; finite scans (64 beliefs,128 own units).
|
|
array<int> considered = {};
|
|
for (int pass = 0; pass < m_PlanBeliefs.Count() && assigned < limit && Assigned() < globalLimit; pass++)
|
|
{
|
|
ERR_HQBelief belief;
|
|
for (int i = 0; i < m_PlanBeliefs.Count(); i++)
|
|
{
|
|
ERR_HQBelief candidate = m_PlanBeliefs[i];
|
|
if (!candidate || considered.Contains(candidate.BeliefId)) continue;
|
|
float age = (now - candidate.ObservedAt) / 1000;
|
|
if (!ERR_HQPursuitRules.Actionable(candidate.Confidence, age, candidate.Radius)) continue;
|
|
if (!belief || candidate.Confidence > belief.Confidence) belief = candidate;
|
|
}
|
|
if (!belief) break;
|
|
considered.Insert(belief.BeliefId);
|
|
ERR_HQHuntWindow hunt = Hunt(belief.BeliefId);
|
|
if (!hunt || now < hunt.NextHunt) continue;
|
|
for (int slot = 0; slot < limit && assigned < limit && Assigned() < globalLimit; slot++)
|
|
{
|
|
float age = (now - belief.ObservedAt) / 1000;
|
|
ERR_HQPursuitRole role = ERR_HQPursuitRules.Role(belief.Confidence, age, belief.Radius, belief.HasVelocity, slot);
|
|
vector destination = ERR_HQPursuitRules.Objective(belief.PredictedPosition, belief.Velocity, belief.HasVelocity, belief.Confidence, age, belief.Radius, role, slot);
|
|
bool roadIntercept;
|
|
if (role == ERR_HQPursuitRole.INTERCEPT)
|
|
{
|
|
if (roadQueries < 2) { roadQueries++; roadIntercept = ERR_HQRoadIntercept.Select(belief, now, reserved, destination); }
|
|
if (!roadIntercept) role = ERR_HQPursuitRole.SEARCH;
|
|
}
|
|
if (role == ERR_HQPursuitRole.CONTAIN) destination = Containment(belief, destination);
|
|
if (role == ERR_HQPursuitRole.SEARCH && !m_Coverage.Select(belief.PredictedPosition, belief.Radius, belief.Position, now, destination, reserved)) continue;
|
|
ERR_HQUnit best;
|
|
ERR_HQRoute bestRoute;
|
|
float bestScore = -1;
|
|
int bestId;
|
|
int bestBearing = -1;
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (m_Watch.ArmedSearchBlocked(unit.ForceSourceId, now)) continue;
|
|
bool busy = unit.Assignment || unit.PendingOrder || unit.Downlink || unit.PlanFighting;
|
|
if (!unit.Radio || !ERR_HQPursuitRules.CanCommit(unit.Group != null, unit.PlanEligible, busy, unit.HomeGuard, HomeAvailable(unit), assigned, limit)) continue;
|
|
vector position = unit.PlanPosition;
|
|
if (vector.DistanceXZ(position, belief.Position) > radius) continue;
|
|
int bearing = ERR_HQPursuitRules.Bearing(position, belief.PredictedPosition);
|
|
if (!ERR_HQPursuitRules.BearingAllowed(bearing, first, second)) continue;
|
|
float score = ERR_HQPursuitRules.Score(role, belief.PredictedPosition, belief.Velocity, position, destination);
|
|
if (!ERR_HQPursuitRules.Better(score, unit.Id, bestScore, bestId)) continue;
|
|
ERR_HQRoute route = m_Network.Route(unit.Radio, true);
|
|
if (!route) continue;
|
|
best = unit; bestRoute = route; bestScore = score; bestId = unit.Id; bestBearing = bearing;
|
|
}
|
|
if (!best) continue;
|
|
ERR_HQTask task = new ERR_HQTask();
|
|
task.BeliefId = belief.BeliefId; task.BeliefRevision = belief.BeliefRevision; task.Role = role; task.RoadIntercept = roadIntercept;
|
|
task.Destination = destination; task.QueuedAt = now;
|
|
task.ExpiresAt = now + ERR_HQPursuitRules.TaskLifetimeSeconds(role, vector.DistanceXZ(best.PlanPosition, destination)) * 1000;
|
|
task.ApproachBearing = bestBearing;
|
|
best.PendingTask = task; best.PendingOrder = belief.Report.Snapshot(); best.Downlink = bestRoute;
|
|
bestRoute.MessageId = m_Journal.Message();
|
|
bestRoute.Payload = string.Format("group %1 %2; belief=%3 from report M%4; destination=%5", best.Id, task.Name(), task.BeliefId, belief.MessageId, destination);
|
|
m_Journal.Write("ORDER QUEUED", bestRoute.Payload, bestRoute.MessageId);
|
|
reserved.Insert(destination);
|
|
if (first < 0) first = bestBearing;
|
|
else if (bestBearing != first && second < 0) second = bestBearing;
|
|
if (best.HomeGuard) m_HomeAvailable.Set(best.HomeId, HomeAvailable(best) - 1);
|
|
hunt.NextHunt = Math.Max(hunt.NextHunt, task.ExpiresAt + 180000);
|
|
assigned++;
|
|
}
|
|
}
|
|
}
|
|
|
|
override void Tick(float now)
|
|
{
|
|
if (!Replication.IsServer()) return;
|
|
m_Memory.Tick(now);
|
|
m_Equipment.Tick(now);
|
|
m_Convoys.Tick(now);
|
|
AutomaticConvoy(now);
|
|
m_Bodies.TickBudget(now);
|
|
if (now >= m_NextNetwork) { IndexRadios(); m_NextNetwork = now + 5000; }
|
|
for (int i = m_Contacts.Count() - 1; i >= 0; i--)
|
|
if (!ERR_MissionRules.ContactFresh(m_Contacts[i].ObservedAt, now)) m_Contacts.Remove(i);
|
|
for (int i = m_Units.Count() - 1; i >= 0; i--)
|
|
{
|
|
ERR_HQUnit unit = m_Units[i];
|
|
if (unit.Uplink)
|
|
{
|
|
int delivered = unit.Uplink.Advance(now, m_Journal);
|
|
if (delivered == 1)
|
|
{
|
|
if (unit.PendingStatus) m_Watch.Ingest(unit.PendingStatus, now);
|
|
else if (unit.PendingSweep) AcceptSweep(unit.PendingSweep, now);
|
|
else if (unit.PendingSupplyStatus) m_Logistics.Receive(unit.PendingSupplyStatus, now);
|
|
else Accept(unit.PendingReport, now);
|
|
}
|
|
if (delivered < 0 && unit.PendingSweep && unit.Task && unit.PendingSweep.BeliefId == unit.Task.BeliefId && unit.PendingSweep.BeliefRevision == unit.Task.BeliefRevision && unit.PendingSweep.WatchSourceId == unit.Task.WatchSourceId && unit.PendingSweep.WatchMessageId == unit.Task.WatchMessageId && unit.PendingSweep.WatchRequestId == unit.Task.WatchRequestId) unit.Task.SweepQueued = false;
|
|
if (delivered != 0) { unit.Uplink = null; unit.PendingReport = null; unit.PendingSupplyStatus = null; unit.PendingSweep = null; unit.PendingStatus = null; }
|
|
}
|
|
if (unit.Downlink)
|
|
{
|
|
int delivered = unit.Downlink.Advance(now, m_Journal);
|
|
if (delivered == 1)
|
|
{
|
|
if (unit.PendingConvoyOrder) DeliverConvoyOrder(unit, now);
|
|
else if (unit.PendingCheckin) { unit.NextStatus = now; unit.CancelPending(); }
|
|
else DeliverOrder(unit, now);
|
|
}
|
|
else if (delivered < 0) LostOrder(unit, now);
|
|
}
|
|
if (!unit.Group && !unit.Uplink) { ReleaseUnit(unit, now); m_Units.Remove(i); continue; }
|
|
QueueReports(unit, now);
|
|
}
|
|
if (now >= m_NextAssignment) { PlanConvoy(now); PlanResupply(now); Assign(now); m_NextAssignment = now + 5000; }
|
|
m_Resupply.Tick(now);
|
|
m_Logistics.Tick(now);
|
|
m_Mortars.Tick(now);
|
|
m_Journal.Flush();
|
|
}
|
|
|
|
override void Stop()
|
|
{
|
|
m_ConvoyStartup.Stop();
|
|
m_Resupply.Stop();
|
|
m_Convoys.Stop();
|
|
m_Equipment.Stop();
|
|
m_Logistics.Stop();
|
|
m_Mortars.Stop();
|
|
foreach (ERR_HQUnit unit : m_Units) unit.Release();
|
|
m_Units.Clear();
|
|
m_Contacts.Clear();
|
|
m_Memory.Clear(); m_Coverage.Clear(); m_Hunts.Clear(); m_Watch.Clear(); m_Bodies.Stop(); m_PlanBeliefs.Clear(); m_HomeAvailable.Clear();
|
|
m_Network.Clear();
|
|
m_Journal.Write("STOP", "HQ stopped; tactical orders released");
|
|
m_Journal.Flush();
|
|
}
|
|
}
|
|
|
|
modded class ERR_GameMode
|
|
{
|
|
protected override ERR_CommandService CreateCommandService()
|
|
{
|
|
ERR_HQ hq = new ERR_HQ(this);
|
|
Admin().Register(new ERR_HQAdminProvider(hq));
|
|
return hq;
|
|
}
|
|
}
|