aussie/EscapistsReintroduced
1
0
Fork 0
forked from escapists/EscapistsReintroduced
Code Pull Requests Activity

Capture current mission, AI, map and administration development

Browse Source 
Include the current addon, terrain integrations, tools, regression tests and recorded development evidence.
This commit is contained in:
jakub
2026-10-13 22:52:53 +02:00
parent a951a96edc
commit 6a667d8deb
8104 changed files with 2124945 additions and 2061 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/evidence/resupply-compatible-stock-2026-10-03/tested/addons/core/Scripts/Game/ERR/10_AI/ERR_InfantryResupply.c
+565
View File
@@ -0,0 +1,565 @@
// 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;
}
// Only positively sampled reloadable magazine-well muzzles establish launcher demand.
static bool LauncherNeed(ERR_HQWatchEntry entry, float now)
{
return Fresh(entry, now) && entry.AmmoState && entry.AmmoState.Valid(entry.Count)
&& entry.AmmoState.LauncherComplete && entry.AmmoState.Members == entry.Count
&& entry.AmmoState.LauncherMuzzles > 0
&& entry.AmmoState.LauncherRounds == 0 && entry.AmmoState.LauncherChambers == 0;
}
static bool LauncherPair(ERR_HQWatchEntry recipient, ERR_HQWatchEntry donor, float now)
{
return LauncherNeed(recipient, now) && Fresh(donor, now) && recipient.SourceId != donor.SourceId
&& vector.DistanceXZ(recipient.Position, donor.Position) <= 200;
}
static bool MinePair(ERR_HQWatchEntry recipient, ERR_HQWatchEntry donor, float now)
{
return Fresh(recipient, now) && Fresh(donor, now) && recipient.SourceId != donor.SourceId
&& recipient.AmmoState && recipient.AmmoState.Valid(recipient.Count)
&& recipient.AmmoState.MineComplete && recipient.AmmoState.MineMembers == recipient.Count
&& recipient.AmmoState.ReadyMines <= 1 && vector.DistanceXZ(recipient.Position, donor.Position) <= 200;
}
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 int m_ConvoySlot = -1;
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_MineStock = {};
protected ref ERR_ConvoyMineStock m_MineBatch;
protected bool m_MineStockCaptured;
protected bool m_MineTrip;
protected bool m_LauncherTrip;
protected int m_MineRecipientSlot = -1;
protected bool m_EmptyMineReplacement;
protected int m_MinesDelivered;
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 ref ERR_InfantryMineTransfer m_MineMove;
protected ref ERR_MountedResupply m_Mounted;
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, 7 unresolved item custody
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_StockDeadline = -1;
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; }
// Bind before startup; every coordinator retains its exact finite convoy identity.
bool Bind(ERR_ConvoyTask task, int slot, map<string, int> consumed, map<string, float> nextAttempt)
{
if (!task || !consumed || !nextAttempt || !m_HQ || !m_HQ.Convoys() || slot < 0 || slot >= 20
|| slot >= m_HQ.Convoys().Count() || m_HQ.Convoys().At(slot) != task) return false;
if (m_Stopped || m_Convoy || m_ConvoySlot >= 0 || m_State != 0 || m_Trip != 0 || m_NextTick != 0
|| m_StockDeadline >= 0 || !m_Stock.IsEmpty() || m_Move || m_Truck) return false;
m_Convoy = task; m_ConvoySlot = slot; m_Consumed = consumed; m_NextAttempt = nextAttempt;
return true;
}
ERR_ConvoyTask Task() { return m_Convoy; }
int State()
{
if (m_Mounted && m_Mounted.Busy()) return 6;
return m_State;
}
ERR_MountedResupply Mounted() { return m_Mounted; }
bool Unresolved() { return (m_Move && m_Move.Unresolved()) || (m_MineMove && m_MineMove.Unresolved()) || (m_Mounted && m_Mounted.Unresolved()); }
protected void PollTransfers(float now)
{
if (m_Mounted) m_Mounted.Tick(now);
if (m_Move && !m_Move.Unresolved() && (m_State <= 1 || (m_State == 7 && m_LauncherTrip)))
{
m_Move = null;
if (m_State == 7) Finish("launcher custody settled; original claims released without retry or refund");
}
if (m_MineMove && !m_MineMove.Unresolved() && (m_State <= 1 || m_State == 7))
{
m_MineMove = null;
if (m_State == 7) Finish("mine custody settled; original claims released without retry or refund");
}
}
int Delivered() { return m_Delivered; }
int MinesDelivered() { return m_MinesDelivered; }
int StockCount() { return m_Stock.Count(); }
// Admission uses the existing array object so an already-created mounted
// coordinator observes this exact finite addition without a replacement ledger.
protected int m_DepotImports;
bool DepotCurrent()
{
return Current() && m_State == 1 && !m_Move && !m_MineMove && !Unresolved()
&& (!m_Mounted || !m_Mounted.Busy()) && TruckValid(true);
}
bool DepotAvailable() { return DepotCurrent() && m_Stock.Count() < 96 && m_Spent.Count() < 96; }
bool DepotNeeded()
{
if (!DepotAvailable()) return false;
int committed;
foreach (IEntity item : m_Spent)
if (item && m_Stock.Contains(item)) committed++;
return committed > m_DepotImports;
}
ERR_ConvoyVehicle DepotTruck()
{
if (!DepotCurrent()) return null;
return m_Truck;
}
bool AdmitDepot(ERR_GroundDepotLoading job, IEntity item)
{
if (!job || !DepotAvailable() || !item || m_Stock.Contains(item) || m_Spent.Contains(item)) return false;
if (!job.DeliveredTo(this, item) || !Contains(m_Truck.Entity, item)) return false;
m_Stock.Insert(item); m_DepotImports++; Audit("one exact finite camp magazine admitted after proved physical courier delivery");
return true;
}
protected void Audit(string reason)
{
if (m_MineTrip) reason = "mine top-up: " + reason;
if (m_LauncherTrip) reason = "depleted launcher magazine: " + reason;
m_Reason = reason;
m_HQ.Journal().Write("INFANTRY SUPPLY", string.Format("convoy-slot=%1 trip=%2 state=%3 moved=%4 spent=%5/%6; %7", m_ConvoySlot, 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 ConvoyCurrent()
{
if (!m_HQ || !m_Convoy) return false;
if (m_ConvoySlot < 0) return m_HQ.ConvoyTask() == m_Convoy;
return m_HQ.Convoys() && m_ConvoySlot < m_HQ.Convoys().Count() && m_HQ.Convoys().At(m_ConvoySlot) == m_Convoy;
}
protected bool TruckValid(bool allowArrived = false)
{
if (!m_Convoy || m_Convoy.Stopped || !m_Convoy.Ready || !m_Convoy.Receipt || !m_Convoy.Receipt.Consumed
|| !ConvoyCurrent() || 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 && !allowArrived)
|| !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)
{
if (!m_Convoy) m_Convoy = m_HQ.ConvoyTask();
if (m_Convoy && !ConvoyCurrent()) { Stop(); return; }
if (!m_Convoy || !m_Convoy.Ready || m_Convoy.Vehicles.Count() != 6) return;
m_Truck = m_Convoy.Vehicles[1];
if (!TruckValid()) { Stop(); return; }
// Cargo has a later, separately bounded lifecycle than native crew admission.
// Supply convoys first request faction weapons, then their matching magazines.
if (m_StockDeadline < 0) m_StockDeadline = now + 90000;
if (now >= m_StockDeadline) { Stop(); return; }
if (!m_Convoy.CargoIssued) return;
ERR_SupplyConvoyTask supply = ERR_SupplyConvoyTask.Cast(m_Convoy);
if (supply && !supply.MagazinesIssued) return;
if (supply) m_MineBatch = supply.MineStock;
foreach (ERR_ConvoyCargoCallback operation : m_Convoy.Cargo)
if (!operation.Finished) 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.FindComponent(BaseMagazineComponent)) continue;
if (m_Stock.Count() >= 96) { 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, bool mineTrip = false, bool launcherTrip = false)
{
if (!Current() || m_State != 1 || m_Move || m_MineMove || (m_Mounted && m_Mounted.Busy()) || m_Trip >= 128 || !TruckValid()) return false;
if ((mineTrip && launcherTrip) || 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 (mineTrip)
{
if (!ERR_InfantryResupplyRules.MinePair(demand, donorStatus, now)) return false;
// Empty reports authorize only an original startup-designated engineer.
// This reads retained entitlement, never live positions/inventory for planning.
if (demand.AmmoState.ReadyMines == 0)
{
bool designated;
for (int member = 0; member < recipient.StatusSampler.InitialStrength() && member < 32; member++)
{
IEntity original = recipient.StatusSampler.InitialMember(member);
if (original && recipient.StatusSampler.CanAttribute(member, original)
&& m_HQ.MineSupplyReady(recipient.Group, original, true)) { designated = true; break; }
}
if (!designated) return false;
}
}
else if (launcherTrip)
{
if (!ERR_InfantryResupplyRules.LauncherPair(demand, donorStatus, now)) return false;
}
else 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;
if (mineTrip)
{
if (!CaptureMines()) return false;
foreach (IEntity mine : m_MineStock)
if (ERR_InfantryMineTransfer.ReadyMine(mine) && !m_Spent.Contains(mine) && Contains(m_Truck.Entity, mine)) { available = true; break; }
}
else if (launcherTrip) available = LauncherStock(recipient);
else available = CompatibleStock(recipient, false);
if (m_Spent.Count() >= 96) return false;
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 slot = m_ConvoySlot;
if (slot < 0) slot = 0; // Isolated legacy fixture uses the first convoy's range.
int token = 100000 + slot * 128 + m_Trip + 1;
if (!m_HQ.ReserveLogistics(recipient.Group, token)) { m_Recipient = null; m_Donor = null; return false; }
m_MineTrip = mineTrip; m_LauncherTrip = launcherTrip; m_MineRecipientSlot = -1; m_Receiving = null; m_EmptyMineReplacement = 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;
string purpose = "stop existing ammo truck and report position";
if (mineTrip) purpose += "; one finite PMN4 top-up for an existing carrier";
if (launcherTrip) purpose += "; finite compatible magazine for a reported depleted launcher";
m_Order = m_HQ.Downlink(donor.Group, "INFANTRY SUPPLY HOLD", purpose, m_ReportId);
if (!m_Order) Finish("truck radio downlink unavailable");
else Audit("existing patrol reserved; truck hold awaits radio delivery");
return true;
}
// Optional mine startup must never delay normal magazine readiness. Pin the
// original batch during Stock(), then copy its closed exact identities once.
protected bool CaptureMines()
{
ERR_SupplyConvoyTask supply = ERR_SupplyConvoyTask.Cast(m_Convoy);
if (!supply || !m_MineBatch || supply.MineStock != m_MineBatch || !m_MineBatch.Complete()) return false;
if (m_MineStockCaptured) return !m_MineStock.IsEmpty();
m_MineStockCaptured = true;
int count = m_MineBatch.Count();
if (count < 0 || count > 2) return false;
for (int index = 0; index < count; index++)
{
IEntity item = m_MineBatch.At(index);
if (item && !m_MineStock.Contains(item)) m_MineStock.Insert(item);
}
return true;
}
// Compatibility-only preflight of original own carriers; HQ still uses the
// delivered report for demand and positions. No item is reserved or moved here.
protected bool CompatibleStock(ERR_HQUnit recipient, bool launcherMagazine)
{
if (!recipient || !recipient.StatusSampler || m_Stock.Count() > 96) return false;
int strength = recipient.StatusSampler.InitialStrength();
if (strength < 1 || strength > 32) return false;
int checks;
foreach (IEntity magazine : m_Stock)
{
if (!magazine || m_Spent.Contains(magazine) || !Contains(m_Truck.Entity, magazine)) continue;
for (int slot = 0; slot < strength; slot++)
{
if (++checks > 96 * 32) return false;
IEntity actor = recipient.StatusSampler.InitialMember(slot);
if (!actor || !recipient.StatusSampler.CanAttribute(slot, actor) || !ERR_Actors.CanFight(actor)) continue;
if (ERR_InfantryAmmoTransfer.Compatible(actor, magazine, launcherMagazine)) return true;
}
}
return false;
}
protected bool LauncherStock(ERR_HQUnit recipient)
{
return CompatibleStock(recipient, true);
}
bool TryPlanLauncher(ERR_HQUnit recipient, ERR_HQUnit donor, ERR_HQWatchEntry demand, ERR_HQWatchEntry donorStatus, float now)
{
return TryPlan(recipient, donor, demand, donorStatus, now, false, true);
}
bool TryPlanMines(ERR_HQUnit recipient, ERR_HQUnit donor, ERR_HQWatchEntry demand, ERR_HQWatchEntry donorStatus, float now)
{
return TryPlan(recipient, donor, demand, donorStatus, now, true);
}
// Share exact frozen inventory identities and global radio replay state.
bool TryPlanMounted(ERR_HQUnit recipient, ERR_HQUnit donor, ERR_HQWatchEntry demand, ERR_HQWatchEntry donorStatus, float now)
{
if (!Current() || m_State != 1 || m_Move || m_MineMove || m_ConvoySlot < 0 || !TruckValid(true)) return false;
if (m_Mounted && m_Mounted.Busy()) return false;
if (!m_Mounted) m_Mounted = new ERR_MountedResupply(m_HQ, m_Mode, m_Convoy, m_ConvoySlot, m_Stock, m_Spent, m_Consumed, m_NextAttempt);
return m_Mounted.Begin(recipient, donor, demand, donorStatus, now);
}
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;
// The reported rendezvous is 3 m from the donor report. A 2 m move
// radius allowed arrival 5 m away, beyond the transfer's physical reach.
m_MoveWaypoint.SetCompletionRadius(0.5); m_HoldWaypoint.SetCompletionRadius(0.5);
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();
if (m_MineMove) m_MineMove.Stop();
ClearWaypoints();
m_Order = null;
// A late native move must not race another truck's newer report. Retain both
// exact claims until this one submitted identity proves custody or deletion.
if ((m_MineMove && m_MineMove.Unresolved()) || (m_LauncherTrip && m_Move && m_Move.Unresolved())) { m_State = 7; return; }
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; m_MineTrip = false; m_LauncherTrip = false; m_MineRecipientSlot = -1;
}
protected void TransferMine(float now)
{
if (m_MineMove)
{
int result = m_MineMove.Tick(now);
if (result == 0) return;
if (result < 0) { Finish("native mine transfer failed or expired; exact submitted identity stays spent"); return; }
m_MineMove = null; m_MinesDelivered++;
Finish("one exact finite PMN4 confirmed in the original carrier inventory"); return;
}
if (!m_Receiving)
{
int strength = m_Recipient.StatusSampler.InitialStrength();
for (int slot = 0; slot < strength && slot < 32; slot++)
{
IEntity actor = m_Recipient.StatusSampler.InitialMember(slot);
if (!actor || !m_Members.Contains(actor) || !m_Recipient.StatusSampler.CanAttribute(slot, actor, false)) continue;
if (!ERR_Actors.CanFight(actor) || vector.DistanceXZ(actor.GetOrigin(), m_Truck.Entity.GetOrigin()) > 4) continue;
if (!m_HQ.MineSupplyReady(m_Recipient.Group, actor)) continue;
IEntity carried;
int count = ERR_InfantryMineTransfer.CarriedCount(actor, m_Recipient.Group, carried);
if (count != 1 && (count != 0 || !m_HQ.MineSupplyReady(m_Recipient.Group, actor, true))) continue;
m_EmptyMineReplacement = count == 0;
m_Receiving = actor; m_MineRecipientSlot = slot; break;
}
if (!m_Receiving) return;
}
if (!m_HQ.MineSupplyReady(m_Recipient.Group, m_Receiving, m_EmptyMineReplacement)) return;
IEntity carried;
int count = ERR_InfantryMineTransfer.CarriedCount(m_Receiving, m_Recipient.Group, carried);
if (!m_Recipient.StatusSampler.CanAttribute(m_MineRecipientSlot, m_Receiving, false)
|| (m_EmptyMineReplacement && count != 0) || (!m_EmptyMineReplacement && count != 1))
{ Finish("original mine recipient lost or its pinned zero/one stock changed"); return; }
foreach (IEntity mine : m_MineStock)
{
if (!ERR_InfantryMineTransfer.ReadyMine(mine) || m_Spent.Contains(mine) || !Contains(m_Truck.Entity, mine)) continue;
ERR_FiniteMagazineReservation reservation = new ERR_FiniteMagazineReservation(m_MineStock, m_Spent, mine);
if (!reservation.Reserve()) continue;
m_MineMove = new ERR_InfantryMineTransfer(m_Mode, m_Truck.Entity, m_Truck.Group, m_Receiving, m_Recipient.Group,
mine, reservation, m_Recipient.StatusSampler, m_MineRecipientSlot, m_EmptyMineReplacement);
m_MineMove.Tick(now);
// The leaf commits before the one native move. Only an unsubmitted refusal
// may release its tentative claim while the same carrier approaches/retries.
if (m_MineMove.Submitted()) return;
reservation.ReleaseUnsubmitted(); m_MineMove = null;
break;
}
}
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 (m_LauncherTrip)
{
if (!local.Valid(1) || !local.LauncherComplete || local.Members != 1 || local.LauncherMuzzles <= 0
|| local.LauncherRounds != 0 || local.LauncherChambers != 0) continue;
}
else 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, m_LauncherTrip)) continue;
ERR_FiniteMagazineReservation reservation = new ERR_FiniteMagazineReservation(m_Stock, m_Spent, magazine);
if (!reservation.Reserve()) continue;
m_Receiving = actor;
m_Move = new ERR_InfantryAmmoTransfer(m_Mode, m_Truck.Entity, m_Truck.Group, actor, m_Recipient.Group, magazine, !m_LauncherTrip, m_LauncherTrip);
m_Move.Tick(now);
if (m_Move.Submitted()) { reservation.Commit(); return; }
// No native operation exists yet: approach geometry, stopped state or
// capacity may improve while the same bounded rendezvous remains valid.
// Keep every submitted identity spent, including a synchronous rejection.
reservation.ReleaseUnsubmitted(); m_Move = null; m_Receiving = null;
break; // At most one unsubmitted preflight per member on this slow tick.
}
}
}
void Tick(float now)
{
if (!ERR_ForceRules.Finite(now) || now < 0) return;
// Stopped services retain uncertain leaf refs until exact late proof settles.
if (m_Stopped) { PollTransfers(now); return; }
if (!Current() || now < m_NextTick) return;
m_NextTick = now + 1000;
PollTransfers(now);
if (m_Mounted && m_Mounted.Busy()) return;
if (m_State == 7) return;
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)
{
if (m_MineTrip) TransferMine(now);
else Transfer(now);
}
}
string Status()
{
string detail = string.Format("Ground supply: state=%1 trips=%2 infantry moved=%3 stock=%4 spent=%5", State(), m_Trip, m_Delivered, m_Stock.Count(), m_Spent.Count());
return detail + string.Format("; mines moved=%1 initial=%2; %3", m_MinesDelivered, m_MineStock.Count(), m_Reason);
}
void Stop()
{
if (m_Stopped) return;
if (m_Mounted) m_Mounted.Stop();
Finish("service stopped; original forces and all remaining cargo retained"); m_Stopped = true;
}
}
docs/evidence/resupply-compatible-stock-2026-10-03/tested/tests/test_infantry_resupply_planning.py
+290
View File
@@ -0,0 +1,290 @@
"""Execute real finite-stock/planning/reservation bodies; native inventory/group APIs are doubles."""
import os,re
from pathlib import Path
from policy_harness import ROOT,body,run
P=Path(os.environ.get('ERR_INFANTRY_RESUPPLY_SOURCE',ROOT/'addons/core/Scripts/Game/ERR/10_AI/ERR_InfantryResupply.c'))
A=Path(os.environ.get('ERR_INFANTRY_TRANSFER_SOURCE',ROOT/'addons/core/Scripts/Game/ERR/10_AI/ERR_InfantryAmmoTransfer.c'))
I=ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_Inventory.c'
H=Path(os.environ.get('ERR_HQ_SOURCE',ROOT/'addons/core/Scripts/Game/ERR/10_AI/ERR_HQ.c'))
def cpp(s):
s=s.replace('protected ','').replace('notnull ','').replace('null','nullptr')
s=s.replace('map<string, int>', 'Map<int>*').replace('map<string, float>', 'Map<float>*')
s=s.replace('array<IEntity> items = {};','Array<IEntity> items;').replace('array<IEntity> raw = {};','Array<IEntity> raw;').replace('array<AIAgent> agents = {};','Array<AIAgent> agents;')
s=s.replace('out array<IEntity> items','Array<IEntity>& items').replace('array<IEntity> items','Array<IEntity>& items')
s=re.sub(r'foreach \((\w+) (\w+) : ([^)]+)\)',r'for (\1 \2 : \3)',s)
for typ in ('InventoryStorageManagerComponent','ERR_ForceRecord','ERR_SupplyConvoyTask'):
s=re.sub(r'\b'+typ+r' (?=\w)',typ+'* ',s)
for name in ('ERR_ForceRules','ERR_InfantryResupplyRules','ERR_InfantryMineTransfer','ERR_InfantryAmmoTransfer','ERR_ConvoyRules','ERR_ForceKind','ERR_ConvoyResources','ERR_Inventory','ERR_Actors','SCR_FactionManager','CompartmentAccessComponent','Replication','Math'):
s=s.replace(name+'.',name+'::')
s=s.replace('ERR_SupplyConvoyTask.Cast','ERR_SupplyConvoyTask::Cast').replace('FindComponent(BaseMagazineComponent)','HasMagazine()')
s=s.replace('vector.DistanceXZ','Vec::DistanceXZ').replace('InventoryStorageManagerComponent.Cast','InventoryStorageManagerComponent::Cast').replace('FindComponent(InventoryStorageManagerComponent)','FindComponent()')
for name in ('m_Mode','m_HQ','m_Convoy','m_Truck','m_Recipient','m_Donor','m_Move','m_MineMove','m_MineBatch','m_Mounted','recipient','donor','demand','donorStatus','entry','operation','inventory','item','owner','record','actor','agent','unit','m_MoveWaypoint','m_HoldWaypoint','magazine','supply','m_Consumed','m_NextAttempt'):
s=s.replace(name+'.',name+'->')
for name in ('Receipt','Entity','Group','Utility','StatusSampler','AmmoState','Combat','m_Perception'):
s=s.replace(name+'.',name+'->')
for name in ('Forces()','GetPrefabData()','Convoys()'):s=s.replace(name+'.',name+'->')
s=s.replace('ERR_SupplyConvoyTask* supply', 'Convoy* supply')
s=s.replace('bool designated;','bool designated=false;')
s=s.replace('int checks;', 'int checks=0;')
s=s.replace('bool available;','bool available=false;').replace('bool living;','bool living=false;')
return s
rules='\n'.join(cpp(body(P,x)) for x in ('static bool Fresh(', 'static bool Need(', 'static bool Pair(', 'static bool MinePair(', 'static bool LauncherNeed(', 'static bool LauncherPair('))
stock_method=('protected bool CompatibleStock(',) if 'protected bool CompatibleStock(' in P.read_text() else ()
methods='\n'.join(cpp(body(P,x)) for x in stock_method+('bool Bind(', 'ERR_ConvoyTask Task(', 'protected bool ConvoyCurrent(', 'protected bool Contains(', 'protected bool TruckValid(', 'protected bool Quiet(', 'protected bool Roster(', 'protected void Stock(', 'protected bool CaptureMines(', 'protected bool LauncherStock(', 'bool TryPlanLauncher(', 'bool TryPlanMines(', 'bool TryPlan(', 'protected void ClearWaypoints(', 'protected void Finish(', 'void Stop('))
reserve=cpp(body(H,'bool ReserveLogistics('))+cpp(body(H,'void ReleaseLogistics('))
unique=cpp(body(I,'static int AppendUnique('))+cpp(body(I,'static int Items('))
compatible=body(A,'static bool Compatible(')
for a,b in {
'BaseMagazineComponent.Cast(exactMagazine.FindComponent(BaseMagazineComponent))':'exactMagazine->ammoComp',
'BaseWeaponManagerComponent.Cast(actor.FindComponent(BaseWeaponManagerComponent))':'actor->weapons',
'BaseWeaponComponent.Cast(rifle.FindComponent(BaseWeaponComponent))':'rifle->weapon',
'InventoryItemComponent.Cast(loaded.GetOwner().FindComponent(InventoryItemComponent))':'loaded->GetOwner()->item',
'SCR_MuzzleInMagComponent.Cast(muzzle)':'(muzzle->inMag ? muzzle : nullptr)',
}.items():compatible=compatible.replace(a,b)
compatible=compatible.replace('array<','Array<').replace('foreach (','for (').replace('EWeaponType kind','int kind').replace('EMuzzleType muzzleKind','int muzzleKind')
for a in ['EWeaponType','EMuzzleType']:compatible=compatible.replace(a+'.',a+'::')
for a in ['magazine','manager','weapon','muzzle','reloadable','loaded','loadedItem','loadedSlot']:compatible=compatible.replace(a+'.',a+'->')
compatible=compatible.replace('GetMagazineWell().','GetMagazineWell()->')
run(r'''
#include <cassert>
#include <string>
#include <vector>
#include <array>
#include <map>
#include <algorithm>
#include <cmath>
using string=std::string;
template<class T>struct Array:std::vector<T>{using std::vector<T>::vector;int Count(){return this->size();}bool IsEmpty(){return this->empty();}void Clear(){this->clear();}void Insert(T v){this->push_back(v);}bool Contains(T v){return std::find(this->begin(),this->end(),v)!=this->end();}};
template<class V>struct Map{std::map<string,V>data;V Get(string k){auto it=data.find(k);return it==data.end()?V{}:it->second;}void Set(string k,V v){data[k]=v;}};
struct Vec{float x=0,y=0,z=0;static float DistanceXZ(Vec a,Vec b){return std::hypot(a.x-b.x,a.z-b.z);}};
struct ERR_ForceRules{static bool Finite(float f){return std::isfinite(f);}static bool FiniteVector(Vec v){return Finite(v.x)&&Finite(v.y)&&Finite(v.z);}};
struct Math{static float Min(float a,float b){return std::min(a,b);}};
struct Replication{static inline bool server=true;static bool IsServer(){return server;}};
struct Entity;using IEntity=Entity*;
struct Magazine;struct Manager;struct Weapon;struct Muzzle;struct Item;struct Slot;
using BaseMagazineComponent=Magazine*;using BaseWeaponManagerComponent=Manager*;using BaseWeaponComponent=Weapon*;using BaseMuzzleComponent=Muzzle*;using SCR_MuzzleInMagComponent=Muzzle*;using InventoryItemComponent=Item*;using InventoryStorageSlot=Slot*;
struct EWeaponType{static const int WT_RIFLE=1,WT_SNIPERRIFLE=2,WT_MACHINEGUN=3,WT_HANDGUN=4,WT_GRENADELAUNCHER=5,WT_ROCKETLAUNCHER=6;};
struct EMuzzleType{static const int MT_BaseMuzzle=0,MT_UGLMuzzle=1,MT_RPGMuzzle=2;};
struct Well{int type=1,parent=0;int Type(){return type;}bool IsInherited(int t){return type==t||parent==t;}};
struct Magazine{IEntity owner=nullptr;Well*well=nullptr;int rounds=30,capacity=30;bool used=false;IEntity GetOwner(){return owner;}Well*GetMagazineWell(){return well;}int GetAmmoCount(){return rounds;}int GetMaxAmmoCount(){return capacity;}bool IsUsed(){return used;}};
struct Muzzle{bool inMag=true,canReload=true,disposable=false;Magazine*loaded=nullptr;Well*well=nullptr;int kind=0;bool CanBeReloaded(){return canReload;}bool IsDisposable(){return disposable;}Magazine*GetMagazine(){return loaded;}Well*GetMagazineWell(){return well;}int GetMuzzleType(){return kind;}};
struct Weapon{IEntity owner=nullptr;Array<Muzzle*>muzzles;int kind=1;IEntity GetOwner(){return owner;}int GetWeaponType(){return kind;}void GetMuzzlesList(Array<Muzzle*>&a){a=muzzles;}};
struct Manager{Array<IEntity>weapons;void GetWeaponsList(Array<IEntity>&a){a=weapons;}};
struct Slot{Muzzle*container=nullptr;IEntity attached=nullptr;Muzzle*GetParentContainer(){return container;}IEntity GetAttachedEntity(){return attached;}};
struct Item{Slot*slot=nullptr;Slot*GetParentSlot(){return slot;}};
struct InventoryStorageManagerComponent{Array<IEntity>items;void GetItems(Array<IEntity>& out){out=items;}static auto Cast(InventoryStorageManagerComponent* p){return p;}};
struct Prefab{string name="magazine";string GetPrefabName(){return name;}};
struct Group;using SCR_AIGroup=Group*;
struct Entity{Magazine*ammoComp=nullptr;Manager*weapons=nullptr;Weapon*weapon=nullptr;Item*item=nullptr;IEntity parent=nullptr;Prefab prefab;bool readyMine=false,magazine=true,hasPrefab=true,alive=true,player=false,fight=true,aboard=false,captured=false,released=false;int faction=1;Group* group=nullptr;InventoryStorageManagerComponent* inventory=nullptr;bool HasMagazine(){return magazine;}Prefab* GetPrefabData(){return hasPrefab?&prefab:nullptr;}InventoryStorageManagerComponent* FindComponent(){return inventory;}};
struct Agent{IEntity actor;IEntity GetControlledEntity(){return actor;}};using AIAgent=Agent*;
struct Waypoint{};
struct Group{Array<AIAgent>agents;bool slave=false;int players=0,faction=1;bool IsSlave(){return slave;}int GetPlayerCount(bool){return players;}int GetFaction(){return faction;}void GetAgents(Array<AIAgent>& out){out=agents;}void RemoveWaypoint(Waypoint*){}};
struct ERR_Actors{static bool Alive(IEntity a){return a&&a->alive;}static bool Player(IEntity a){return a&&a->player;}static SCR_AIGroup Group(IEntity a){return a->group;}static bool CanFight(IEntity a){return a&&a->alive&&a->fight;}static void DeleteSpawned(Waypoint*){}};
struct SCR_FactionManager{static int SGetFaction(IEntity a){return a->faction;}};
struct CompartmentAccessComponent{static bool GetVehicleIn(IEntity a){return a->aboard;}};
struct ERR_Inventory{
'''+unique+r'''
};
struct Ammo{bool LauncherComplete=true;int LauncherMuzzles=1,LauncherMagazines=1,LauncherRounds=0,LauncherChambers=0;bool MineComplete=true;int MineMembers=2,ReadyMines=1;bool Complete=true;int Members=2,SmallArmsMuzzles=2,SmallArmsRounds=60,SmallArmsChambers=0;bool Valid(int n){return Members==n;}};
struct Entry{bool Closed=false;int Count=2,Fit=2,MessageId=1;float ObservedAt=0;Vec Position;string SourceId;Ammo* AmmoState=nullptr;};using ERR_HQWatchEntry=Entry*;
struct ERR_InfantryResupplyRules{
'''+rules+r'''
};
namespace ERR_ForceKind{const int CONVOY=3;}
struct ERR_ForceRecord{bool Physical=true,Eliminated=false;int Kind=3,Id=2;};
struct Ledger{Group* owned=nullptr;ERR_ForceRecord record;ERR_ForceRecord* FindGroup(Group* g){return g==owned?&record:nullptr;}};
struct Mode{Ledger ledger;Ledger* Forces(){return &ledger;}int EnemyFaction(){return 1;}};
struct Perception{Array<int>m_aTargets;};
struct Utility{Perception* m_Perception=nullptr;};
struct Sampler{Group* group;Array<IEntity>original;int InitialStrength(){return original.Count();}IEntity InitialMember(int i){return original[i];}bool CanAttribute(int i,IEntity a){return original[i]==a&&!a->released;}bool OwnsRoster(Group* g){return g==group;}};
struct Unit{struct Group* Group=nullptr;struct Utility* Utility=nullptr;Sampler* StatusSampler=nullptr;string ForceSourceId;bool HomeGuard=false,eligible=true;int LogisticsReservation=0;void* Downlink=nullptr;void* PendingOrder=nullptr;void* PendingConvoyOrder=nullptr;void* Radio=this;void* Assignment=nullptr;void* Waypoint=nullptr;bool Eligible(Mode*){return eligible&&LogisticsReservation==0;}};using ERR_HQUnit=Unit*;
struct Combat{bool Held=false;};
struct Truck{int Index=1,SupplyToken=0;bool Registered=true,Released=false,Arrived=false,SupplyHeld=false,crew=true;struct Entity* Entity=nullptr;struct Group* Group=nullptr;struct Combat* Combat=nullptr;bool CrewValid(Mode*){return crew;}};
struct Receipt{bool Consumed=true;Array<int>Records={1,2,3,4,5,6};};
struct Cargo{bool Finished=true;};using ERR_ConvoyCargoCallback=Cargo*;
struct MineBatch{bool complete=true;Array<IEntity>items;bool Complete(){return complete;}int Count(){return items.Count();}IEntity At(int i){return items[i];}};
struct Convoy{MineBatch*MineStock=nullptr;bool supply=false,MagazinesIssued=true,CargoIssued=true,Stopped=false,Ready=true;struct Receipt* Receipt=nullptr;Array<Truck*>Vehicles;Array<struct Cargo*>Cargo;float Deadline=30000;};
using ERR_ConvoyTask=Convoy*;
struct ConvoyService{Array<Convoy*>tasks;int Count(){return tasks.Count();}Convoy* At(int index){return index>=0&&index<Count()?tasks[index]:nullptr;}};
struct ERR_SupplyConvoyTask:Convoy{static Convoy* Cast(Convoy* task){return task&&task->supply?task:nullptr;}};
struct ERR_ConvoyRules{static bool Captured(Entity* e,Group*){return e->captured;}};
struct ERR_ConvoyResources{static string Magazine(){return "magazine";}};
struct ERR_InfantryMineTransfer{static bool ReadyMine(IEntity x){return x&&x->readyMine;}};
struct Route{};struct Leaf{bool unresolved=false;void Stop(){}bool Unresolved(){return unresolved;}};struct Mounted{bool busy=false;bool Busy(){return busy;}void Stop(){}};
struct HQ{Mode* m_Mode;Array<ERR_HQUnit>m_Units;Convoy* convoy=nullptr;ConvoyService convoys;ConvoyService* Convoys(){return &convoys;}Route route;bool active=true,routeAvailable=true;int downlinks=0;bool MissionActive(){return active;}Convoy* ConvoyTask(){return convoy;}
bool designated=false;bool MineSupplyReady(Group*,IEntity,bool replacement=false){return !replacement||designated;}
Route* Downlink(Group*,string,string,int){downlinks++;return routeAvailable?&route:nullptr;}
'''+reserve+r'''
};
struct ERR_InfantryAmmoTransfer{static bool StoredUnder(IEntity item,IEntity actor){return item&&item->parent==actor;}
'''+compatible+r'''
};
struct Service{HQ* m_HQ;Mode* m_Mode;Convoy* m_Convoy=nullptr;Truck* m_Truck=nullptr;Unit* m_Recipient=nullptr;Unit* m_Donor=nullptr;Leaf* m_Move=nullptr;Leaf*m_MineMove=nullptr;MineBatch*m_MineBatch=nullptr;bool m_LauncherTrip=false,m_MineTrip=false,m_MineStockCaptured=false,m_EmptyMineReplacement=false;int m_MineRecipientSlot=-1;Mounted*m_Mounted=nullptr;Route* m_Order=nullptr;IEntity m_Receiving=nullptr;
Array<IEntity>m_Stock,m_MineStock,m_Spent,m_Members,m_Served;Map<int>*m_Consumed=new Map<int>();Map<float>*m_NextAttempt=new Map<float>();int m_ConvoySlot=-1;float m_NextTick=0;int m_State=0,m_Trip=0,m_Token=0,m_ReportId=0,m_TripDelivered=0;float m_Deadline=0,m_StockDeadline=-1;bool m_Stopped=false;
Waypoint* m_MoveWaypoint=nullptr;Waypoint* m_HoldWaypoint=nullptr;string reason;bool Current(){return !m_Stopped&&Replication::IsServer()&&m_HQ->active;}void Audit(string why){reason=why;}
'''+methods+r'''
};
struct Fixture{Mode mode;HQ hq;Service s;InventoryStorageManagerComponent inventory;Entity vehicle;std::array<Entity,140>items;std::array<Magazine,140>magazines;Entity rifle,launcher;Manager weapons;Weapon rifleWeapon,launcherWeapon;Muzzle rifleMuzzle,launcherMuzzle;Well well,wrongWell{2,0};Entity one,two;Agent a{&one},b{&two};Group recipients,donors;Utility recipientUtility,donorUtility;Sampler sampler;Unit recipient,donor;Combat combat;Truck truck;Receipt receipt;Cargo cargo;Convoy convoy;Ammo ammo;Entry demand,donorStatus;
Fixture():sampler{&recipients,{&one,&two}}{
hq.m_Mode=&mode;hq.convoy=&convoy;hq.convoys.tasks={&convoy};s.m_HQ=&hq;s.m_Mode=&mode;
one.weapons=&weapons;two.weapons=&weapons;weapons.weapons={&rifle,&launcher};rifle.weapon=&rifleWeapon;rifleWeapon.owner=&rifle;rifleWeapon.muzzles={&rifleMuzzle};rifleMuzzle.well=&well;
launcher.weapon=&launcherWeapon;launcherWeapon.owner=&launcher;launcherWeapon.kind=EWeaponType::WT_ROCKETLAUNCHER;launcherWeapon.muzzles={&launcherMuzzle};launcherMuzzle.well=&well;launcherMuzzle.kind=EMuzzleType::MT_RPGMuzzle;launcher.parent=&one;
for(int i=0;i<140;i++){items[i].ammoComp=&magazines[i];magazines[i].owner=&items[i];magazines[i].well=&well;}
vehicle.inventory=&inventory;vehicle.group=&donors;truck.Entity=&vehicle;truck.Group=&donors;truck.Combat=&combat;
mode.ledger.owned=&donors;convoy.Receipt=&receipt;convoy.Vehicles={&truck,&truck,&truck,&truck,&truck,&truck};convoy.Cargo={&cargo};
one.group=&recipients;two.group=&recipients;recipients.agents={&a,&b};recipient.Group=&recipients;recipient.Utility=&recipientUtility;recipient.StatusSampler=&sampler;recipient.ForceSourceId="recipient";
donor.Group=&donors;donor.Utility=&donorUtility;donor.ForceSourceId="donor";hq.m_Units={&recipient,&donor};
demand.SourceId="recipient";demand.AmmoState=&ammo;donorStatus.SourceId="donor";donorStatus.AmmoState=&ammo;
for(int i=0;i<48;i++)inventory.items.Insert(&items[i]);
}
bool Plan(float now=0){return s.TryPlan(&recipient,&donor,&demand,&donorStatus,now);}
void Refresh(float now,int id){demand.ObservedAt=now;donorStatus.ObservedAt=now;demand.MessageId=id;}
void Unchanged(){assert(s.m_Trip==0&&s.m_Consumed->Get("recipient")==0&&s.m_NextAttempt->Get("recipient")==0&&recipient.LogisticsReservation==0&&truck.SupplyToken==0&&hq.downlinks==0&&!truck.SupplyHeld&&!convoy.Stopped&&!s.m_Recipient&&!s.m_Donor);}
};
int main(){
// Actual Compatible must reject wrong-well, empty or malformed stock before
// any report/cooldown consumption, reservation, downlink or convoy hold.
for(int bad=0;bad<5;bad++){Fixture f;for(auto&mag:f.magazines){if(bad==0)mag.well=&f.wrongWell;if(bad==1)mag.rounds=0;if(bad==2)mag.capacity=0;if(bad==3)mag.rounds=31;if(bad==4)mag.well=nullptr;}f.s.Stock(0);assert(!f.Plan());f.Unchanged();}
{Fixture f;f.s.Stock(0);f.rifleMuzzle.well=&f.wrongWell;assert(!f.Plan());f.Unchanged();f.rifleMuzzle.well=&f.well;assert(f.Plan());}
// Same delivered recipient report remains available to a later compatible
// truck sharing the real per-source consumption/cooldown maps.
{Fixture first,second;Map<int> consumed;Map<float> cooldown;second.hq.convoys.tasks={&first.convoy,&second.convoy};second.hq.convoy=&first.convoy;second.hq.m_Units={&first.recipient,&second.donor};
assert(first.s.Bind(&first.convoy,0,&consumed,&cooldown));assert(second.s.Bind(&second.convoy,1,&consumed,&cooldown));
for(auto&mag:first.magazines){mag.well=&first.wrongWell;}first.s.Stock(0);second.s.Stock(0);assert(!first.Plan());first.Unchanged();
assert(second.s.TryPlan(&first.recipient,&second.donor,&first.demand,&second.donorStatus,0));assert(consumed.Get("recipient")==1&&cooldown.Get("recipient")==180000&&first.recipient.LogisticsReservation==100129&&second.hq.downlinks==1&&first.hq.downlinks==0);}
// A usable compatible item must still be a surviving unspent frozen identity.
{Fixture f;for(auto&mag:f.magazines)mag.rounds=0;f.magazines[48].rounds=30;f.s.Stock(0);f.inventory.items.Insert(&f.items[48]);assert(!f.Plan());f.Unchanged();f.magazines[0].rounds=30;f.s.m_Spent.Insert(&f.items[0]);assert(!f.Plan());f.Unchanged();f.s.m_Spent.Clear();assert(f.Plan());}
// Hard 32 original carriers and 96 captured magazines remain fail-closed.
{Fixture f;f.s.Stock(0);f.sampler.original.resize(33,&f.one);assert(!f.Plan());f.Unchanged();}
{Fixture f;f.s.Stock(0);for(int i=48;i<97;i++){f.s.m_Stock.Insert(&f.items[i]);f.inventory.items.Insert(&f.items[i]);}assert(!f.Plan());f.Unchanged();}
{Fixture f;for(int i=48;i<96;i++)f.inventory.items.Insert(&f.items[i]);for(int i=0;i<95;i++)f.magazines[i].well=&f.wrongWell;f.s.Stock(0);assert(f.Plan());}
// Small-arms demand cannot borrow launcher compatibility, but the dedicated
// launcher path still supports its real empty reloadable muzzle and rejects disposables.
{Fixture f;f.weapons.weapons={&f.launcher};f.s.Stock(0);assert(!f.Plan());f.Unchanged();assert(f.s.TryPlanLauncher(&f.recipient,&f.donor,&f.demand,&f.donorStatus,0));}
{Fixture f;f.weapons.weapons={&f.launcher};f.launcherMuzzle.disposable=true;f.s.Stock(0);assert(!f.s.TryPlanLauncher(&f.recipient,&f.donor,&f.demand,&f.donorStatus,0));f.Unchanged();}
{Fixture f;for(int i=48;i<96;i++)f.inventory.items.Insert(&f.items[i]);f.s.Stock(0);
for(int i=0;i<95;i++)f.magazines[i].well=&f.wrongWell;
assert(f.s.TryPlanLauncher(&f.recipient,&f.donor,&f.demand,&f.donorStatus,0));
assert(f.s.m_LauncherTrip);}
{Fixture f;f.s.Stock(0);for(auto&mag:f.magazines)mag.well=&f.wrongWell;assert(!f.s.TryPlanLauncher(&f.recipient,&f.donor,&f.demand,&f.donorStatus,0)&&f.truck.SupplyToken==0);}
{Fixture f;f.s.Stock(0);f.ammo.SmallArmsRounds=999;f.ammo.LauncherMagazines=0;assert(!f.Plan());assert(f.s.TryPlanLauncher(&f.recipient,&f.donor,&f.demand,&f.donorStatus,0));assert(f.s.m_LauncherTrip&&!f.s.m_MineTrip);}
for(int bad=0;bad<7;bad++){Fixture f;f.s.Stock(0);f.ammo.SmallArmsRounds=999;if(bad==0)f.ammo.LauncherComplete=false;if(bad==1)f.ammo.LauncherMuzzles=0;if(bad==2)f.ammo.LauncherRounds=1;if(bad==3)f.ammo.LauncherChambers=1;if(bad==4)f.ammo.Members=1;if(bad==5)f.demand.ObservedAt=-1;if(bad==6)f.demand.ObservedAt=1;
assert(!f.s.TryPlanLauncher(&f.recipient,&f.donor,&f.demand,&f.donorStatus,0));assert(f.s.m_State==1&&f.truck.SupplyToken==0);}
// Additional mounted stock callbacks belong to the same initial freeze barrier.
{Fixture f;Cargo mounted;mounted.Finished=false;f.convoy.supply=true;f.convoy.Cargo.Insert(&mounted);
f.s.Stock(0);assert(f.s.m_State==0&&f.s.m_Stock.IsEmpty());
mounted.Finished=true;f.inventory.items.Insert(&f.items[48]);f.s.Stock(1000);
assert(f.s.m_State==1&&f.s.m_Stock.Count()==49&&f.s.m_Stock.Contains(&f.items[48]));}
// Bind accepts only an exact current slot and non-null shared demand histories.
{Fixture f;Map<int> consumed;Map<float> cooldown;Convoy other;
assert(!f.s.Bind(nullptr,0,&consumed,&cooldown));assert(!f.s.Bind(&f.convoy,-1,&consumed,&cooldown));
assert(!f.s.Bind(&f.convoy,20,&consumed,&cooldown));assert(!f.s.Bind(&f.convoy,1,&consumed,&cooldown));
assert(!f.s.Bind(&other,0,&consumed,&cooldown));assert(!f.s.Bind(&f.convoy,0,nullptr,&cooldown));assert(!f.s.Bind(&f.convoy,0,&consumed,nullptr));
assert(f.s.Bind(&f.convoy,0,&consumed,&cooldown));assert(f.s.Task()==&f.convoy);assert(!f.s.Bind(&f.convoy,0,&consumed,&cooldown));}
// Any prior startup/stock/trip/stop refuses late binding.
for(int began=0;began<6;began++){Fixture f;Map<int> consumed;Map<float> cooldown;
if(began==0){f.s.Stock(0);}if(began==1){f.s.m_NextTick=1000;}if(began==2){f.s.m_Trip=1;}
if(began==3){f.s.m_StockDeadline=90000;}if(began==4){f.s.m_Stopped=true;}if(began==5){f.s.m_State=1;}
assert(!f.s.Bind(&f.convoy,0,&consumed,&cooldown));}
// Second convoy remains valid independently of canonical first, but never follows replacement/reordering.
for(int mutation=0;mutation<3;mutation++){Fixture f;Convoy first,replacement;Map<int> consumed;Map<float> cooldown;
f.hq.convoy=&first;f.hq.convoys.tasks={&first,&f.convoy};assert(f.s.Bind(&f.convoy,1,&consumed,&cooldown));
f.s.Stock(0);assert(f.s.TruckValid()&&f.s.Task()==&f.convoy&&f.s.m_Stock.Count()==48);
if(mutation==0)f.hq.convoys.tasks[1]=&replacement;
if(mutation==1)std::swap(f.hq.convoys.tasks[0],f.hq.convoys.tasks[1]);
if(mutation==2)f.hq.convoys.tasks.resize(1);
assert(!f.s.TruckValid()&&!f.Plan()&&f.s.Task()==&f.convoy);}
// Canonical legacy startup also pins its first identity before readiness.
{Fixture f;Convoy replacement;f.convoy.Ready=false;f.s.Stock(0);assert(f.s.Task()==&f.convoy);
f.hq.convoy=&replacement;f.s.Stock(1000);assert(f.s.m_Stopped&&f.s.Task()==&f.convoy);}
// Every bound slot owns a disjoint 128-trip token range, including its last allowed trip.
for(int slot=0;slot<20;slot++){Fixture f;Map<int> consumed;Map<float> cooldown;
f.hq.convoys.tasks.resize(slot+1,nullptr);f.hq.convoys.tasks[slot]=&f.convoy;assert(f.s.Bind(&f.convoy,slot,&consumed,&cooldown));
f.s.Stock(0);assert(f.Plan());assert(f.s.m_Token==100000+slot*128+1);f.s.Finish("test released");
f.s.m_Trip=127;f.Refresh(180000,2);assert(f.Plan(180000));assert(f.s.m_Token==100000+(slot+1)*128);
f.s.Finish("test released");f.Refresh(360000,3);assert(!f.Plan(360000));}
// Separate convoys share report consumption and failed-attempt cooldowns for the same recipient source.
{Fixture first,second;Map<int> consumed;Map<float> cooldown;
second.hq.convoys.tasks={&first.convoy,&second.convoy};second.hq.convoy=&first.convoy;
assert(first.s.Bind(&first.convoy,0,&consumed,&cooldown));assert(second.s.Bind(&second.convoy,1,&consumed,&cooldown));
first.s.Stock(0);second.s.Stock(0);first.hq.routeAvailable=false;assert(first.Plan());
assert(consumed.Get("recipient")==1&&cooldown.Get("recipient")==180000);
second.Refresh(180000,1);assert(!second.Plan(180000));second.Refresh(179999,2);assert(!second.Plan(179999));
second.Refresh(180000,2);assert(second.Plan(180000));assert(first.s.m_Consumed->Get("recipient")==2&&first.s.m_NextAttempt->Get("recipient")==360000);}
// Actual inventory aggregation collapses repeated native storage references, not distinct identical-prefab magazines.
{Fixture f;f.inventory.items.Insert(&f.items[0]);f.inventory.items.Insert(nullptr);f.s.Stock(0);assert(f.s.m_State==1&&!f.s.m_Stopped&&f.s.m_Stock.Count()==48);assert(f.s.m_Stock[0]!=f.s.m_Stock[1]);}
// Malformed/non-magazine items never become spendable stock; native startup partial cargo stays partial.
{Fixture f;f.inventory.items={&f.items[0],&f.items[1],&f.items[2],nullptr};f.items[1].magazine=false;f.items[2].magazine=false;f.items[2].prefab.name="rifle";f.s.Stock(0);assert(f.s.m_Stock.Count()==1&&f.s.m_State==1);}
{Fixture f;f.cargo.Finished=false;f.s.Stock(0);assert(f.s.m_State==0&&f.s.m_Stock.IsEmpty());f.s.Stock(89999);assert(!f.s.m_Stopped&&f.s.m_Stock.IsEmpty());f.s.Stock(90000);assert(f.s.m_Stopped&&f.s.m_Stock.IsEmpty());}
{Fixture f;f.cargo.Finished=false;f.s.Stock(0);f.cargo.Finished=true;f.inventory.items={&f.items[0]};f.s.Stock(1000);assert(f.s.m_Stock.Count()==1&&!f.s.m_Stopped);}
{Fixture f;for(int i=48;i<97;i++)f.inventory.items.Insert(&f.items[i]);f.s.Stock(0);assert(f.s.m_Stopped&&!f.Plan());f.Unchanged();}
{Fixture f;for(auto& item:f.items)f.inventory.items.Insert(&item);f.s.Stock(0);assert(f.s.m_Stopped&&f.s.m_Stock.IsEmpty());}
{Fixture f;f.vehicle.inventory=nullptr;f.s.Stock(0);assert(f.s.m_Stopped&&!f.Plan());}
{Fixture f;f.convoy.Ready=false;f.s.Stock(0);assert(f.s.m_State==0&&f.s.m_Stock.IsEmpty());}
{Fixture f;f.receipt.Consumed=false;f.s.Stock(0);assert(f.s.m_Stopped&&f.s.m_Stock.IsEmpty());}
// Supply weapons settle after crew deadline; matching ammo must be issued and settled before snapshot.
{Fixture f;f.convoy.supply=true;f.convoy.MagazinesIssued=false;f.s.Stock(25000);assert(f.s.m_State==0&&f.s.m_Stock.IsEmpty());
f.s.Stock(31000);assert(!f.s.m_Stopped&&f.s.m_State==0);f.convoy.MagazinesIssued=true;f.cargo.Finished=false;
f.s.Stock(32000);assert(f.s.m_State==0&&f.s.m_Stock.IsEmpty());f.cargo.Finished=true;
f.items[0].prefab.name="NATO_556_STANAG";f.s.Stock(33000);assert(f.s.m_State==1&&!f.s.m_Stopped&&f.s.m_Stock.Contains(&f.items[0]));}
// Earliest admission: producer may finish weapons only at original Deadline+30000.
{Fixture f;f.convoy.supply=true;f.convoy.MagazinesIssued=false;f.cargo.Finished=false;f.s.Stock(0);
f.s.Stock(59999);assert(!f.s.m_Stopped&&f.s.m_Stock.IsEmpty());
f.convoy.MagazinesIssued=true;f.s.Stock(60000);assert(!f.s.m_Stopped&&f.s.m_State==0);
f.cargo.Finished=true;f.items[0].prefab.name="NATO_556_STANAG";f.s.Stock(89000);
assert(!f.s.m_Stopped&&f.s.m_State==1&&f.s.m_Stock.Contains(&f.items[0]));}
// Missing first-phase submission and missing second phase are bounded by one immutable deadline.
for(int phase=0;phase<2;phase++){Fixture f;f.convoy.supply=true;f.convoy.CargoIssued=phase!=0;f.convoy.MagazinesIssued=false;
f.s.Stock(25000);f.s.Stock(114999);assert(!f.s.m_Stopped&&f.s.m_StockDeadline==115000&&f.s.m_Stock.IsEmpty());
f.s.Stock(115000);assert(f.s.m_Stopped&&f.s.m_Stock.IsEmpty());}
// Faction catalogs may yield 96 distinct magazine identities; weapons are excluded.
{Fixture f;for(int i=48;i<96;i++)f.inventory.items.Insert(&f.items[i]);f.items[0].prefab.name="NATO_556_STANAG";
f.items[96].magazine=false;f.inventory.items.Insert(&f.items[96]);f.s.Stock(0);
assert(!f.s.m_Stopped&&f.s.m_State==1&&f.s.m_Stock.Count()==96&&f.s.m_Stock.Contains(&f.items[0])&&!f.s.m_Stock.Contains(&f.items[96]));}
// Detached known-zero demand also requires settled original designation; unknown never authorizes.
{Fixture f;MineBatch batch;f.convoy.supply=true;f.convoy.MineStock=&batch;f.items[48].readyMine=true;batch.items={&f.items[48]};f.inventory.items.Insert(&f.items[48]);f.s.Stock(0);
for(int n: {0,2,3}){f.ammo.ReadyMines=n;assert(!f.s.TryPlanMines(&f.recipient,&f.donor,&f.demand,&f.donorStatus,0));}
f.ammo.ReadyMines=0;f.hq.designated=true;f.one.released=f.two.released=true;assert(!f.s.TryPlanMines(&f.recipient,&f.donor,&f.demand,&f.donorStatus,0));f.one.released=f.two.released=false;assert(f.s.TryPlanMines(&f.recipient,&f.donor,&f.demand,&f.donorStatus,0));f.s.Finish("reset");f.s.m_Consumed->data.clear();f.s.m_NextAttempt->data.clear();f.hq.designated=false;
f.ammo.ReadyMines=1;f.ammo.MineComplete=false;assert(!f.s.TryPlanMines(&f.recipient,&f.donor,&f.demand,&f.donorStatus,0));f.ammo.MineComplete=true;
batch.complete=false;assert(!f.s.TryPlanMines(&f.recipient,&f.donor,&f.demand,&f.donorStatus,0));batch.complete=true;
assert(f.s.TryPlanMines(&f.recipient,&f.donor,&f.demand,&f.donorStatus,0));assert(f.s.m_MineTrip&&f.s.m_MineStock.Count()==1);}
// A submitted unknown mine retains the real HQ claim across a newer delivered
// report and expired shared cooldown; a second truck cannot race the same actor.
{Fixture first,second;Leaf leaf;leaf.unresolved=true;first.s.Stock(0);assert(first.Plan());first.s.m_MineMove=&leaf;first.s.m_MineTrip=true;first.s.Finish("unknown native move");
assert(first.s.m_State==7&&first.recipient.LogisticsReservation==100001&&first.truck.SupplyToken==100001);
second.s.Stock(0);second.s.m_HQ=&first.hq;first.hq.convoy=&second.convoy;first.hq.convoys.tasks={&second.convoy};second.s.m_Consumed=first.s.m_Consumed;second.s.m_NextAttempt=first.s.m_NextAttempt;
first.Refresh(180001,2);second.donorStatus.ObservedAt=180001;
assert(!second.s.TryPlan(&first.recipient,&second.donor,&first.demand,&second.donorStatus,180001));assert(first.recipient.LogisticsReservation==100001);
leaf.unresolved=false;first.s.Finish("settled");assert(first.recipient.LogisticsReservation==0);
assert(second.s.TryPlan(&first.recipient,&second.donor,&first.demand,&second.donorStatus,180001));}
// Removed stock is unavailable; a different magazine added after capture does not replace its identity.
{Fixture f;f.s.Stock(0);f.inventory.items={&f.items[48]};assert(!f.Plan());f.Unchanged();f.inventory.items.Insert(&f.items[0]);assert(f.Plan());assert(f.s.m_Stock.Count()==48&&!f.s.m_Stock.Contains(&f.items[48]));}
{Fixture f;f.s.Stock(0);f.s.m_Spent=f.s.m_Stock;assert(!f.Plan());f.Unchanged();}
// A delivered report is tied to exact original source identities and original still-owned members.
{Fixture f;f.s.Stock(0);f.demand.SourceId="foreign";assert(!f.Plan());f.Unchanged();}
{Fixture f;f.s.Stock(0);f.donorStatus.SourceId="foreign";assert(!f.Plan());f.Unchanged();}
{Fixture f;f.s.Stock(0);f.one.released=true;assert(!f.Plan());f.Unchanged();assert(!f.s.m_Recipient&&!f.s.m_Donor);}
{Fixture f;f.s.Stock(0);Entity foreign;foreign.group=&f.recipients;Agent extra{&foreign};f.recipients.agents.Insert(&extra);assert(!f.Plan());f.Unchanged();}
// Real HQ force reservation refuses busy/support-ineligible or silent-radio recipients without consuming the demand.
for(int refusal=0;refusal<5;refusal++){Fixture f;f.s.Stock(0);void* owned=&f;
if(refusal==0){f.recipient.Assignment=owned;}if(refusal==1){f.recipient.Downlink=owned;}if(refusal==2){f.recipient.Waypoint=owned;}if(refusal==3){f.recipient.Radio=nullptr;}if(refusal==4){f.recipient.eligible=false;}
assert(!f.Plan());f.Unchanged();assert(!f.s.m_Recipient&&!f.s.m_Donor);
f.recipient.Assignment=nullptr;f.recipient.Downlink=nullptr;f.recipient.Waypoint=nullptr;f.recipient.Radio=&f;f.recipient.eligible=true;
assert(f.Plan());assert(f.s.m_Trip==1&&f.s.m_Consumed->Get("recipient")==1&&f.recipient.LogisticsReservation==100001);}
{Fixture f;f.s.Stock(0);f.recipient.LogisticsReservation=7;assert(!f.Plan());assert(f.recipient.LogisticsReservation==7&&f.s.m_Trip==0&&f.hq.downlinks==0);}
// Failed truck downlink is still a consumed planning attempt; cleanup preserves all cargo and other ownership.
{Fixture f;f.s.Stock(0);f.hq.routeAvailable=false;assert(f.Plan());assert(f.s.m_State==1&&f.s.m_Trip==1&&f.s.m_Consumed->Get("recipient")==1&&f.recipient.LogisticsReservation==0&&f.truck.SupplyToken==0&&f.inventory.items.Count()==48);
f.hq.routeAvailable=true;f.Refresh(180000,1);assert(!f.Plan(180000)); // same consumed message cannot replay after cooldown
f.Refresh(179999,2);assert(!f.Plan(179999));f.Refresh(180000,2);assert(f.Plan(180000));assert(f.s.m_Trip==2&&f.s.m_Deadline==300000);}
// A stale-but-still-admissible demand gets only the remaining evidence horizon, never a new full lifetime.
{Fixture f;f.s.Stock(0);assert(f.Plan(120000));assert(f.s.m_Deadline==180000);assert(!f.Plan(120000)&&f.hq.downlinks==1);}
// Independent guarded failures do not leak reservations or acquire replacement force identities.
for(int refusal=0;refusal<7;refusal++){Fixture f;f.s.Stock(0);
if(refusal==0){f.recipient.HomeGuard=true;}if(refusal==1){f.truck.Combat->Held=true;}if(refusal==2){f.vehicle.captured=true;}if(refusal==3){f.mode.ledger.record.Eliminated=true;}if(refusal==4){f.donor.PendingConvoyOrder=&f;}if(refusal==5){f.ammo.Complete=false;}if(refusal==6){f.demand.Position.x=201;}
assert(!f.Plan());f.Unchanged();}
}
''')
print('PASS: actual Compatible and bounded stock preflight before report/claim consumption, later compatible truck, launcher controls, convoy binding, finite identities, disjoint tokens, shared report replay/cooldown, original recipients and HQ cleanup')