jakub
6a667d8deb
Include the current addon, terrain integrations, tools, regression tests and recorded development evidence.
208 lines
11 KiB
C
208 lines
11 KiB
C
// One physical escort may intercept a road ahead of delivered travel history.
|
|
// This HQ-owned transport uses the ordinary radio graph and never reads players.
|
|
modded class ERR_HQ
|
|
{
|
|
protected ref ERR_ConvoyInterceptOrder m_MountedIntercept;
|
|
protected ERR_HQUnit m_MountedInterceptUnit;
|
|
protected ERR_ConvoyTask m_MountedInterceptTask;
|
|
protected ref ERR_HQRoute m_MountedInterceptRoute;
|
|
protected bool m_MountedInterceptDelivered;
|
|
protected ref array<int> m_MountedAttemptBeliefs = {};
|
|
protected ref array<int> m_MountedAttemptRevisions = {};
|
|
|
|
override string Status()
|
|
{
|
|
string result = super.Status();
|
|
if (!m_MountedIntercept) return result;
|
|
string phase = "queued";
|
|
if (m_MountedInterceptDelivered) phase = "delivered";
|
|
return result + "\n" + string.Format("Mounted interception: escort %1; %2; report M%3; road %4", m_MountedIntercept.VehicleIndex, phase, m_MountedIntercept.ReportId, m_MountedIntercept.Position);
|
|
}
|
|
|
|
protected override int Assigned()
|
|
{
|
|
int count = super.Assigned();
|
|
if (m_MountedIntercept) count++;
|
|
return count;
|
|
}
|
|
protected override int HuntingAssigned()
|
|
{
|
|
int count = super.HuntingAssigned();
|
|
if (m_MountedIntercept) count++;
|
|
return count;
|
|
}
|
|
protected override void ReserveUnit(ERR_HQUnit unit, array<vector> reserved, out int first, out int second)
|
|
{
|
|
super.ReserveUnit(unit, reserved, first, second);
|
|
if (m_MountedIntercept && unit == m_MountedInterceptUnit) reserved.Insert(m_MountedIntercept.Position);
|
|
}
|
|
protected bool MountedInterceptAttempted(int beliefId, int revision)
|
|
{
|
|
for (int i = 0; i < m_MountedAttemptBeliefs.Count(); i++)
|
|
if (m_MountedAttemptBeliefs[i] == beliefId && m_MountedAttemptRevisions[i] == revision) return true;
|
|
return false;
|
|
}
|
|
protected bool MountedInterceptStatus(ERR_HQUnit unit, ERR_ConvoyVehicle vehicle, float now)
|
|
{
|
|
if (!unit || !vehicle || !unit.StatusSampler || vehicle.Group != unit.Group || !vehicle.Entity
|
|
|| !unit.StatusSampler.OwnsRoster(unit.Group) || !unit.StatusSampler.ValidateBoundVehicle(vehicle.Entity)) return false;
|
|
ERR_HQWatchEntry entry = m_Watch.Find(unit.ForceSourceId);
|
|
if (!entry || entry.Closed || entry.SourceId != unit.ForceSourceId || entry.MessageId <= 0
|
|
|| !ERR_HQMemoryRules.DeliveryFresh(entry.ObservedAt, now) || !ERR_ForceRules.Finite(entry.LastDeliveredAt)
|
|
|| entry.LastDeliveredAt < entry.ObservedAt || entry.LastDeliveredAt > now
|
|
|| !ERR_ForceRules.FiniteVector(entry.Position) || entry.Count < 1 || entry.Count != entry.Strength
|
|
|| entry.Fit != entry.Count || !entry.MountedAmmo || !entry.MountedAmmo.Complete || !entry.MountedAmmo.Valid()) return false;
|
|
return entry.MountedAmmo.Weapons > 0 && entry.MountedAmmo.Rounds + entry.MountedAmmo.Chambers > 0;
|
|
}
|
|
protected void ReleaseMountedIntercept(float now, string reason)
|
|
{
|
|
ref ERR_ConvoyInterceptOrder order = m_MountedIntercept;
|
|
ERR_HQUnit unit = m_MountedInterceptUnit;
|
|
ERR_ConvoyTask task = m_MountedInterceptTask;
|
|
// Detach first: physical release may synchronously unregister the group.
|
|
m_MountedIntercept = null; m_MountedInterceptUnit = null; m_MountedInterceptTask = null;
|
|
m_MountedInterceptRoute = null; m_MountedInterceptDelivered = false;
|
|
if (!order) return;
|
|
if (m_Convoys) m_Convoys.ReleaseIntercept(task, order, now);
|
|
if (unit && unit.LogisticsReservation == order.Token) unit.LogisticsReservation = 0;
|
|
m_Journal.Write("MOUNTED INTERCEPT END", reason, order.ReportId);
|
|
}
|
|
protected override void ReleaseUnit(ERR_HQUnit unit, float now)
|
|
{
|
|
if (m_MountedIntercept && unit == m_MountedInterceptUnit) ReleaseMountedIntercept(now, "original formation released");
|
|
super.ReleaseUnit(unit, now);
|
|
}
|
|
protected override void TickMountedIntercept(float now)
|
|
{
|
|
if (!m_MountedIntercept || !ERR_ForceRules.Finite(now)) return;
|
|
ERR_HQUnit unit = m_MountedInterceptUnit;
|
|
ERR_ConvoyInterceptOrder order = m_MountedIntercept;
|
|
int globalLimit = m_Watch.SquadLimit(m_Mode.Settings().Runtime("supportSquadLimit"));
|
|
if (now < order.IssuedAt || now >= order.ExpiresAt
|
|
|| !MissionActive() || m_Stopping || !unit || !m_Units.Contains(unit) || unit.Group != order.Group
|
|
|| unit.LogisticsReservation != order.Token || !unit.StatusSampler || !unit.StatusSampler.OwnsRoster(unit.Group)
|
|
|| Assigned() > globalLimit || HuntingAssigned() > ERR_HQPursuitRules.Limit(globalLimit)
|
|
|| !m_Convoys.InterceptCurrent(m_MountedInterceptTask, order))
|
|
{ ReleaseMountedIntercept(now, "expiry, capacity or original ownership changed"); return; }
|
|
if (m_MountedInterceptDelivered) return;
|
|
ERR_HQBelief belief = m_Memory.GetById(order.BeliefId);
|
|
if (!ERR_HQMountedInterceptRules.Current(order, belief, now) || !m_MountedInterceptRoute)
|
|
{ ReleaseMountedIntercept(now, "delivered history changed before command arrival"); return; }
|
|
int delivered = m_MountedInterceptRoute.Advance(now, m_Journal);
|
|
if (delivered == 0) return;
|
|
if (delivered < 0)
|
|
{ ReleaseMountedIntercept(now, "radio interrupted; authored route retained"); return; }
|
|
ERR_ConvoyVehicle vehicle = m_MountedInterceptTask.Vehicles[order.VehicleIndex];
|
|
if (!MountedInterceptStatus(unit, vehicle, now) || ConvoyContact(unit, now)
|
|
|| !m_Convoys.ApplyIntercept(m_MountedInterceptTask, order, now))
|
|
{ ReleaseMountedIntercept(now, "command refused by original crew"); return; }
|
|
m_MountedInterceptRoute = null; m_MountedInterceptDelivered = true;
|
|
m_Journal.Write("MOUNTED INTERCEPT DELIVERED", "original armed escort ordered to the remembered road ahead", order.ReportId);
|
|
}
|
|
protected bool MountedInterceptTaskAvailable(ERR_ConvoyTask task)
|
|
{
|
|
if (!task || task.Stopped || !task.Ready || !task.Receipt || task.Vehicles.Count() != 6) return false;
|
|
// Service admission excludes the whole original convoy, including sibling
|
|
// holds still in transit. Do not spend a delivered revision on a busy task.
|
|
foreach (ERR_ConvoyVehicle vehicle : task.Vehicles)
|
|
{
|
|
if (!vehicle || vehicle.InterceptToken > 0 || vehicle.SupplyToken > 0 || vehicle.SupplyHeld || vehicle.Combat.Held) return false;
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
if (unit.Group == vehicle.Group && (unit.PendingConvoyOrder || unit.Downlink || unit.LogisticsReservation > 0)) return false;
|
|
}
|
|
return true;
|
|
}
|
|
protected bool HasMountedInterceptCandidate(float now)
|
|
{
|
|
// Avoid native road surveys until one original escort has usable delivered status.
|
|
for (int t = 0; t < m_Convoys.Count(); t++)
|
|
{
|
|
ERR_ConvoyTask task = m_Convoys.At(t);
|
|
if (!MountedInterceptTaskAvailable(task)) continue;
|
|
foreach (ERR_ConvoyVehicle vehicle : task.Vehicles)
|
|
{
|
|
if (!vehicle || (vehicle.Index != 0 && vehicle.Index != 3 && vehicle.Index != 5)
|
|
|| vehicle.Released || vehicle.Arrived || !vehicle.Registered || vehicle.InterceptToken > 0
|
|
|| vehicle.SupplyToken > 0 || vehicle.SupplyHeld || vehicle.Combat.Held) continue;
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
if (unit.Group == vehicle.Group && MountedLogisticsEligible(unit) && !ConvoyContact(unit, now)
|
|
&& MountedInterceptStatus(unit, vehicle, now)) return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
protected override void PlanMountedIntercept(float now)
|
|
{
|
|
if (!Replication.IsServer() || m_Stopping || !MissionActive() || m_MountedIntercept || m_MountedAttemptBeliefs.Count() >= 256) return;
|
|
int globalLimit = m_Watch.SquadLimit(m_Mode.Settings().Runtime("supportSquadLimit"));
|
|
if (Assigned() >= globalLimit || HuntingAssigned() >= ERR_HQPursuitRules.Limit(globalLimit)) return;
|
|
if (!HasMountedInterceptCandidate(now)) return;
|
|
array<vector> reserved = {}; int first = -1; int second = -1;
|
|
foreach (ERR_HQUnit known : m_Units) ReserveUnit(known, reserved, first, second);
|
|
// At most two bounded native road queries per normal five-second HQ pass.
|
|
int queries;
|
|
for (int b = 0; b < m_Memory.Count() && queries < 2; b++)
|
|
{
|
|
ERR_HQBelief belief = m_Memory.At(b);
|
|
if (!ERR_HQMountedInterceptRules.Eligible(belief, now) || MountedInterceptAttempted(belief.BeliefId, belief.BeliefRevision)) continue;
|
|
vector destination; queries++;
|
|
if (!ERR_HQMountedInterceptRules.Select(belief, now, reserved, destination)) continue;
|
|
ERR_HQUnit best;
|
|
ERR_ConvoyTask bestTask;
|
|
ERR_ConvoyVehicle bestVehicle;
|
|
ERR_HQRoute bestRoute;
|
|
float bestDistance = 1e20;
|
|
for (int t = 0; t < m_Convoys.Count(); t++)
|
|
{
|
|
ERR_ConvoyTask task = m_Convoys.At(t);
|
|
if (!MountedInterceptTaskAvailable(task)) continue;
|
|
foreach (ERR_ConvoyVehicle vehicle : task.Vehicles)
|
|
{
|
|
if (!vehicle || (vehicle.Index != 0 && vehicle.Index != 3 && vehicle.Index != 5)
|
|
|| vehicle.Released || vehicle.Arrived || !vehicle.Registered || vehicle.InterceptToken > 0
|
|
|| vehicle.SupplyToken > 0 || vehicle.SupplyHeld || vehicle.Combat.Held) continue;
|
|
foreach (ERR_HQUnit unit : m_Units)
|
|
{
|
|
if (unit.Group != vehicle.Group || !MountedLogisticsEligible(unit) || ConvoyContact(unit, now)
|
|
|| !MountedInterceptStatus(unit, vehicle, now)) continue;
|
|
ERR_HQWatchEntry own = m_Watch.Find(unit.ForceSourceId);
|
|
float distance = vector.DistanceXZ(own.Position, destination);
|
|
if (distance > m_Mode.Settings().Runtime("responseRadiusMetres") || distance >= bestDistance) continue;
|
|
ERR_HQRoute candidateRoute = m_Network.Route(unit.Radio, true);
|
|
if (!candidateRoute) continue;
|
|
best = unit; bestTask = task; bestVehicle = vehicle; bestRoute = candidateRoute; bestDistance = distance;
|
|
}
|
|
}
|
|
}
|
|
if (!best) continue;
|
|
ERR_HQRoute route = bestRoute;
|
|
if (!route) continue;
|
|
ERR_ConvoyInterceptOrder order = new ERR_ConvoyInterceptOrder();
|
|
order.Token = 400001 + m_MountedAttemptBeliefs.Count(); order.Group = best.Group;
|
|
order.SourceId = bestTask.Receipt.SourceId; order.VehicleIndex = bestVehicle.Index;
|
|
order.Position = destination; order.BeliefId = belief.BeliefId; order.BeliefRevision = belief.BeliefRevision;
|
|
order.ReportId = belief.MessageId; order.ObservedAt = belief.ObservedAt;
|
|
order.IssuedAt = now; order.ExpiresAt = belief.ObservedAt + 120000;
|
|
if (!ERR_HQMountedInterceptRules.Current(order, belief, now)) continue;
|
|
// The attempt stays spent after radio interruption, physical refusal or loss.
|
|
m_MountedAttemptBeliefs.Insert(order.BeliefId); m_MountedAttemptRevisions.Insert(order.BeliefRevision);
|
|
best.LogisticsReservation = order.Token;
|
|
if (!m_Convoys.ReserveIntercept(bestTask, order, now))
|
|
{ if (best.LogisticsReservation == order.Token) best.LogisticsReservation = 0; return; }
|
|
m_MountedIntercept = order; m_MountedInterceptUnit = best; m_MountedInterceptTask = bestTask;
|
|
m_MountedInterceptRoute = route; m_MountedInterceptDelivered = false;
|
|
route.MessageId = m_Journal.Message();
|
|
route.Payload = string.Format("original escort %1 to road %2; delivered track %3 revision %4 report M%5", order.VehicleIndex, destination, order.BeliefId, order.BeliefRevision, order.ReportId);
|
|
m_Journal.Write("MOUNTED INTERCEPT QUEUED", route.Payload, route.MessageId);
|
|
return;
|
|
}
|
|
}
|
|
override void Stop()
|
|
{
|
|
float now;
|
|
if (GetGame() && GetGame().GetWorld()) now = GetGame().GetWorld().GetWorldTime();
|
|
ReleaseMountedIntercept(now, "mission stopped");
|
|
super.Stop();
|
|
}
|
|
}
|