279 lines
14 KiB
C
279 lines
14 KiB
C
// HQ-owned ground rendezvous using delivered positions and existing finite cargo.
|
|
class ERR_InfantryResupplyRules
|
|
{
|
|
static bool Fresh(ERR_HQWatchEntry entry, float now)
|
|
{
|
|
return entry && !entry.Closed && entry.Count > 0 && entry.Fit > 0
|
|
&& ERR_ForceRules.Finite(now) && entry.ObservedAt >= 0 && now >= entry.ObservedAt
|
|
&& now - entry.ObservedAt <= 120000 && ERR_ForceRules.FiniteVector(entry.Position);
|
|
}
|
|
static bool Need(ERR_HQWatchEntry entry, float now)
|
|
{
|
|
return Fresh(entry, now) && entry.AmmoState && entry.AmmoState.Valid(entry.Count)
|
|
&& entry.AmmoState.Complete && entry.AmmoState.Members == entry.Count
|
|
&& entry.AmmoState.SmallArmsMuzzles > 0
|
|
&& entry.AmmoState.SmallArmsRounds + entry.AmmoState.SmallArmsChambers <= entry.Count * 30;
|
|
}
|
|
static bool Pair(ERR_HQWatchEntry recipient, ERR_HQWatchEntry donor, float now)
|
|
{
|
|
return Need(recipient, now) && Fresh(donor, now) && recipient.SourceId != donor.SourceId
|
|
&& vector.DistanceXZ(recipient.Position, donor.Position) <= 200;
|
|
}
|
|
}
|
|
|
|
class ERR_InfantryResupply
|
|
{
|
|
protected ERR_HQ m_HQ;
|
|
protected ERR_GameMode m_Mode;
|
|
protected ERR_ConvoyTask m_Convoy;
|
|
protected ERR_ConvoyVehicle m_Truck;
|
|
protected ERR_HQUnit m_Recipient;
|
|
protected ERR_HQUnit m_Donor;
|
|
protected ref array<IEntity> m_Stock = {};
|
|
protected ref array<IEntity> m_Spent = {};
|
|
protected ref array<IEntity> m_Members = {};
|
|
protected ref array<IEntity> m_Served = {};
|
|
protected ref map<string, int> m_Consumed = new map<string, int>();
|
|
protected ref map<string, float> m_NextAttempt = new map<string, float>();
|
|
protected ref ERR_HQRoute m_Order;
|
|
protected ref ERR_InfantryAmmoTransfer m_Move;
|
|
protected IEntity m_Receiving;
|
|
protected AIWaypoint m_MoveWaypoint;
|
|
protected AIWaypoint m_HoldWaypoint;
|
|
protected vector m_Rendezvous;
|
|
protected int m_State; // 0 stock startup, 1 idle, 2 truck downlink, 3 stopped status, 4 infantry downlink, 5 transfer
|
|
protected int m_Trip;
|
|
protected int m_Token;
|
|
protected int m_ReportId;
|
|
protected int m_Delivered;
|
|
protected int m_TripDelivered;
|
|
protected float m_Deadline;
|
|
protected float m_HeldAt;
|
|
protected float m_NextTick;
|
|
protected bool m_Stopped;
|
|
protected string m_Reason;
|
|
void ERR_InfantryResupply(ERR_HQ hq, ERR_GameMode mode) { m_HQ = hq; m_Mode = mode; }
|
|
int State() { return m_State; }
|
|
int Delivered() { return m_Delivered; }
|
|
int StockCount() { return m_Stock.Count(); }
|
|
protected void Audit(string reason)
|
|
{
|
|
m_Reason = reason;
|
|
m_HQ.Journal().Write("INFANTRY SUPPLY", string.Format("trip=%1 state=%2 moved=%3 spent=%4/%5; %6", m_Trip, m_State, m_Delivered, m_Spent.Count(), m_Stock.Count(), reason), m_ReportId);
|
|
}
|
|
protected bool Current()
|
|
{
|
|
return !m_Stopped && Replication.IsServer() && m_Mode && m_Mode == ERR_GameMode.Get() && m_Mode.Active();
|
|
}
|
|
protected bool Contains(IEntity owner, IEntity item)
|
|
{
|
|
if (!owner || !item) return false;
|
|
InventoryStorageManagerComponent inventory = InventoryStorageManagerComponent.Cast(owner.FindComponent(InventoryStorageManagerComponent));
|
|
if (!inventory) return false;
|
|
array<IEntity> items = {}; ERR_Inventory.Items(inventory, items);
|
|
return items.Count() <= 128 && items.Contains(item);
|
|
}
|
|
protected bool TruckValid()
|
|
{
|
|
if (!m_Convoy || m_Convoy.Stopped || !m_Convoy.Ready || !m_Convoy.Receipt || !m_Convoy.Receipt.Consumed
|
|
|| m_HQ.ConvoyTask() != m_Convoy || m_Convoy.Vehicles.Count() != 6 || m_Convoy.Vehicles[1] != m_Truck) return false;
|
|
if (!m_Truck || m_Truck.Index != 1 || !m_Truck.Registered || m_Truck.Released || m_Truck.Arrived
|
|
|| !m_Truck.CrewValid(m_Mode) || ERR_ConvoyRules.Captured(m_Truck.Entity, m_Truck.Group)) return false;
|
|
ERR_ForceRecord record = m_Mode.Forces().FindGroup(m_Truck.Group);
|
|
return record && record.Physical && !record.Eliminated && record.Kind == ERR_ForceKind.CONVOY
|
|
&& m_Convoy.Receipt.Records.Count() == 6 && record.Id == m_Convoy.Receipt.Records[1];
|
|
}
|
|
protected bool Quiet(ERR_HQUnit unit)
|
|
{
|
|
return unit && unit.Group && unit.Utility && !unit.Group.IsSlave() && unit.Group.GetPlayerCount(true) == 0
|
|
&& unit.Group.GetFaction() == m_Mode.EnemyFaction()
|
|
&& (!unit.Utility.m_Perception || unit.Utility.m_Perception.m_aTargets.IsEmpty());
|
|
}
|
|
protected bool Roster()
|
|
{
|
|
if (!m_Recipient || !Quiet(m_Recipient) || !m_Recipient.StatusSampler.OwnsRoster(m_Recipient.Group)) return false;
|
|
int strength = m_Recipient.StatusSampler.InitialStrength();
|
|
if (strength < 1 || strength > 32) return false;
|
|
array<AIAgent> agents = {}; m_Recipient.Group.GetAgents(agents);
|
|
if (agents.IsEmpty() || agents.Count() > 32) return false;
|
|
foreach (AIAgent agent : agents)
|
|
if (!agent || !m_Members.Contains(agent.GetControlledEntity())) return false;
|
|
bool living;
|
|
foreach (IEntity actor : m_Members)
|
|
{
|
|
if (!actor || !ERR_Actors.Alive(actor)) continue;
|
|
// Returning to the group cannot undo a sampler's permanent release of an
|
|
// original slot after transfer or player control during this trip.
|
|
bool attributed = false;
|
|
for (int slot = 0; slot < strength; slot++)
|
|
{
|
|
if (m_Recipient.StatusSampler.InitialMember(slot) != actor) continue;
|
|
attributed = m_Recipient.StatusSampler.CanAttribute(slot, actor);
|
|
break;
|
|
}
|
|
if (!attributed) return false;
|
|
if (ERR_Actors.Player(actor) || ERR_Actors.Group(actor) != m_Recipient.Group
|
|
|| SCR_FactionManager.SGetFaction(actor) != m_Mode.EnemyFaction() || CompartmentAccessComponent.GetVehicleIn(actor)) return false;
|
|
if (ERR_Actors.CanFight(actor)) living = true;
|
|
}
|
|
return living;
|
|
}
|
|
protected void Stock(float now)
|
|
{
|
|
m_Convoy = m_HQ.ConvoyTask();
|
|
if (!m_Convoy || !m_Convoy.Ready || m_Convoy.Vehicles.Count() != 6) return;
|
|
m_Truck = m_Convoy.Vehicles[1];
|
|
if (!TruckValid()) { Stop(); return; }
|
|
foreach (ERR_ConvoyCargoCallback operation : m_Convoy.Cargo)
|
|
if (!operation.Finished) { if (now >= m_Convoy.Deadline) Stop(); return; }
|
|
InventoryStorageManagerComponent inventory = InventoryStorageManagerComponent.Cast(m_Truck.Entity.FindComponent(InventoryStorageManagerComponent));
|
|
if (!inventory) { Stop(); return; }
|
|
array<IEntity> items = {}; ERR_Inventory.Items(inventory, items);
|
|
if (items.Count() > 128) { Stop(); return; }
|
|
foreach (IEntity item : items)
|
|
{
|
|
if (!item || !item.GetPrefabData() || item.GetPrefabData().GetPrefabName() != ERR_ConvoyResources.Magazine()) continue;
|
|
if (m_Stock.Count() >= 48) { Stop(); return; }
|
|
m_Stock.Insert(item);
|
|
}
|
|
m_State = 1; Audit("truck magazine identities captured once after startup; absent/looted stock is never replaced");
|
|
}
|
|
bool TryPlan(ERR_HQUnit recipient, ERR_HQUnit donor, ERR_HQWatchEntry demand, ERR_HQWatchEntry donorStatus, float now)
|
|
{
|
|
if (!Current() || m_State != 1 || m_Move || m_Trip >= 128 || !TruckValid()) return false;
|
|
if (m_Truck.Combat.Held || m_Truck.SupplyToken > 0 || !recipient || !donor) return false;
|
|
if (donor.Group != m_Truck.Group || recipient.HomeGuard || !Quiet(recipient) || !Quiet(donor)) return false;
|
|
if (donor.Downlink || donor.PendingOrder || donor.PendingConvoyOrder) return false;
|
|
if (!ERR_InfantryResupplyRules.Pair(demand, donorStatus, now)) return false;
|
|
if (demand.SourceId != recipient.ForceSourceId || donorStatus.SourceId != donor.ForceSourceId) return false;
|
|
if (demand.MessageId <= m_Consumed.Get(demand.SourceId) || now < m_NextAttempt.Get(demand.SourceId)) return false;
|
|
bool available;
|
|
foreach (IEntity magazine : m_Stock) if (magazine && !m_Spent.Contains(magazine) && Contains(m_Truck.Entity, magazine)) { available = true; break; }
|
|
if (!available) return false;
|
|
m_Members.Clear();
|
|
for (int i = 0; i < recipient.StatusSampler.InitialStrength(); i++)
|
|
{
|
|
IEntity actor = recipient.StatusSampler.InitialMember(i);
|
|
if (actor && recipient.StatusSampler.CanAttribute(i, actor)) m_Members.Insert(actor);
|
|
}
|
|
m_Recipient = recipient; m_Donor = donor;
|
|
if (!Roster()) { m_Recipient = null; m_Donor = null; return false; }
|
|
// Disjoint bounded token range from the existing mortar courier's trip IDs.
|
|
int token = 100000 + m_Trip + 1;
|
|
if (!m_HQ.ReserveLogistics(recipient.Group, token)) { m_Recipient = null; m_Donor = null; return false; }
|
|
m_Trip++; m_Token = token; m_Truck.SupplyToken = token; m_ReportId = demand.MessageId; m_TripDelivered = 0; m_Served.Clear();
|
|
m_Consumed.Set(demand.SourceId, demand.MessageId); m_NextAttempt.Set(demand.SourceId, now + 180000);
|
|
m_Deadline = Math.Min(now + 120000, demand.ObservedAt + 180000); m_State = 2;
|
|
m_Order = m_HQ.Downlink(donor.Group, "INFANTRY SUPPLY HOLD", "stop existing ammo truck and report position", m_ReportId);
|
|
if (!m_Order) Finish("truck radio downlink unavailable");
|
|
else Audit("existing patrol reserved; truck hold awaits radio delivery");
|
|
return true;
|
|
}
|
|
protected bool Waypoints()
|
|
{
|
|
m_MoveWaypoint = AIWaypoint.Cast(ERR_Actors.Spawn(ERR_Resources.MoveWaypoint(), ERR_Actors.Ground(m_Rendezvous)));
|
|
m_HoldWaypoint = AIWaypoint.Cast(ERR_Actors.Spawn(ERR_Resources.DefendWaypoint(), ERR_Actors.Ground(m_Rendezvous)));
|
|
if (!m_MoveWaypoint || !m_HoldWaypoint) return false;
|
|
m_MoveWaypoint.SetCompletionRadius(2); m_HoldWaypoint.SetCompletionRadius(3);
|
|
m_Recipient.Group.AddWaypointAt(m_HoldWaypoint, 0); m_Recipient.Group.AddWaypointAt(m_MoveWaypoint, 0);
|
|
m_Recipient.Group.ActivateAI(); return true;
|
|
}
|
|
protected void ClearWaypoints()
|
|
{
|
|
if (m_MoveWaypoint) { if (m_Recipient && m_Recipient.Group) m_Recipient.Group.RemoveWaypoint(m_MoveWaypoint); ERR_Actors.DeleteSpawned(m_MoveWaypoint); }
|
|
if (m_HoldWaypoint) { if (m_Recipient && m_Recipient.Group) m_Recipient.Group.RemoveWaypoint(m_HoldWaypoint); ERR_Actors.DeleteSpawned(m_HoldWaypoint); }
|
|
m_MoveWaypoint = null; m_HoldWaypoint = null;
|
|
}
|
|
protected void Finish(string reason)
|
|
{
|
|
Audit(reason);
|
|
if (m_Move) m_Move.Stop();
|
|
ClearWaypoints();
|
|
if (m_Recipient) m_HQ.ReleaseLogistics(m_Recipient.Group, m_Token);
|
|
if (m_Truck && m_Truck.SupplyToken == m_Token) { m_Truck.SupplyToken = 0; m_Truck.SupplyHeld = false; }
|
|
m_Recipient = null; m_Donor = null; m_Order = null; m_Receiving = null; m_State = 1;
|
|
}
|
|
protected void Transfer(float now)
|
|
{
|
|
if (m_Move)
|
|
{
|
|
int result = m_Move.Tick(now);
|
|
if (result == 0) return;
|
|
if (result < 0) { Finish("native transfer rejected, expired or lost authority; no item retry"); return; }
|
|
m_Move = null; m_Delivered++; m_TripDelivered++; m_Served.Insert(m_Receiving); m_Receiving = null;
|
|
Audit("exact finite magazine confirmed in original soldier inventory");
|
|
if (m_TripDelivered >= 6) { Finish("six-magazine trip allowance reached"); return; }
|
|
}
|
|
foreach (IEntity actor : m_Members)
|
|
{
|
|
if (!ERR_Actors.CanFight(actor) || m_Served.Contains(actor) || vector.DistanceXZ(actor.GetOrigin(), m_Truck.Entity.GetOrigin()) > 4) continue;
|
|
ERR_HQAmmoSnapshot local = new ERR_HQAmmoSnapshot(); local.Complete = true; local.LauncherComplete = true;
|
|
ERR_HQAmmoSampler.Inspect(actor, m_Recipient.Group, local);
|
|
if (!local.Complete || local.SmallArmsMuzzles <= 0 || local.SmallArmsRounds + local.SmallArmsChambers > 30) continue;
|
|
foreach (IEntity magazine : m_Stock)
|
|
{
|
|
if (!magazine || m_Spent.Contains(magazine) || !Contains(m_Truck.Entity, magazine) || !ERR_InfantryAmmoTransfer.Compatible(actor, magazine)) continue;
|
|
m_Spent.Insert(magazine); m_Receiving = actor;
|
|
m_Move = new ERR_InfantryAmmoTransfer(m_Mode, m_Truck.Entity, m_Truck.Group, actor, m_Recipient.Group, magazine);
|
|
m_Move.Tick(now); return;
|
|
}
|
|
}
|
|
}
|
|
void Tick(float now)
|
|
{
|
|
if (!Current() || !ERR_ForceRules.Finite(now) || now < m_NextTick) return;
|
|
m_NextTick = now + 1000;
|
|
if (m_State == 0) { Stock(now); return; }
|
|
if (m_State == 1)
|
|
{
|
|
if (m_Move && !m_Move.Unresolved()) m_Move = null;
|
|
return;
|
|
}
|
|
if (now >= m_Deadline || !TruckValid() || !Quiet(m_Donor) || !Roster() || m_Truck.Combat.Held
|
|
|| m_HQ.LogisticsToken(m_Recipient.Group) != m_Token)
|
|
{ Finish("rendezvous expired, contact appeared or original ownership changed"); return; }
|
|
if (m_Truck.SupplyToken != m_Token) { Finish("truck hold authority lost"); return; }
|
|
if (m_State == 2)
|
|
{
|
|
int delivered = m_Order.Advance(now, m_HQ.Journal());
|
|
if (delivered == 0) return;
|
|
if (delivered < 0 || m_Truck.SupplyToken != m_Token) { Finish("truck hold downlink interrupted or reservation lost"); return; }
|
|
m_Truck.SupplyHeld = true; m_Truck.ClearOrder(); m_HeldAt = -1;
|
|
m_Order = null; m_State = 3; Audit("truck received stop; waiting for delivered stopped-position report"); return;
|
|
}
|
|
if (m_State == 3)
|
|
{
|
|
// The delivered hold asks the original crew to report only after physically stopping.
|
|
if (m_HeldAt < 0)
|
|
{
|
|
Physics physics = m_Truck.Entity.GetPhysics();
|
|
if (!physics) return;
|
|
float speed = physics.GetVelocity().Length();
|
|
float angular = physics.GetAngularVelocity().Length();
|
|
if (!(speed >= 0 && speed <= 0.25 && angular >= 0 && angular <= 0.1)) return;
|
|
m_HeldAt = now; m_Donor.NextStatus = now; return;
|
|
}
|
|
ERR_HQWatchEntry stopped = m_HQ.Watch().Find(m_Donor.ForceSourceId);
|
|
if (!ERR_InfantryResupplyRules.Fresh(stopped, now) || stopped.ObservedAt < m_HeldAt) return;
|
|
m_Rendezvous = stopped.Position + "3 0 0";
|
|
m_Order = m_HQ.Downlink(m_Recipient.Group, "INFANTRY SUPPLY RENDEZVOUS", string.Format("walk to reported stopped ammo truck at %1", m_Rendezvous), m_ReportId);
|
|
if (!m_Order) { Finish("infantry radio downlink unavailable"); return; }
|
|
m_State = 4; return;
|
|
}
|
|
if (m_State == 4)
|
|
{
|
|
int delivered = m_Order.Advance(now, m_HQ.Journal());
|
|
if (delivered == 0) return;
|
|
if (delivered < 0 || !Waypoints()) { Finish("infantry order interrupted or native waypoint creation failed"); return; }
|
|
m_Order = null; m_State = 5; Audit("infantry received reported rendezvous; native movement and physical transfer required");
|
|
}
|
|
if (m_State == 5) Transfer(now);
|
|
}
|
|
string Status() { return string.Format("Infantry supply: state=%1 trips=%2 moved=%3 stock=%4 spent=%5; %6", m_State, m_Trip, m_Delivered, m_Stock.Count(), m_Spent.Count(), m_Reason); }
|
|
void Stop()
|
|
{
|
|
if (m_Stopped) return;
|
|
Finish("service stopped; original forces and all remaining cargo retained"); m_Stopped = true;
|
|
}
|
|
}
|