Capture current mission, AI, map and administration development
Include the current addon, terrain integrations, tools, regression tests and recorded development evidence.
This commit is contained in:
@@ -0,0 +1,13 @@
|
||||
Read-only integration audit: no reproduced automatic-equipment/PMN4 resupply race in installed catalogs.
|
||||
|
||||
Production boundaries:
|
||||
- ERR_AutomaticEquipmentCatalog.Supported excludes EXPLOSIVES, ROCKET_LAUNCHER, attachment/ammo modes. All bits must belong to allowed set; EXPLOSIVES combined with an allowed category still fails.
|
||||
- Installed vanilla USSR InventoryItems catalog lines777-780 and FIA lines484-487 classify exact PMN4 B05A816C0BF50802 as EXPLOSIVES. Both loaded from installed vanilla PAK, not protected original Escapists overrides.
|
||||
- Read-only PAK scan of installed RHS StatusQuo+contentpacks, WCS Armaments+Core and BMP: no exact PMN4 catalog override found. Found RHS TM62M/M15AT entries all EXPLOSIVES. Mine marking flags are EQUIPMENT but are not explosive mines. Results retained in catalog-audit.log and mine-catalog-audit.log.
|
||||
- MineSupplyReady does not wait for Automatic, but that alone is not a demonstrated mine race: installed eligible automatic categories cannot issue PMN4. Other automatic inventory items can consume capacity; finite mine leaf rechecks native storage/CanMove and preserves one-shot submission quarantine, so capacity refusal is ordinary bounded failure rather than additional mine.
|
||||
- ERR_EnemyEquipment.RegisterGroup deduplicates exact groups; Known(actor) retains original actor identity. Tick suspends existing entry during unconsciousness without resetting grants. Player/captured ownership permanently stops entry; released entries remain known, so later loss of player ownership cannot reroll same original actor. New physical replacement actors are separate identities, not reconnect rerolls.
|
||||
- Grant m_Rolled and retained m_Operation prevent retry/reroll after completion, rejection, timeout or late callback.
|
||||
|
||||
Focused actual-method tests PASS: test_automatic_equipment.py, test_enemy_equipment.py, test_infantry_mine_transfer.py. Logs retained alongside this review. These are extracted methods with native doubles, not native multiplayer qualification. No source patch proposed, no target/reference source edits, no engine/UI actions.
|
||||
|
||||
Limit: unsupported future addon catalog misclassification (e.g. PMN4 intentionally marked EQUIPMENT) was not reproduced or defended by speculative extra gate. Active runtime catalog selection can differ from static inspected installed entries; no live catalog query launched.
|
||||
@@ -0,0 +1,2 @@
|
||||
PASS: automatic inventory one-shot roll, exact item ownership, finite compatible ammo, rejection, capture/stop, deletion, loot and late callback quarantine
|
||||
PASS: enabled/valid catalog eligibility, category restrictions, content filtering, GUID deduplication across factions and bounded catalogs
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
SCANNED RHS-StatusQuo_595F2BF2F44836FB 17 catalogs; exact PMN4 matches 0
|
||||
SCANNED RHS-ContentPack01_1337C0DE5DABBEEF 0 catalogs; exact PMN4 matches 0
|
||||
SCANNED RHS-ContentPack02_BADC0DEDABBEDA5E 0 catalogs; exact PMN4 matches 0
|
||||
SCANNED WCS_Armaments_629B2BA37EFFD577 11 catalogs; exact PMN4 matches 0
|
||||
SCANNED WCS_Core_64610AFB74AA9842 0 catalogs; exact PMN4 matches 0
|
||||
SCANNED BMP-1IFV_5E524E4FEECCA92B 4 catalogs; exact PMN4 matches 0
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
import sys,struct,zlib,re
|
||||
from pathlib import Path
|
||||
sys.path.insert(0,'/home/jakub/devel/escapistsrereintroduced/tools')
|
||||
from pak_inventory import parse_tree,Limits
|
||||
root=Path('/home/jakub/.local/share/Steam/steamapps/compatdata/1874880/pfx/drive_c/users/steamuser/Documents/My Games/ArmaReforger/addons')
|
||||
mods=['RHS-StatusQuo_595F2BF2F44836FB','RHS-ContentPack01_1337C0DE5DABBEEF','RHS-ContentPack02_BADC0DEDABBEDA5E','WCS_Armaments_629B2BA37EFFD577','WCS_Core_64610AFB74AA9842','BMP-1IFV_5E524E4FEECCA92B']
|
||||
for mod in mods:
|
||||
count=0;hits=0
|
||||
for p in (root/mod).glob('*.pak'):
|
||||
with p.open('rb') as f:
|
||||
chunks={};off=12
|
||||
for _ in range(3):
|
||||
f.seek(off);tag,size=struct.unpack('>4sI',f.read(8));chunks[tag]=(off+8,size);off+=8+size
|
||||
f.seek(chunks[b'FILE'][0]);tree=f.read(chunks[b'FILE'][1]);start,size=chunks[b'DATA']
|
||||
entries,_,_=parse_tree(tree,start,start+size,Limits(archive_bytes=16*1024**3,total_bytes=32*1024**3))
|
||||
for e in entries:
|
||||
if 'entitycatalog' not in e['path'].lower() or not e['path'].endswith('.conf'):continue
|
||||
f.seek(e['offset']);b=f.read(e['stored_bytes']);b=zlib.decompress(b) if e['compression']=='zlib' else b
|
||||
count+=1;s=b.decode('utf-8',errors='replace')
|
||||
for m in re.finditer('(?i)PMN4|B05A816C0BF50802',s):
|
||||
hits+=1;print(mod,e['path'],s[max(0,m.start()-100):m.end()+350])
|
||||
print('SCANNED',mod,count,'catalogs; exact PMN4 matches',hits)
|
||||
@@ -0,0 +1 @@
|
||||
PASS: actual equipment coordinator registration dedupe, startup delay, five member scans, finite component retries, unregister/stop terminal behavior and 256-group bound
|
||||
+143
@@ -0,0 +1,143 @@
|
||||
RHS-StatusQuo_595F2BF2F44836FB Configs/EntityCatalog/FFA/FFA_InventoryItems.conf }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{5EACB04FE72A6C00}" {
|
||||
m_sEntityPrefab "{49FFE8F373F55960}Prefabs/Weapons/Explosives/Mine_M15AT/Mine_M15AT.et"
|
||||
m_aEntityDataList {
|
||||
SCR_ArsenalItem "{5EACB04FE72A6C07}" {
|
||||
m_eItemType EXPLOSIVES
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogMultiListEntry "{5EACB04FE72A6C06}" {
|
||||
m_sIdentifier "Equipment"
|
||||
m_aEntities {
|
||||
SCR_EntityCatalogInventoryItem "{5EACB04FE72A6C05}" {
|
||||
m_sEntityPrefab "{A81F501D3EF6F38E}Prefabs/Items/Medi
|
||||
RHS-StatusQuo_595F2BF2F44836FB Configs/EntityCatalog/FFA/FFA_InventoryItems.conf mType EQUIPMENT
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{5EACB04FE72A6C64}" {
|
||||
m_sEntityPrefab "{EC13D4E934B2ADD8}Prefabs/Items/Demining/MineFlags/MineFlag_US.et"
|
||||
m_aEntityDataList {
|
||||
SCR_ArsenalItem "{5EACB04FE72A6C6B}" {
|
||||
m_eItemType EQUIPMENT
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{5EACB04FE72A6C6A}" {
|
||||
m_sEntityPrefab "{64322D5D501B7D79}Prefabs/Items/Equipment/Nightvision/PVS14/NVG_PVS14_Base.et"
|
||||
m_aEntityDataList {
|
||||
SCR_ArsenalItem "{5EACB04FE72A6C69}" {
|
||||
|
||||
RHS-StatusQuo_595F2BF2F44836FB Configs/EntityCatalog/ION/ION_InventoryItems.conf plyType GRENADE
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{5D4A8E6F2C974411}" {
|
||||
m_sEntityPrefab "{49FFE8F373F55960}Prefabs/Weapons/Explosives/Mine_M15AT/Mine_M15AT.et"
|
||||
m_aEntityDataList {
|
||||
SCR_ArsenalItem "{5D4A8E6F2C974412}" {
|
||||
m_eItemType EXPLOSIVES
|
||||
m_iSupplyCost 5
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{61B54A0654E2F1FA}" {
|
||||
m_sEntityPrefab "{33CBDE73AB48172A}Prefabs/Weapons/Explosives/DemoBlock_M112/DemoBlock_M112.et"
|
||||
m_aEntityDataList {
|
||||
SCR_ArsenalItem
|
||||
RHS-StatusQuo_595F2BF2F44836FB Configs/EntityCatalog/ION/ION_InventoryItems.conf m_iSupplyCost 0
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{5D4A8E6F2C974405}" {
|
||||
m_sEntityPrefab "{EC13D4E934B2ADD8}Prefabs/Items/Demining/MineFlags/MineFlag_US.et"
|
||||
m_aEntityDataList {
|
||||
SCR_ArsenalItem "{5D4A8E6F2C974406}" {
|
||||
m_eItemType EQUIPMENT
|
||||
m_iSupplyCost 0
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{64E120FDD304C9D3}" {
|
||||
m_sEntityPrefab "{BE2A47715A24AE5D}Prefabs/Items/Equipment/Accessories/GPSRadioBeacon/GPSRadioBeacon.et"
|
||||
m_aEntityDataList {
|
||||
SCR_Ars
|
||||
RHS-StatusQuo_595F2BF2F44836FB Configs/EntityCatalog/RHS_MSV/MSV_InventoryItems.conf plyType GRENADE
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{5C62F7DF47B8BF41}" {
|
||||
m_sEntityPrefab "{D6EF54367CECE1D9}Prefabs/Weapons/Explosives/Mine_TM62M/Mine_TM62M.et"
|
||||
m_aEntityDataList {
|
||||
SCR_ArsenalItem "{5C62F7DEAEC68866}" {
|
||||
m_eItemType EXPLOSIVES
|
||||
m_iSupplyCost 5
|
||||
m_eRequiredRank CORPORAL
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{618887A369EADA91}" {
|
||||
m_sEntityPrefab "{90976DC90A223095}Prefabs/Items/Equipment/Detonators/BlastingMachine_KPM_3U1/BlastingMachine_
|
||||
RHS-StatusQuo_595F2BF2F44836FB Configs/EntityCatalog/RHS_MSV/MSV_InventoryItems.conf m_iSupplyCost 0
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{5D4A87E86D2162B5}" {
|
||||
m_sEntityPrefab "{AC67BAB9763A3977}Prefabs/Items/Demining/MineFlags/MineFlag_USSR.et"
|
||||
m_aEntityDataList {
|
||||
SCR_ArsenalItem "{5D4A87E86D2162AB}" {
|
||||
m_eItemType EQUIPMENT
|
||||
m_iSupplyCost 0
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{64E120FDBDE55926}" {
|
||||
m_sEntityPrefab "{BE2A47715A24AE5D}Prefabs/Items/Equipment/Accessories/GPSRadioBeacon/GPSRadioBeacon.et"
|
||||
m_aEntityDataList {
|
||||
SCR_Ars
|
||||
RHS-StatusQuo_595F2BF2F44836FB Configs/EntityCatalog/USMC/USMC_InventoryItems.conf plyType GRENADE
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{5CA0A9E6C9E91F72}" {
|
||||
m_sEntityPrefab "{49FFE8F373F55960}Prefabs/Weapons/Explosives/Mine_M15AT/Mine_M15AT.et"
|
||||
m_aEntityDataList {
|
||||
SCR_ArsenalItem "{5CA0A9E6C9E91F70}" {
|
||||
m_eItemType EXPLOSIVES
|
||||
m_iSupplyCost 5
|
||||
m_eRequiredRank CORPORAL
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{618887A35A01F86F}" {
|
||||
m_sEntityPrefab "{CE0AF733722B3978}Prefabs/Items/Equipment/Detonators/BlastingMachine_M34/BlastingMachine_M34.
|
||||
RHS-StatusQuo_595F2BF2F44836FB Configs/EntityCatalog/USMC/USMC_InventoryItems.conf m_iSupplyCost 0
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{5D4A8E6F2C974405}" {
|
||||
m_sEntityPrefab "{EC13D4E934B2ADD8}Prefabs/Items/Demining/MineFlags/MineFlag_US.et"
|
||||
m_aEntityDataList {
|
||||
SCR_ArsenalItem "{5D4A8E6F2C974406}" {
|
||||
m_eItemType EQUIPMENT
|
||||
m_iSupplyCost 0
|
||||
}
|
||||
}
|
||||
}
|
||||
SCR_EntityCatalogInventoryItem "{64E120FDB4FD8912}" {
|
||||
m_sEntityPrefab "{BE2A47715A24AE5D}Prefabs/Items/Equipment/Accessories/GPSRadioBeacon/GPSRadioBeacon.et"
|
||||
m_aEntityDataList {
|
||||
SCR_Ars
|
||||
SCANNED RHS-StatusQuo_595F2BF2F44836FB 17 catalogs; mine-name matches (includes marking flags) 8
|
||||
SCANNED RHS-ContentPack01_1337C0DE5DABBEEF 0 catalogs; mine-name matches (includes marking flags) 0
|
||||
SCANNED RHS-ContentPack02_BADC0DEDABBEDA5E 0 catalogs; mine-name matches (includes marking flags) 0
|
||||
SCANNED WCS_Armaments_629B2BA37EFFD577 11 catalogs; mine-name matches (includes marking flags) 0
|
||||
SCANNED WCS_Core_64610AFB74AA9842 0 catalogs; mine-name matches (includes marking flags) 0
|
||||
SCANNED BMP-1IFV_5E524E4FEECCA92B 4 catalogs; mine-name matches (includes marking flags) 0
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
import sys,struct,zlib,re
|
||||
from pathlib import Path
|
||||
sys.path.insert(0,'/home/jakub/devel/escapistsrereintroduced/tools')
|
||||
from pak_inventory import parse_tree,Limits
|
||||
root=Path('/home/jakub/.local/share/Steam/steamapps/compatdata/1874880/pfx/drive_c/users/steamuser/Documents/My Games/ArmaReforger/addons')
|
||||
mods=['RHS-StatusQuo_595F2BF2F44836FB','RHS-ContentPack01_1337C0DE5DABBEEF','RHS-ContentPack02_BADC0DEDABBEDA5E','WCS_Armaments_629B2BA37EFFD577','WCS_Core_64610AFB74AA9842','BMP-1IFV_5E524E4FEECCA92B']
|
||||
for mod in mods:
|
||||
count=0;hits=0
|
||||
for p in (root/mod).glob('*.pak'):
|
||||
with p.open('rb') as f:
|
||||
chunks={};off=12
|
||||
for _ in range(3):
|
||||
f.seek(off);tag,size=struct.unpack('>4sI',f.read(8));chunks[tag]=(off+8,size);off+=8+size
|
||||
f.seek(chunks[b'FILE'][0]);tree=f.read(chunks[b'FILE'][1]);start,size=chunks[b'DATA']
|
||||
entries,_,_=parse_tree(tree,start,start+size,Limits(archive_bytes=16*1024**3,total_bytes=32*1024**3))
|
||||
for e in entries:
|
||||
if 'entitycatalog' not in e['path'].lower() or not e['path'].endswith('.conf'):continue
|
||||
f.seek(e['offset']);b=f.read(e['stored_bytes']);b=zlib.decompress(b) if e['compression']=='zlib' else b
|
||||
count+=1;s=b.decode('utf-8',errors='replace')
|
||||
for m in re.finditer(r'(?i)m_sEntityPrefab[^\n]*mine[^\n]*',s):
|
||||
hits+=1;print(mod,e['path'],s[max(0,m.start()-100):m.end()+350])
|
||||
print('SCANNED',mod,count,'catalogs; mine-name matches (includes marking flags)',hits)
|
||||
@@ -0,0 +1 @@
|
||||
PASS: actual finite PMN4 one-to-two entitlement, pinned original ownership, shared commit, physical custody, callback quarantine/deletion and no retry
|
||||
@@ -0,0 +1,43 @@
|
||||
Test audio routed to silent output and muted (stream 665438)
|
||||
Test audio routed to silent output and muted (stream 665497)
|
||||
Test audio routed to silent output and muted (stream 665508)
|
||||
{
|
||||
"stopped_unix": 1790879595.6074069,
|
||||
"console_sha256": "f6eb9ff706fa6b3e27c71c958d3237b736cf4d437fa18c928e48ae97a1a583da",
|
||||
"end_source_sha256": "5bfa158e42511b1f358071b48f66fde43774f430d3c0e42e878d44dec71fbaea",
|
||||
"source_unchanged_after_run": true,
|
||||
"source_provenance": "launch_snapshot",
|
||||
"launch_id": "7d392849-4fe1-4250-8841-0b9eaa782ded",
|
||||
"launch_source_manifest": "launch-source-sha256.json",
|
||||
"launch_source_metadata": "launch-source.json",
|
||||
"launch_source_sha256": "5bfa158e42511b1f358071b48f66fde43774f430d3c0e42e878d44dec71fbaea",
|
||||
"external_addons_unchanged_after_run": true,
|
||||
"external_addon_count": 7,
|
||||
"external_addon_inputs": "external-addons-inputs.json",
|
||||
"started_unix": 1790879453.9770525,
|
||||
"result": "test-failed",
|
||||
"result_before_cleanup": "test-failed",
|
||||
"cleanup_confirmed": true,
|
||||
"cleanup_report": {
|
||||
"cleanup_confirmed": true,
|
||||
"idle_verified": true,
|
||||
"errors": [],
|
||||
"orphan_cleanup": {
|
||||
"attempted": true,
|
||||
"report": {
|
||||
"scope": "/tmp/erri-headless-compat/pfx",
|
||||
"candidates": [],
|
||||
"term_sent": [],
|
||||
"kill_sent": [],
|
||||
"cleared": true
|
||||
}
|
||||
}
|
||||
},
|
||||
"runner_error": null,
|
||||
"session": "/tmp/erri-mounted-mine-stock-20261001/logs/logs_2026-10-01_20-30-55",
|
||||
"rounds_required": 1,
|
||||
"project": "chat",
|
||||
"display": "headless Gamescope 1280x720/30Hz",
|
||||
"dedicated_server": false,
|
||||
"audio": "silent sink and per-test-stream mute"
|
||||
}
|
||||
+306
@@ -0,0 +1,306 @@
|
||||
#ifdef WORKBENCH
|
||||
// Read-only fixture access to the actual production sender; never initiates a report.
|
||||
modded class ERR_HQ
|
||||
{
|
||||
ERR_HQUnit ERR_MountedFixtureUnit(SCR_AIGroup group)
|
||||
{
|
||||
if (!ERR_NativeMountedAmmoProbe.Enabled() || !group) return null;
|
||||
for (int i = 0; i < m_Units.Count() && i < 256; i++)
|
||||
if (m_Units[i].Group == group) return m_Units[i];
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// WORKBENCH-only read access to the exact successful startup callback identity.
|
||||
modded class ERR_ConvoyMineStock
|
||||
{
|
||||
bool ERR_FixtureMine(ERR_SupplyConvoyTask task, ERR_ConvoyVehicle original, IEntity item)
|
||||
{
|
||||
if (!m_Closed || task != m_Task || original != m_Original || !original || original.Entity != m_Truck) return false;
|
||||
if (!m_Truck || !item || !m_Items.Contains(item) || m_Cargo.Count() > 2 || !m_Inventory || m_Inventory.GetOwner() != m_Truck) return false;
|
||||
if (m_Truck.FindComponent(InventoryStorageManagerComponent) != m_Inventory) return false;
|
||||
foreach (ERR_ConvoyMineCargo operation : m_Cargo)
|
||||
if (operation && operation.Finished && operation.Succeeded && operation.Item == item) return true;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
class ERR_NativeMountedAmmoProbe
|
||||
{
|
||||
protected ERR_GameMode m_Mode;
|
||||
protected float m_Deadline;
|
||||
protected float m_NextLog;
|
||||
protected bool m_Failed;
|
||||
protected bool m_Stopped;
|
||||
protected bool m_FleetReady;
|
||||
protected bool m_SwapEligibility;
|
||||
protected bool m_MineStock;
|
||||
protected ref ERR_ConvoyMineStock m_MineBatch;
|
||||
protected ref ERR_ConvoyVehicle m_MineTruck;
|
||||
protected InventoryStorageManagerComponent m_MineInventory;
|
||||
protected ref array<IEntity> m_Mines = {};
|
||||
protected ref array<ref ERR_ConvoyCargoCallback> m_PrimaryCargo = {};
|
||||
protected ref ERR_NativeMountedSwapProbe m_SwapProbe;
|
||||
protected ref ERR_SupplyConvoyTask m_ProofTask;
|
||||
protected ERR_HQUnit m_Unit;
|
||||
protected IEntity m_Root;
|
||||
protected ref ERR_HQStatusReport m_Queued;
|
||||
protected ref ERR_HQMountedAmmoSnapshot m_Payload;
|
||||
protected ref ERR_HQRoute m_Route;
|
||||
protected string m_RoutePayload;
|
||||
static bool Enabled()
|
||||
{
|
||||
string enabled, outcome;
|
||||
return Replication.IsServer() && System.GetCLIParam("errSmoke", enabled) && enabled == "1"
|
||||
&& System.GetCLIParam("errSmokeOutcome", outcome) && outcome == "mounted-ammo";
|
||||
}
|
||||
void ERR_NativeMountedAmmoProbe(ERR_GameMode mode, float now)
|
||||
{
|
||||
m_Mode = mode; m_Deadline = now + 180000;
|
||||
string swap, mines, courier;
|
||||
m_MineStock = System.GetCLIParam("errMineStock", mines) && mines == "1";
|
||||
m_SwapEligibility = System.GetCLIParam("errMountedSwapEligibility", swap) && swap == "1";
|
||||
if (m_MineStock && (m_SwapEligibility || (System.GetCLIParam("errMountedCourier", courier) && courier == "1")))
|
||||
Check(false, "mine-stock proof requires the normal mounted radio path, without swap or courier flags");
|
||||
if (m_SwapEligibility) m_SwapProbe = new ERR_NativeMountedSwapProbe();
|
||||
}
|
||||
bool SwapEligibility() { return m_SwapEligibility; }
|
||||
static string CompletionText(bool swapEligibility)
|
||||
{
|
||||
if (swapEligibility) return "ERR SMOKE COMPLETE: native mounted swap eligibility only; no transfer or radio proof; explicit fixture reset";
|
||||
return "ERR SMOKE COMPLETE: production fleet mounted ammunition, cargo exclusion and actual radio delivery; explicit fixture reset";
|
||||
}
|
||||
protected bool Check(bool condition, string detail)
|
||||
{
|
||||
if (condition) { Print("ERR SMOKE PASS: mounted ammo " + detail); return true; }
|
||||
m_Failed = true; Print("ERR SMOKE FAIL: mounted ammo " + detail, LogLevel.ERROR); return false;
|
||||
}
|
||||
protected bool Same(ERR_HQMountedAmmoSnapshot a, ERR_HQMountedAmmoSnapshot b)
|
||||
{
|
||||
return a && b && a.Complete == b.Complete && a.Weapons == b.Weapons && a.Muzzles == b.Muzzles
|
||||
&& a.Magazines == b.Magazines && a.Rounds == b.Rounds && a.Capacity == b.Capacity
|
||||
&& a.Chambers == b.Chambers && a.LowMagazines == b.LowMagazines;
|
||||
}
|
||||
protected bool Original(ERR_ConvoyVehicle vehicle, ERR_HQUnit unit)
|
||||
{
|
||||
if (!vehicle || !unit || !vehicle.Registered || vehicle.Released || !vehicle.Entity || !vehicle.Group
|
||||
|| vehicle.Members.Count() > 32 || unit.Group != vehicle.Group || !unit.StatusSampler || !unit.StatusSampler.OwnsRoster(vehicle.Group)) return false;
|
||||
ERR_ForceRecord record = m_Mode.Forces().FindGroup(vehicle.Group);
|
||||
if (!record || record.Kind != ERR_ForceKind.CONVOY || !record.Physical || record.Eliminated
|
||||
|| record.SourceId != unit.StatusSampler.InitialSourceId() || record.InitialStrength != vehicle.Members.Count()
|
||||
|| unit.StatusSampler.InitialStrength() != vehicle.Members.Count()) return false;
|
||||
foreach (IEntity member : vehicle.Members)
|
||||
{
|
||||
bool original;
|
||||
for (int slot = 0; slot < unit.StatusSampler.InitialStrength(); slot++)
|
||||
if (unit.StatusSampler.InitialMember(slot) == member) original = true;
|
||||
if (!original || !ERR_Actors.Alive(member) || ERR_Actors.Group(member) != vehicle.Group
|
||||
|| !ERR_ConvoyRules.PartOf(CompartmentAccessComponent.GetVehicleIn(member), vehicle.Entity)) return false;
|
||||
}
|
||||
return !vehicle.Members.IsEmpty();
|
||||
}
|
||||
protected void Capture(ERR_HQ hq, ERR_ConvoyVehicle vehicle, float now)
|
||||
{
|
||||
if (m_Queued || !vehicle || !vehicle.Registered) return;
|
||||
ERR_HQUnit unit = hq.ERR_MountedFixtureUnit(vehicle.Group);
|
||||
if (!Original(vehicle, unit) || !unit.PendingStatus || !unit.Uplink) return;
|
||||
ERR_HQStatusReport report = unit.PendingStatus;
|
||||
if (!report.MountedAmmo || report.MountedAmmo.Weapons < 1 || report.MountedAmmo.Magazines < 1) return;
|
||||
ERR_HQWatchEntry before = hq.Watch().Find(report.SourceId);
|
||||
if (before && before.MessageId >= report.MessageId) return;
|
||||
if (!Check(ERR_HQWatchRules.Valid(report, now) && report.SourceId == unit.StatusSampler.InitialSourceId()
|
||||
&& unit.Uplink.MessageId == report.MessageId && unit.Uplink.Cursor < unit.Uplink.Nodes.Count(), "original mounted payload observed before real radio delivery")) return;
|
||||
m_Unit = unit; m_Root = vehicle.Entity; m_Queued = report;
|
||||
m_Payload = report.MountedAmmo.Snapshot(); m_Route = unit.Uplink; m_RoutePayload = m_Route.Payload;
|
||||
Check(m_Payload != report.MountedAmmo && Same(m_Payload, report.MountedAmmo)
|
||||
&& m_RoutePayload.Contains("mounted ammunition="), "queued counts copied without mutating sender or radio payload");
|
||||
}
|
||||
protected ERR_SupplyConvoyTask Candidate(ERR_HQ hq)
|
||||
{
|
||||
for (int i = 0; i < hq.Convoys().Count() && i < 3; i++)
|
||||
{
|
||||
ERR_SupplyConvoyTask task = ERR_SupplyConvoyTask.Cast(hq.Convoys().At(i));
|
||||
if (m_MineStock && m_ProofTask && task != m_ProofTask) continue;
|
||||
if (!task || task.Stopped || !task.Ready || !task.MagazinesIssued || !task.Receipt || task.Vehicles.Count() != 6 || task.Cargo.Count() > 128) continue;
|
||||
bool finished = true;
|
||||
foreach (ERR_ConvoyCargoCallback pending : task.Cargo) if (!pending || !pending.Finished) finished = false;
|
||||
if (!finished) continue;
|
||||
// If an initial report was already observed, prove that same convoy's roots.
|
||||
if (m_Queued)
|
||||
{
|
||||
bool ownsRoot;
|
||||
foreach (ERR_ConvoyVehicle vehicle : task.Vehicles) if (vehicle && vehicle.Entity == m_Root) ownsRoot = true;
|
||||
if (!ownsRoot) continue;
|
||||
}
|
||||
if (m_MineStock)
|
||||
{
|
||||
// Pin the first ordinary eligible convoy; absent optional cargo must not
|
||||
// select a different fleet or change the original fixed proof deadline.
|
||||
if (!m_ProofTask) m_ProofTask = task;
|
||||
if (!m_MineBatch) m_MineBatch = task.MineStock;
|
||||
if (m_MineBatch && task.MineStock != m_MineBatch)
|
||||
{ Check(false, "original pending optional mine batch replaced"); return null; }
|
||||
if (!m_MineBatch || !m_MineBatch.Complete()) return null;
|
||||
}
|
||||
return task;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
protected bool MineCustody(IEntity item, IEntity truck, array<IEntity> items)
|
||||
{
|
||||
if (!ERR_InfantryMineTransfer.ReadyMine(item) || !items.Contains(item)) return false;
|
||||
if (!item.FindComponent(DamageManagerComponent)) return false;
|
||||
InventoryItemComponent carried = InventoryItemComponent.Cast(item.FindComponent(InventoryItemComponent));
|
||||
if (!carried) return false;
|
||||
InventoryStorageSlot slot = carried.GetParentSlot();
|
||||
if (!slot || slot.GetAttachedEntity() != item || !slot.GetStorage()) return false;
|
||||
if (slot.GetStorage().GetSlot(slot.GetID()) != slot) return false;
|
||||
return ERR_InfantryAmmoTransfer.StoredUnder(item, truck);
|
||||
}
|
||||
protected bool Mines(ERR_SupplyConvoyTask task, bool capture)
|
||||
{
|
||||
if (!m_MineStock) return true;
|
||||
if (!Check(task && !task.Stopped && task.Ready && task.MagazinesIssued && task.Vehicles.Count() == 6,
|
||||
"mine proof retains ready original production convoy")) return false;
|
||||
ERR_ConvoyVehicle truck = task.Vehicles[1];
|
||||
ERR_ConvoyMineStock batch = task.MineStock;
|
||||
if (!Check(truck && truck.Entity && truck.Registered && !truck.Released && batch && batch.Complete(),
|
||||
"original truck optional mine batch closed")) return false;
|
||||
int count = batch.Count();
|
||||
if (!Check(count >= 1 && count <= 2, "one or two exact initial PMN4 identities available; no stock fabricated")) return false;
|
||||
InventoryStorageManagerComponent inventory = InventoryStorageManagerComponent.Cast(truck.Entity.FindComponent(InventoryStorageManagerComponent));
|
||||
if (!Check(inventory && inventory.GetOwner() == truck.Entity && task.Cargo.Count() <= 128,
|
||||
"original mine truck inventory and primary callback bounds")) return false;
|
||||
array<IEntity> items = {}; ERR_Inventory.Items(inventory, items);
|
||||
if (!Check(items.Count() <= 128, "mine physical inventory enumeration bounded")) return false;
|
||||
if (capture)
|
||||
{
|
||||
if (!Check(!m_MineBatch || m_MineBatch == batch, "same original mine batch at capture")) return false;
|
||||
m_MineBatch = batch; m_MineTruck = truck; m_MineInventory = inventory;
|
||||
for (int primary = 0; primary < task.Cargo.Count(); primary++) m_PrimaryCargo.Insert(task.Cargo[primary]);
|
||||
}
|
||||
else if (!Check(batch == m_MineBatch && truck == m_MineTruck && inventory == m_MineInventory
|
||||
&& count == m_Mines.Count() && task.Cargo.Count() == m_PrimaryCargo.Count(), "original mine batch, truck, count and primary callbacks unchanged through radio delivery")) return false;
|
||||
for (int cargo = 0; cargo < task.Cargo.Count(); cargo++)
|
||||
if (!Check(task.Cargo[cargo] && task.Cargo[cargo].Finished && task.Cargo[cargo] == m_PrimaryCargo[cargo],
|
||||
"higher-priority primary cargo remains settled and unchanged")) return false;
|
||||
array<IEntity> unique = {};
|
||||
for (int index = 0; index < count; index++)
|
||||
{
|
||||
IEntity item = batch.At(index);
|
||||
if (!Check(item && !unique.Contains(item)
|
||||
&& MineCustody(item, truck.Entity, items), "unique original callback-proved inactive PMN4 retains reciprocal truck storage custody")) return false;
|
||||
unique.Insert(item);
|
||||
if (capture) m_Mines.Insert(item);
|
||||
else if (!Check(m_Mines[index] == item, "exact initial PMN4 snapshot identity unchanged")) return false;
|
||||
}
|
||||
PrintFormat("ERR MINE STOCK PROOF: capture=%1 originals=%2 primary=%3; read-only, no transfer proof", capture, count, task.Cargo.Count());
|
||||
return true;
|
||||
}
|
||||
protected bool Fleet(ERR_HQ hq)
|
||||
{
|
||||
ERR_SupplyConvoyTask task = Candidate(hq);
|
||||
if (!task) return false;
|
||||
if (!Check(task.Vehicles.Count() == 6, "six original production roots in selected convoy")) return false;
|
||||
bool armed;
|
||||
for (int slot = 0; slot < 6; slot++)
|
||||
{
|
||||
ERR_ConvoyVehicle vehicle = task.Vehicles[slot];
|
||||
if (!Check(vehicle && Original(vehicle, hq.ERR_MountedFixtureUnit(vehicle.Group)), "root retains original admitted seated crew and ledger")) return false;
|
||||
ERR_HQMountedAmmoSnapshot sample = ERR_HQMountedAmmoSampler.Inspect(vehicle.Entity);
|
||||
if (!Check(sample && sample.Valid(), "native root returns bounded valid snapshot")) return false;
|
||||
PrintFormat("ERR MOUNTED SAMPLE: source=%1 slot=%2 complete=%3 weapons=%4 muzzles=%5 magazines=%6", task.Receipt.SourceId, slot, sample.Complete, sample.Weapons, sample.Muzzles, sample.Magazines);
|
||||
PrintFormat("ERR MOUNTED COUNTS: slot=%1 rounds=%2 capacity=%3 chambers=%4 low=%5", slot, sample.Rounds, sample.Capacity, sample.Chambers, sample.LowMagazines);
|
||||
if (sample.Weapons > 0 && sample.Magazines > 0) armed = true;
|
||||
if (slot == 1)
|
||||
{
|
||||
InventoryStorageManagerComponent inventory = InventoryStorageManagerComponent.Cast(vehicle.Entity.FindComponent(InventoryStorageManagerComponent));
|
||||
if (!Check(inventory != null, "original ammo truck storage present")) return false;
|
||||
array<IEntity> cargo = {}; inventory.GetItems(cargo, EStoragePurpose.PURPOSE_DEPOSIT);
|
||||
if (!Check(cargo.Count() <= 128, "cargo proof inspection is bounded")) return false;
|
||||
int cargoWeapons;
|
||||
foreach (IEntity item : cargo)
|
||||
if (item && BaseWeaponComponent.Cast(item.FindComponent(BaseWeaponComponent))) cargoWeapons++;
|
||||
if (!Check(cargoWeapons >= 8 && sample.Complete && sample.Weapons == 0 && sample.Magazines == 0
|
||||
&& sample.Rounds == 0 && sample.Capacity == 0 && sample.Chambers == 0, "eight physical cargo weapons excluded from unarmed truck snapshot")) return false;
|
||||
}
|
||||
}
|
||||
if (!Check(armed, "actual installed weapon magazines sampled in production convoy")) return false;
|
||||
if (!Mines(task, true)) return false;
|
||||
m_ProofTask = task;
|
||||
PrintFormat("ERR MOUNTED SCOPE: checked=1 original convoy, deployed=%1 configured=%2; remaining fleet reliability not qualified", hq.Convoys().Count(), hq.SupplyConvoys().Target());
|
||||
return true;
|
||||
}
|
||||
int Tick(ERR_HQ hq, float now)
|
||||
{
|
||||
if (m_Stopped || m_Failed) return -1;
|
||||
if (!m_Mode || m_Mode != ERR_GameMode.Get() || !m_Mode.Active()) return -1;
|
||||
if (now > m_Deadline)
|
||||
{
|
||||
if (m_MineStock) Check(false, "fixed 180-second mine-stock and radio proof deadline; original stock or delivery unavailable");
|
||||
else Check(false, "fixed 180-second proof deadline");
|
||||
return -1;
|
||||
}
|
||||
if (!hq || !hq.Convoys() || !hq.SupplyConvoys()) return 0;
|
||||
if (!CheckTarget(hq)) return -1;
|
||||
if (m_ProofTask && m_ProofTask.Stopped) { Check(false, "selected original convoy retained through proof"); return -1; }
|
||||
if (now >= m_NextLog)
|
||||
{
|
||||
PrintFormat("ERR MOUNTED WAIT: fleet=%1 ready=%2 queued=%3 remaining=%4", hq.Convoys().Count(), m_FleetReady, m_Queued != null, m_Deadline - now);
|
||||
PrintFormat("ERR MOUNTED PRODUCTION: %1", hq.SupplyConvoys().Status());
|
||||
m_NextLog = now + 10000;
|
||||
}
|
||||
if (m_SwapEligibility)
|
||||
{
|
||||
if (!m_ProofTask) m_ProofTask = Candidate(hq);
|
||||
if (!m_ProofTask) return 0;
|
||||
int eligibility = m_SwapProbe.Tick(m_Mode, hq, m_ProofTask);
|
||||
if (eligibility < 0) { Check(false, "swap eligibility unavailable or native refusal; no radio-delivery qualification"); return -1; }
|
||||
return eligibility;
|
||||
}
|
||||
// Observe queues during fleet preparation too, so fast initial deliveries are not missed.
|
||||
for (int convoy = 0; convoy < hq.Convoys().Count() && convoy < 3; convoy++)
|
||||
{
|
||||
ERR_ConvoyTask task = hq.Convoys().At(convoy);
|
||||
if (!task || (m_ProofTask && task != m_ProofTask)) continue;
|
||||
for (int slot = 0; slot < task.Vehicles.Count() && slot < 6; slot++) Capture(hq, task.Vehicles[slot], now);
|
||||
}
|
||||
if (!m_FleetReady) m_FleetReady = Fleet(hq);
|
||||
if (m_Failed) return -1;
|
||||
if (!m_FleetReady || !m_Queued) return 0;
|
||||
ERR_HQWatchEntry delivered = hq.Watch().Find(m_Queued.SourceId);
|
||||
if (!delivered || delivered.MessageId < m_Queued.MessageId)
|
||||
{
|
||||
if (m_Unit.PendingStatus != m_Queued && m_Unit.Uplink != m_Route)
|
||||
{
|
||||
Check(true, "interrupted observed transmission created no matching HQ knowledge; wait for another natural report");
|
||||
Forget();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
if (!Check(delivered.MessageId == m_Queued.MessageId && delivered.MountedAmmo
|
||||
&& delivered.MountedAmmo != m_Queued.MountedAmmo && delivered.MountedAmmo != m_Payload
|
||||
&& Same(delivered.MountedAmmo, m_Payload) && Same(m_Queued.MountedAmmo, m_Payload), "actual HQ Watch holds separate copy of the exact queued counts")) return -1;
|
||||
if (!Check(delivered.ObservedAt == m_Queued.ObservedAt && delivered.LastDeliveredAt >= delivered.ObservedAt
|
||||
&& delivered.LastDeliveredAt <= now && delivered.LastDeliveredAt - delivered.ObservedAt <= 120000
|
||||
&& delivered.Strength == m_Queued.Strength && delivered.Count == m_Queued.Count
|
||||
&& delivered.Fit == m_Queued.Fit && m_Route.MessageId == m_Queued.MessageId
|
||||
&& m_Route.Payload == m_RoutePayload, "delivered observation age, roster counts and radio payload preserved")) return -1;
|
||||
if (!Check(hq.ERR_MountedFixtureUnit(m_Unit.Group) == m_Unit && ERR_Actors.Alive(m_Root), "original source and root retained through delivery")) return -1;
|
||||
if (!Mines(m_ProofTask, false)) return -1;
|
||||
return 1;
|
||||
}
|
||||
protected bool CheckTarget(ERR_HQ hq)
|
||||
{
|
||||
if (hq.SupplyConvoys().Target() == 3 && hq.Convoys().Count() <= 3) return true;
|
||||
return Check(false, "unchanged default three-convoy production target");
|
||||
}
|
||||
protected void Forget() { m_Unit = null; m_Root = null; m_Queued = null; m_Payload = null; m_Route = null; m_RoutePayload = string.Empty; }
|
||||
void Stop()
|
||||
{
|
||||
m_Stopped = true; if (m_SwapProbe) m_SwapProbe.Stop();
|
||||
m_ProofTask = null; m_MineBatch = null; m_MineTruck = null; m_MineInventory = null;
|
||||
m_Mines.Clear(); m_PrimaryCargo.Clear(); Forget();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
check: /tmp/err-policy-l9ox501m/check.cpp:134: int main(): Assertion `!f.p.Mines(&f.task,true)&&f.p.m_Failed' failed.
|
||||
Traceback (most recent call last):
|
||||
File "/tmp/erri-mine-stock-native-1821/tests/test_native_convoy_mine_stock.py", line 33, in <module>
|
||||
run(r'''
|
||||
~~~^^^^^
|
||||
#include <cassert>
|
||||
^^^^^^^^^^^^^^^^^^
|
||||
...<47 lines>...
|
||||
}
|
||||
^
|
||||
''')
|
||||
^^^^
|
||||
File "/home/jakub/devel/escapistsrereintroduced/tests/policy_harness.py", line 14, in run
|
||||
subprocess.run([str(p/'check')],check=True)
|
||||
~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
File "/usr/lib/python3.14/subprocess.py", line 578, in run
|
||||
raise CalledProcessError(retcode, process.args,
|
||||
output=stdout, stderr=stderr)
|
||||
subprocess.CalledProcessError: Command '['/tmp/err-policy-l9ox501m/check']' died with <Signals.SIGABRT: 6>.
|
||||
+306
@@ -0,0 +1,306 @@
|
||||
#ifdef WORKBENCH
|
||||
// Read-only fixture access to the actual production sender; never initiates a report.
|
||||
modded class ERR_HQ
|
||||
{
|
||||
ERR_HQUnit ERR_MountedFixtureUnit(SCR_AIGroup group)
|
||||
{
|
||||
if (!ERR_NativeMountedAmmoProbe.Enabled() || !group) return null;
|
||||
for (int i = 0; i < m_Units.Count() && i < 256; i++)
|
||||
if (m_Units[i].Group == group) return m_Units[i];
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// WORKBENCH-only read access to the exact successful startup callback identity.
|
||||
modded class ERR_ConvoyMineStock
|
||||
{
|
||||
bool ERR_FixtureMine(ERR_SupplyConvoyTask task, ERR_ConvoyVehicle original, IEntity item)
|
||||
{
|
||||
if (!m_Closed || task != m_Task || original != m_Original || !original || original.Entity != m_Truck) return false;
|
||||
if (!m_Truck || !item || !m_Items.Contains(item) || m_Cargo.Count() > 2 || !m_Inventory || m_Inventory.GetOwner() != m_Truck) return false;
|
||||
if (m_Truck.FindComponent(InventoryStorageManagerComponent) != m_Inventory) return false;
|
||||
foreach (ERR_ConvoyMineCargo operation : m_Cargo)
|
||||
if (operation && operation.Finished && operation.Succeeded && operation.Item == item) return true;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
class ERR_NativeMountedAmmoProbe
|
||||
{
|
||||
protected ERR_GameMode m_Mode;
|
||||
protected float m_Deadline;
|
||||
protected float m_NextLog;
|
||||
protected bool m_Failed;
|
||||
protected bool m_Stopped;
|
||||
protected bool m_FleetReady;
|
||||
protected bool m_SwapEligibility;
|
||||
protected bool m_MineStock;
|
||||
protected ref ERR_ConvoyMineStock m_MineBatch;
|
||||
protected ref ERR_ConvoyVehicle m_MineTruck;
|
||||
protected InventoryStorageManagerComponent m_MineInventory;
|
||||
protected ref array<IEntity> m_Mines = {};
|
||||
protected ref array<ref ERR_ConvoyCargoCallback> m_PrimaryCargo = {};
|
||||
protected ref ERR_NativeMountedSwapProbe m_SwapProbe;
|
||||
protected ref ERR_SupplyConvoyTask m_ProofTask;
|
||||
protected ERR_HQUnit m_Unit;
|
||||
protected IEntity m_Root;
|
||||
protected ref ERR_HQStatusReport m_Queued;
|
||||
protected ref ERR_HQMountedAmmoSnapshot m_Payload;
|
||||
protected ref ERR_HQRoute m_Route;
|
||||
protected string m_RoutePayload;
|
||||
static bool Enabled()
|
||||
{
|
||||
string enabled, outcome;
|
||||
return Replication.IsServer() && System.GetCLIParam("errSmoke", enabled) && enabled == "1"
|
||||
&& System.GetCLIParam("errSmokeOutcome", outcome) && outcome == "mounted-ammo";
|
||||
}
|
||||
void ERR_NativeMountedAmmoProbe(ERR_GameMode mode, float now)
|
||||
{
|
||||
m_Mode = mode; m_Deadline = now + 180000;
|
||||
string swap, mines, courier;
|
||||
m_MineStock = System.GetCLIParam("errMineStock", mines) && mines == "1";
|
||||
m_SwapEligibility = System.GetCLIParam("errMountedSwapEligibility", swap) && swap == "1";
|
||||
if (m_MineStock && (m_SwapEligibility || (System.GetCLIParam("errMountedCourier", courier) && courier == "1")))
|
||||
Check(false, "mine-stock proof requires the normal mounted radio path, without swap or courier flags");
|
||||
if (m_SwapEligibility) m_SwapProbe = new ERR_NativeMountedSwapProbe();
|
||||
}
|
||||
bool SwapEligibility() { return m_SwapEligibility; }
|
||||
static string CompletionText(bool swapEligibility)
|
||||
{
|
||||
if (swapEligibility) return "ERR SMOKE COMPLETE: native mounted swap eligibility only; no transfer or radio proof; explicit fixture reset";
|
||||
return "ERR SMOKE COMPLETE: production fleet mounted ammunition, cargo exclusion and actual radio delivery; explicit fixture reset";
|
||||
}
|
||||
protected bool Check(bool condition, string detail)
|
||||
{
|
||||
if (condition) { Print("ERR SMOKE PASS: mounted ammo " + detail); return true; }
|
||||
m_Failed = true; Print("ERR SMOKE FAIL: mounted ammo " + detail, LogLevel.ERROR); return false;
|
||||
}
|
||||
protected bool Same(ERR_HQMountedAmmoSnapshot a, ERR_HQMountedAmmoSnapshot b)
|
||||
{
|
||||
return a && b && a.Complete == b.Complete && a.Weapons == b.Weapons && a.Muzzles == b.Muzzles
|
||||
&& a.Magazines == b.Magazines && a.Rounds == b.Rounds && a.Capacity == b.Capacity
|
||||
&& a.Chambers == b.Chambers && a.LowMagazines == b.LowMagazines;
|
||||
}
|
||||
protected bool Original(ERR_ConvoyVehicle vehicle, ERR_HQUnit unit)
|
||||
{
|
||||
if (!vehicle || !unit || !vehicle.Registered || vehicle.Released || !vehicle.Entity || !vehicle.Group
|
||||
|| vehicle.Members.Count() > 32 || unit.Group != vehicle.Group || !unit.StatusSampler || !unit.StatusSampler.OwnsRoster(vehicle.Group)) return false;
|
||||
ERR_ForceRecord record = m_Mode.Forces().FindGroup(vehicle.Group);
|
||||
if (!record || record.Kind != ERR_ForceKind.CONVOY || !record.Physical || record.Eliminated
|
||||
|| record.SourceId != unit.StatusSampler.InitialSourceId() || record.InitialStrength != vehicle.Members.Count()
|
||||
|| unit.StatusSampler.InitialStrength() != vehicle.Members.Count()) return false;
|
||||
foreach (IEntity member : vehicle.Members)
|
||||
{
|
||||
bool original;
|
||||
for (int slot = 0; slot < unit.StatusSampler.InitialStrength(); slot++)
|
||||
if (unit.StatusSampler.InitialMember(slot) == member) original = true;
|
||||
if (!original || !ERR_Actors.Alive(member) || ERR_Actors.Group(member) != vehicle.Group
|
||||
|| !ERR_ConvoyRules.PartOf(CompartmentAccessComponent.GetVehicleIn(member), vehicle.Entity)) return false;
|
||||
}
|
||||
return !vehicle.Members.IsEmpty();
|
||||
}
|
||||
protected void Capture(ERR_HQ hq, ERR_ConvoyVehicle vehicle, float now)
|
||||
{
|
||||
if (m_Queued || !vehicle || !vehicle.Registered) return;
|
||||
ERR_HQUnit unit = hq.ERR_MountedFixtureUnit(vehicle.Group);
|
||||
if (!Original(vehicle, unit) || !unit.PendingStatus || !unit.Uplink) return;
|
||||
ERR_HQStatusReport report = unit.PendingStatus;
|
||||
if (!report.MountedAmmo || report.MountedAmmo.Weapons < 1 || report.MountedAmmo.Magazines < 1) return;
|
||||
ERR_HQWatchEntry before = hq.Watch().Find(report.SourceId);
|
||||
if (before && before.MessageId >= report.MessageId) return;
|
||||
if (!Check(ERR_HQWatchRules.Valid(report, now) && report.SourceId == unit.StatusSampler.InitialSourceId()
|
||||
&& unit.Uplink.MessageId == report.MessageId && unit.Uplink.Cursor < unit.Uplink.Nodes.Count(), "original mounted payload observed before real radio delivery")) return;
|
||||
m_Unit = unit; m_Root = vehicle.Entity; m_Queued = report;
|
||||
m_Payload = report.MountedAmmo.Snapshot(); m_Route = unit.Uplink; m_RoutePayload = m_Route.Payload;
|
||||
Check(m_Payload != report.MountedAmmo && Same(m_Payload, report.MountedAmmo)
|
||||
&& m_RoutePayload.Contains("mounted ammunition="), "queued counts copied without mutating sender or radio payload");
|
||||
}
|
||||
protected ERR_SupplyConvoyTask Candidate(ERR_HQ hq)
|
||||
{
|
||||
for (int i = 0; i < hq.Convoys().Count() && i < 3; i++)
|
||||
{
|
||||
ERR_SupplyConvoyTask task = ERR_SupplyConvoyTask.Cast(hq.Convoys().At(i));
|
||||
if (m_MineStock && m_ProofTask && task != m_ProofTask) continue;
|
||||
if (!task || task.Stopped || !task.Ready || !task.MagazinesIssued || !task.Receipt || task.Vehicles.Count() != 6 || task.Cargo.Count() > 128) continue;
|
||||
bool finished = true;
|
||||
foreach (ERR_ConvoyCargoCallback pending : task.Cargo) if (!pending || !pending.Finished) finished = false;
|
||||
if (!finished) continue;
|
||||
// If an initial report was already observed, prove that same convoy's roots.
|
||||
if (m_Queued)
|
||||
{
|
||||
bool ownsRoot;
|
||||
foreach (ERR_ConvoyVehicle vehicle : task.Vehicles) if (vehicle && vehicle.Entity == m_Root) ownsRoot = true;
|
||||
if (!ownsRoot) continue;
|
||||
}
|
||||
if (m_MineStock)
|
||||
{
|
||||
// Pin the first ordinary eligible convoy; absent optional cargo must not
|
||||
// select a different fleet or change the original fixed proof deadline.
|
||||
if (!m_ProofTask) m_ProofTask = task;
|
||||
if (!m_MineBatch) m_MineBatch = task.MineStock;
|
||||
if (m_MineBatch && task.MineStock != m_MineBatch)
|
||||
{ Check(false, "original pending optional mine batch replaced"); return null; }
|
||||
if (!m_MineBatch || !m_MineBatch.Complete()) return null;
|
||||
}
|
||||
return task;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
protected bool MineCustody(IEntity item, IEntity truck, array<IEntity> items)
|
||||
{
|
||||
if (!ERR_InfantryMineTransfer.ReadyMine(item) || !items.Contains(item)) return false;
|
||||
if (!item.FindComponent(DamageManagerComponent)) return false;
|
||||
InventoryItemComponent carried = InventoryItemComponent.Cast(item.FindComponent(InventoryItemComponent));
|
||||
if (!carried) return false;
|
||||
InventoryStorageSlot slot = carried.GetParentSlot();
|
||||
if (!slot || slot.GetAttachedEntity() != item || !slot.GetStorage()) return false;
|
||||
if (slot.GetStorage().GetSlot(slot.GetID()) != slot) return false;
|
||||
return ERR_InfantryAmmoTransfer.StoredUnder(item, truck);
|
||||
}
|
||||
protected bool Mines(ERR_SupplyConvoyTask task, bool capture)
|
||||
{
|
||||
if (!m_MineStock) return true;
|
||||
if (!Check(task && !task.Stopped && task.Ready && task.MagazinesIssued && task.Vehicles.Count() == 6,
|
||||
"mine proof retains ready original production convoy")) return false;
|
||||
ERR_ConvoyVehicle truck = task.Vehicles[1];
|
||||
ERR_ConvoyMineStock batch = task.MineStock;
|
||||
if (!Check(truck && truck.Entity && truck.Registered && !truck.Released && batch && batch.Complete(),
|
||||
"original truck optional mine batch closed")) return false;
|
||||
int count = batch.Count();
|
||||
if (!Check(count >= 0 && count <= 2, "one or two exact initial PMN4 identities available; no stock fabricated")) return false;
|
||||
InventoryStorageManagerComponent inventory = InventoryStorageManagerComponent.Cast(truck.Entity.FindComponent(InventoryStorageManagerComponent));
|
||||
if (!Check(inventory && inventory.GetOwner() == truck.Entity && task.Cargo.Count() <= 128,
|
||||
"original mine truck inventory and primary callback bounds")) return false;
|
||||
array<IEntity> items = {}; ERR_Inventory.Items(inventory, items);
|
||||
if (!Check(items.Count() <= 128, "mine physical inventory enumeration bounded")) return false;
|
||||
if (capture)
|
||||
{
|
||||
if (!Check(!m_MineBatch || m_MineBatch == batch, "same original mine batch at capture")) return false;
|
||||
m_MineBatch = batch; m_MineTruck = truck; m_MineInventory = inventory;
|
||||
for (int primary = 0; primary < task.Cargo.Count(); primary++) m_PrimaryCargo.Insert(task.Cargo[primary]);
|
||||
}
|
||||
else if (!Check(batch == m_MineBatch && truck == m_MineTruck && inventory == m_MineInventory
|
||||
&& count == m_Mines.Count() && task.Cargo.Count() == m_PrimaryCargo.Count(), "original mine batch, truck, count and primary callbacks unchanged through radio delivery")) return false;
|
||||
for (int cargo = 0; cargo < task.Cargo.Count(); cargo++)
|
||||
if (!Check(task.Cargo[cargo] && task.Cargo[cargo].Finished && task.Cargo[cargo] == m_PrimaryCargo[cargo],
|
||||
"higher-priority primary cargo remains settled and unchanged")) return false;
|
||||
array<IEntity> unique = {};
|
||||
for (int index = 0; index < count; index++)
|
||||
{
|
||||
IEntity item = batch.At(index);
|
||||
if (!Check(item && !unique.Contains(item) && batch.ERR_FixtureMine(task, truck, item)
|
||||
&& MineCustody(item, truck.Entity, items), "unique original callback-proved inactive PMN4 retains reciprocal truck storage custody")) return false;
|
||||
unique.Insert(item);
|
||||
if (capture) m_Mines.Insert(item);
|
||||
else if (!Check(m_Mines[index] == item, "exact initial PMN4 snapshot identity unchanged")) return false;
|
||||
}
|
||||
PrintFormat("ERR MINE STOCK PROOF: capture=%1 originals=%2 primary=%3; read-only, no transfer proof", capture, count, task.Cargo.Count());
|
||||
return true;
|
||||
}
|
||||
protected bool Fleet(ERR_HQ hq)
|
||||
{
|
||||
ERR_SupplyConvoyTask task = Candidate(hq);
|
||||
if (!task) return false;
|
||||
if (!Check(task.Vehicles.Count() == 6, "six original production roots in selected convoy")) return false;
|
||||
bool armed;
|
||||
for (int slot = 0; slot < 6; slot++)
|
||||
{
|
||||
ERR_ConvoyVehicle vehicle = task.Vehicles[slot];
|
||||
if (!Check(vehicle && Original(vehicle, hq.ERR_MountedFixtureUnit(vehicle.Group)), "root retains original admitted seated crew and ledger")) return false;
|
||||
ERR_HQMountedAmmoSnapshot sample = ERR_HQMountedAmmoSampler.Inspect(vehicle.Entity);
|
||||
if (!Check(sample && sample.Valid(), "native root returns bounded valid snapshot")) return false;
|
||||
PrintFormat("ERR MOUNTED SAMPLE: source=%1 slot=%2 complete=%3 weapons=%4 muzzles=%5 magazines=%6", task.Receipt.SourceId, slot, sample.Complete, sample.Weapons, sample.Muzzles, sample.Magazines);
|
||||
PrintFormat("ERR MOUNTED COUNTS: slot=%1 rounds=%2 capacity=%3 chambers=%4 low=%5", slot, sample.Rounds, sample.Capacity, sample.Chambers, sample.LowMagazines);
|
||||
if (sample.Weapons > 0 && sample.Magazines > 0) armed = true;
|
||||
if (slot == 1)
|
||||
{
|
||||
InventoryStorageManagerComponent inventory = InventoryStorageManagerComponent.Cast(vehicle.Entity.FindComponent(InventoryStorageManagerComponent));
|
||||
if (!Check(inventory != null, "original ammo truck storage present")) return false;
|
||||
array<IEntity> cargo = {}; inventory.GetItems(cargo, EStoragePurpose.PURPOSE_DEPOSIT);
|
||||
if (!Check(cargo.Count() <= 128, "cargo proof inspection is bounded")) return false;
|
||||
int cargoWeapons;
|
||||
foreach (IEntity item : cargo)
|
||||
if (item && BaseWeaponComponent.Cast(item.FindComponent(BaseWeaponComponent))) cargoWeapons++;
|
||||
if (!Check(cargoWeapons >= 8 && sample.Complete && sample.Weapons == 0 && sample.Magazines == 0
|
||||
&& sample.Rounds == 0 && sample.Capacity == 0 && sample.Chambers == 0, "eight physical cargo weapons excluded from unarmed truck snapshot")) return false;
|
||||
}
|
||||
}
|
||||
if (!Check(armed, "actual installed weapon magazines sampled in production convoy")) return false;
|
||||
if (!Mines(task, true)) return false;
|
||||
m_ProofTask = task;
|
||||
PrintFormat("ERR MOUNTED SCOPE: checked=1 original convoy, deployed=%1 configured=%2; remaining fleet reliability not qualified", hq.Convoys().Count(), hq.SupplyConvoys().Target());
|
||||
return true;
|
||||
}
|
||||
int Tick(ERR_HQ hq, float now)
|
||||
{
|
||||
if (m_Stopped || m_Failed) return -1;
|
||||
if (!m_Mode || m_Mode != ERR_GameMode.Get() || !m_Mode.Active()) return -1;
|
||||
if (now > m_Deadline)
|
||||
{
|
||||
if (m_MineStock) Check(false, "fixed 180-second mine-stock and radio proof deadline; original stock or delivery unavailable");
|
||||
else Check(false, "fixed 180-second proof deadline");
|
||||
return -1;
|
||||
}
|
||||
if (!hq || !hq.Convoys() || !hq.SupplyConvoys()) return 0;
|
||||
if (!CheckTarget(hq)) return -1;
|
||||
if (m_ProofTask && m_ProofTask.Stopped) { Check(false, "selected original convoy retained through proof"); return -1; }
|
||||
if (now >= m_NextLog)
|
||||
{
|
||||
PrintFormat("ERR MOUNTED WAIT: fleet=%1 ready=%2 queued=%3 remaining=%4", hq.Convoys().Count(), m_FleetReady, m_Queued != null, m_Deadline - now);
|
||||
PrintFormat("ERR MOUNTED PRODUCTION: %1", hq.SupplyConvoys().Status());
|
||||
m_NextLog = now + 10000;
|
||||
}
|
||||
if (m_SwapEligibility)
|
||||
{
|
||||
if (!m_ProofTask) m_ProofTask = Candidate(hq);
|
||||
if (!m_ProofTask) return 0;
|
||||
int eligibility = m_SwapProbe.Tick(m_Mode, hq, m_ProofTask);
|
||||
if (eligibility < 0) { Check(false, "swap eligibility unavailable or native refusal; no radio-delivery qualification"); return -1; }
|
||||
return eligibility;
|
||||
}
|
||||
// Observe queues during fleet preparation too, so fast initial deliveries are not missed.
|
||||
for (int convoy = 0; convoy < hq.Convoys().Count() && convoy < 3; convoy++)
|
||||
{
|
||||
ERR_ConvoyTask task = hq.Convoys().At(convoy);
|
||||
if (!task || (m_ProofTask && task != m_ProofTask)) continue;
|
||||
for (int slot = 0; slot < task.Vehicles.Count() && slot < 6; slot++) Capture(hq, task.Vehicles[slot], now);
|
||||
}
|
||||
if (!m_FleetReady) m_FleetReady = Fleet(hq);
|
||||
if (m_Failed) return -1;
|
||||
if (!m_FleetReady || !m_Queued) return 0;
|
||||
ERR_HQWatchEntry delivered = hq.Watch().Find(m_Queued.SourceId);
|
||||
if (!delivered || delivered.MessageId < m_Queued.MessageId)
|
||||
{
|
||||
if (m_Unit.PendingStatus != m_Queued && m_Unit.Uplink != m_Route)
|
||||
{
|
||||
Check(true, "interrupted observed transmission created no matching HQ knowledge; wait for another natural report");
|
||||
Forget();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
if (!Check(delivered.MessageId == m_Queued.MessageId && delivered.MountedAmmo
|
||||
&& delivered.MountedAmmo != m_Queued.MountedAmmo && delivered.MountedAmmo != m_Payload
|
||||
&& Same(delivered.MountedAmmo, m_Payload) && Same(m_Queued.MountedAmmo, m_Payload), "actual HQ Watch holds separate copy of the exact queued counts")) return -1;
|
||||
if (!Check(delivered.ObservedAt == m_Queued.ObservedAt && delivered.LastDeliveredAt >= delivered.ObservedAt
|
||||
&& delivered.LastDeliveredAt <= now && delivered.LastDeliveredAt - delivered.ObservedAt <= 120000
|
||||
&& delivered.Strength == m_Queued.Strength && delivered.Count == m_Queued.Count
|
||||
&& delivered.Fit == m_Queued.Fit && m_Route.MessageId == m_Queued.MessageId
|
||||
&& m_Route.Payload == m_RoutePayload, "delivered observation age, roster counts and radio payload preserved")) return -1;
|
||||
if (!Check(hq.ERR_MountedFixtureUnit(m_Unit.Group) == m_Unit && ERR_Actors.Alive(m_Root), "original source and root retained through delivery")) return -1;
|
||||
if (!Mines(m_ProofTask, false)) return -1;
|
||||
return 1;
|
||||
}
|
||||
protected bool CheckTarget(ERR_HQ hq)
|
||||
{
|
||||
if (hq.SupplyConvoys().Target() == 3 && hq.Convoys().Count() <= 3) return true;
|
||||
return Check(false, "unchanged default three-convoy production target");
|
||||
}
|
||||
protected void Forget() { m_Unit = null; m_Root = null; m_Queued = null; m_Payload = null; m_Route = null; m_RoutePayload = string.Empty; }
|
||||
void Stop()
|
||||
{
|
||||
m_Stopped = true; if (m_SwapProbe) m_SwapProbe.Stop();
|
||||
m_ProofTask = null; m_MineBatch = null; m_MineTruck = null; m_MineInventory = null;
|
||||
m_Mines.Clear(); m_PrimaryCargo.Clear(); Forget();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
check: /tmp/err-policy-zc96n_2h/check.cpp:134: int main(): Assertion `!f.p.Mines(&f.task,true)&&f.p.m_Failed' failed.
|
||||
Traceback (most recent call last):
|
||||
File "/tmp/erri-mine-stock-native-1821/tests/test_native_convoy_mine_stock.py", line 33, in <module>
|
||||
run(r'''
|
||||
~~~^^^^^
|
||||
#include <cassert>
|
||||
^^^^^^^^^^^^^^^^^^
|
||||
...<47 lines>...
|
||||
}
|
||||
^
|
||||
''')
|
||||
^^^^
|
||||
File "/home/jakub/devel/escapistsrereintroduced/tests/policy_harness.py", line 14, in run
|
||||
subprocess.run([str(p/'check')],check=True)
|
||||
~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
File "/usr/lib/python3.14/subprocess.py", line 578, in run
|
||||
raise CalledProcessError(retcode, process.args,
|
||||
output=stdout, stderr=stderr)
|
||||
subprocess.CalledProcessError: Command '['/tmp/err-policy-zc96n_2h/check']' died with <Signals.SIGABRT: 6>.
|
||||
@@ -0,0 +1 @@
|
||||
Native finite mine-stock runner: parser, scope, exclusions and command pass
|
||||
+1
@@ -0,0 +1 @@
|
||||
PASS: actual optional candidate barrier, exact callback/custody proof and unchanged mine/primary snapshots; no native transfer claim
|
||||
+2
@@ -0,0 +1,2 @@
|
||||
PASS: actual bounded native mounted proof/detached payload/deadline/cleanup methods, production-only setup and isolated runner selector
|
||||
PASS: actual one-existing-convoy candidate readiness, sender-root identity, incomplete cargo refusal and fixed three-candidate bound
|
||||
@@ -0,0 +1,582 @@
|
||||
PASS: missing, child-only, malformed, zero and duplicate prefab root IDs rejected
|
||||
PASS: delayed scene/inventory arrival, deferred preload, identity checks, stale replies, timeout and observer cleanup
|
||||
PASS: actual inventory manifest, delayed/missing/wrong-owner item links, finite cap, consumed-stock refresh and preload ordering
|
||||
PASS: spawn scene remains held through final acknowledgement and nearby use; leaving, reassignment, disconnect and teardown release it
|
||||
PASS: production prison AI hold/release, repeat activation, authority/faction/player exclusion, dead actor and stop cleanup
|
||||
PASS: actual Tick clock initialization admits fractional first ticks and expires without extending the original start
|
||||
PASS: actual finite conservation/deadline/callback policies; read-only selection, bounded once-only inventory submission and no can refill; native transfer not executed
|
||||
PASS: actual exact-context membership, bounded identity/reach gates, native start/cache/eligibility ordering and no duplicate/foreign action start; fuel manager identity and empty-can headroom guards checked
|
||||
PASS: actual detached node/value snapshot and conservation refuse mismatched lengths before indexed reads, retain original identities under native out-array aliasing and log bounded counts once; native cause remains unknown
|
||||
PASS: actual mine evidence sealing/recovery, historical coarse publication, caps, canonical ownership, marker join retry/owner-change/stop; native arming and replicated vector-array transport untested
|
||||
PASS: actual full document recovery retains authored/sealed targets, one shared spent ledger, retry/exhaustion semantics and canonical multi-player ownership alongside supplemental mine intel
|
||||
PASS: actual infantry search suspension, quiet grace, finite resume, expiry/replacement and defensive/ownership boundaries
|
||||
PASS: infantry combat gate precedes radio delivery and preserves non-task transports
|
||||
PASS: actual HQ contact transition wakes only fit squad members, cancels only task orders and logs changes once
|
||||
PASS: actual finite medicine grants, authored stock deduction, full-backpack refusal/pouch fallback, no loot replenishment, unresolved-operation quarantine and ownership/stop guards
|
||||
PASS: only recent native detected/identified threats suspend hunter travel; stale/disarmed/destroyed contacts cannot strand patrols
|
||||
PASS: actual hunter combat transition cancels only its travel once, holds through renewed contact and resumes after quiet; unregistered startup preserved
|
||||
PASS: captured sighting retention, immutable details, expiry, replay rejection, bounded sound uncertainty/cooldown, radio loss, priority and overdue-status fairness
|
||||
PASS: arrow press/release, held keys, opposing keys, disabled/menu input and firearm-only retention
|
||||
PASS: town trigger and hard 700m exclusion for all observers, empty/invalid positions and final-check crossings
|
||||
PASS: exact finite site squads, invalid roster/count rejection, committed-site spacing and safe fallback boundary
|
||||
PASS: mortar couriers use the mobile site team and refuse permanent-only garrisons
|
||||
PASS: omitted preferred mortar depot selects a surviving owned camp/mobile team; no camp, foreign cache and permanent-only sites are unavailable; historical priority retained
|
||||
PASS: real-session mortar deadline, failed-support convoy admission and hunter survivor/recovery gates
|
||||
PASS: native-route retry preserves delivered target, limits attempts and suspends during combat
|
||||
PASS: stale/deleted AI utility cannot receive Complete; mortar HQ preflight withholds unsafe orders; mounted convoy cover never creates infantry Defend
|
||||
PASS: flight crew affiliation and group precede native boarding; preparation remains bounded even while passengers wait
|
||||
PASS: factionless/deleted map targets do not abort perception; faction lookup tolerates teardown; deleting helicopter releases without capture/engine access
|
||||
PASS: shoot adapter waits for a physical round; bounded same-shell retries, interrupted/never-started loads, committed no-retry, order/owner changes and normal native delegation
|
||||
PASS: missing/invalid faction crew defers before any native spawn or allowance insertion; all registered RHS factions have explicit soldier and medic profiles
|
||||
PASS: vehicle radio issued once; pending, refusal and looting cannot duplicate or fabricate a physical radio link
|
||||
PASS: actual vehicle-radio link requires the original seated crew, physical manpack and live uncaptured mission vehicle; looting, dismount, release and teardown remove it
|
||||
PASS: actual hunter release preserves survivors/HQ, releases driving ownership once, delegates capture/teardown, and excludes prison/patrol/mortar from generic objective defence
|
||||
PASS: real opening road geometry enforces wide azimuths; fresh delivered contact preempts patrol cooldown, respects radio failures and does not starve in-flight interception
|
||||
PASS: actual scoped 10% tighter REGULAR aim error and alert perception; preserves equipment multiplier and restores vanilla behavior when unbound
|
||||
PASS: physical inspection and parent-wreck retention; server-only searched/report delivery unlocks native cleanup once with a 300-second delay
|
||||
PASS: bounded same-group empty-spawn retries, no casualty refill, queue retirement, delivery-gated intel, prepared-team reuse, throttled diagnostics and LOD release
|
||||
PASS: production airborne memory confidence, persistence, ground coverage, confirmed losses, artillery veto, cooldown and invalid-input rules
|
||||
PASS: production cover retains the carried HQ target until its deadline; airport reload waits until the drop pass and cover have finished
|
||||
PASS: air logistics reservation preserves delivered search until radio handoff, excludes guards/combat/in-flight orders, and quarantines unresolved native loads/moves
|
||||
PASS: actual ammunition cargo selector handles empty rifle/machinegun/sniper magazines, preserves loaded variants, excludes auxiliary launchers and tolerates missing native metadata
|
||||
PASS: original 15-minute launch/loss cadence, active/captured timer disarm, saved delay reset, stop, 300m orbit and bounded close-contact standoff at 30/60/120 Hz
|
||||
PASS: actual aircraft-removal notification guards owner/server/active/stop and schedules one full delay without replay extension
|
||||
PASS: hill prominence/elevation, actual road edges/heights/bends and server-only finite scout admission, pending stock, timeout and no replacements/refills
|
||||
PASS: mortar duty scope excludes players, other crews, stopped/client/inactive states; only destruction releases an active assignment, while the gunner may approach the gun
|
||||
PASS: random mode restrictions, full numeric ranges, independent calendar dates and strict daylight boundaries
|
||||
PASS: actual killais eligibility includes the 1000m boundary, excludes players/retained bodies/dead/non-character entities and checks full 3D distance
|
||||
PASS: actual generation scheduler bounds each tick, enforces deadline/candidate ceiling, validates fallback, commits only accepted positions, skips only dispensable sites, preserves required objectives/intel, and resets the next search budget
|
||||
PASS: terrain placement samples world bounds, retains streaming candidates, bounds waits/work, rejects foreign fallbacks, preserves objectives/intel and validates completion
|
||||
PASS: actual navigation readiness supports static meshes, yields only for loadable streaming tiles and refuses unreachable positions
|
||||
PASS: universal connector, embedded/standalone exports, multiple terrains, stable IDs, native nav configs, missing-nav visibility, path validation and overwrite protection
|
||||
PASS: airfield detection accepts physical runways/towers and bounded authored markers, rejects unrelated props, water and out-of-world markers, and samples terrain height
|
||||
PASS: configured airport parsing, bounded readiness, stale admission rejection and cleanup wiring
|
||||
PASS: explicit CLI opt-in, disabled/editor guards and mission-header airport precedence
|
||||
PASS: singleton identity guards, paired faction deserialization and client world-cleanup wiring
|
||||
PASS: task/map/respawn getters survive delayed old destruction and preserve ordinary-mode behavior
|
||||
PASS: replication hierarchy refuses absent/aliased nodes and establishes delivery dependencies idempotently
|
||||
PASS: standalone old faction delegates collected once, with null/deleted owners ignored
|
||||
PASS: actual faction resolution reserves explicit roles, samples without replacement, substitutes disabled selections, and rejects duplicate/unknown/missing choices and insufficient pools
|
||||
PASS: Random all submits persistent random roles immediately; manual mixed choices, stale/unauthorized UI guards and debounce preserved
|
||||
PASS: actual content policy gates parent packs, individual factions, faction identity and finite group rotation with vanilla fallback
|
||||
PASS: actual delivered road eligibility, ahead projection without chords, reservations, stock road query bounds, terrain/water/obstruction refusal and clean outputs
|
||||
PASS: actual delivered-task lineage, expiry, old-order retention, native commit, release, road precision expiry and duplicate delivery
|
||||
PASS: actual original-roster local handoff,100m3D bound,busy carrier/budget exclusion,origin interruption including deletedsource,normal radio delivery and per-source replay history
|
||||
PASS: actual visual intake retains source/time/position/id, rejects replay, prefers usable own route, excludes simultaneous callers and conservatively resets negative-sweep dwell
|
||||
PASS: actual fixture local/radio gating, immutable source/time/position, interrupted-report exclusion and exact-owner cleanup
|
||||
PASS: local-handoff runner refuses wrong project/round count/insufficient deadline before runtime work
|
||||
PASS: actual fixture allocator terminal/unsubmitted guard, original-group lookup and both candidate gates
|
||||
PASS: actual report-derived waypoint insertion/order and tighter positive radii; no formation navigation claim
|
||||
PASS: actual Place/Stop waits native pose update, bounds four attempts, preserves original position, restores pending/settled placement and respects ownership/accepted-move quarantine
|
||||
PASS: actual fixture current/original recipient ownership, unresolved transfer cleanup, exact-token release and idempotent Stop
|
||||
PASS: actual fixture phased-cargo readiness, bounded callbacks, captured-stock mixed-caliber selection/continuation, reservation cleanup and component magazine counts
|
||||
PASS: actual inventory-fixture setup uses ordinary prison unlock before constructing its convoy-waiting probe; failed unlock cannot run fixture
|
||||
PASS: actual authored storage anchors, native trace flags, own-hierarchy exclusion, external wall/vehicle obstruction, range, unknown geometry and bounded context refusal
|
||||
PASS: actual convoy binding, finite identities, disjoint tokens, shared report replay/cooldown, original recipients and HQ cleanup
|
||||
PASS: actual finite convoy supply pool; immutable slots, shared demand state, sparse/capped discovery and permanent shutdown
|
||||
PASS: actual HQ rotates finite donors, skips unavailable/contacted trucks, uses delivered reports and dispatches at most one trip per planning cadence
|
||||
PASS: actual original turret identity, native/canonical guards, scoped maximum-skill profile, reset, dismount/reboard, requested-skill preservation and restoration
|
||||
PASS: bounded HQ startup/memory windows and outcome-specific full-route deadlines
|
||||
PASS: explicit escape-route skips only administrator stress, preserving original full-fixture wait/failure paths
|
||||
PASS: normal escape route keeps ordinary catalog and generated placement; historical selectors remain unchanged
|
||||
PASS: actual read migrates old valid settings, preserves explicit disabled state, rejects invalid data; next-round feedback and fixed menu remain honest
|
||||
PASS: actual automatic convoy timing/authority/admission/one-attempt/manual-task/stop policy; native deployment unproved
|
||||
PASS: late authoritative failure reason refreshes open result; detach, mode change and success subscriptions preserved
|
||||
infantry resupply actual rules, radio transitions, owned cleanup and unresolved-operation tests passed
|
||||
PASS: actual resupply Roster preserves permanent release, original slot mapping and bounded ownership
|
||||
PASS: actual one-mine original carrier selection, settled startup, shared finite claims, no refund after submission
|
||||
PASS: actual HQ startup grant readiness forwarding is authoritative and fail-closed
|
||||
PASS: actual finite PMN4 one-to-two entitlement, pinned original ownership, shared commit, physical custody, callback quarantine/deletion and no retry
|
||||
PASS: actual bounded empty-return and finite delivery; phase-isolated callbacks, exact ownership proof, stop quarantine and original actor/vehicle boundaries
|
||||
PASS: actual shared finite identity reservation; competing consumers, submission permanence, stale cleanup and96-item bound
|
||||
PASS: actual carried-mounted swap, shared committed claim, physical slot reach, exact two-way proof, uncertainty and terminal cleanup
|
||||
PASS: actual mounted pickup, exact finite ownership, pre-submission commit, physical custody, bounded callback and quarantine lifecycle; no native coverage claim
|
||||
PASS: actual mounted courier admission, radio, individual orders, two-stage transfer, reboarding, token cleanup and quarantine lifecycle
|
||||
PASS: actual scoped crew permit and native board completion/failure preserves foreign seats without teleport fallback
|
||||
PASS: actual shared mounted stock/history ownership, atomic exact HQ pair claim, and bounded stopped-owner proof polling
|
||||
PASS: actual carried/mounted early ammunition policy and status-first shared uplink; complete threshold, phases, cooldown, failures requested check-ins and non-urgent detached carried-mine status
|
||||
PASS: actual group radio startup preservation, finite native grants, callback quarantine, frozen selection/actor ownership and bounded observation
|
||||
PASS: actual maintenance native-stock check rejects missing/duplicate/wrong-identity/unowned/depleted/malformed stock and is read-only; native runtime not executed
|
||||
..................
|
||||
----------------------------------------------------------------------
|
||||
Ran 18 tests in 0.266s
|
||||
|
||||
OK
|
||||
PASS: actual radio node rejects current incapacitation, death, ownership and faction changes despite cached inventory; one-second capability refresh remains explicit
|
||||
PASS: Southern finite maintenance stock preserves weapons/clues and optional transport, historical Western fixture stays separate; native capacity/consumption untested
|
||||
PASS: optional transport deferred behind required readiness, bounded once-only spawn/omission, isolated cleanup, occupied-candidate retention and required-default preservation
|
||||
PASS: actual diagnostic fallback runs only on failed missing-context call, derives unique native pilot door, preserves stock eligibility and restores prior index on success/failure; diagnostics mutate no game state.
|
||||
PASS: actual native-prelude cleanup restores only original changed damage, refuses stale/incapacitated/aboard teleport; bounded five-seat/four-door fixture wiring checked. Native execution remains pending.
|
||||
PASS: actual CreateTransport requires successful scoped Configure after handbrake, preserves ordinary vehicles, tracks spawned entity before failures and never treats failed lock registration as ready.
|
||||
PASS: actual preparation Configure guards/idempotence/breach preservation, security eligibility/final current-body server mutation and all scoped action guards; all five seat/four door resource overrides. Native hold, prefab merge, replication and boarding remain unverified.
|
||||
PASS: production vehicle alarm single trigger/replica completion/no replay, fixed deadline/readiness wait, failed audio, dedicated server, moving exact handle, destruction/native end/deletion/clock and mission teardown. Native sound and multiplayer delivery require engine qualification.
|
||||
PASS: production alarm emitter/receiver original time/location, explicit native queue only, 32-entry cap, 50m local witness eligibility, bound perception, native-super preservation; actual engine broadcast/hearing remains unverified.
|
||||
PASS: actual optional candidate barrier, exact callback/custody proof and unchanged mine/primary snapshots; no native transfer claim
|
||||
Native finite mine-stock runner: parser, scope, exclusions and command pass
|
||||
PASS: actual bounded native mounted proof/detached payload/deadline/cleanup methods, production-only setup and isolated runner selector
|
||||
PASS: actual one-existing-convoy candidate readiness, sender-root identity, incomplete cargo refusal and fixed three-candidate bound
|
||||
PASS: actual once-only native dry query, exact before/after slots, native refusal, shutdown; shared bounded discovery and distinct opt-in verdict
|
||||
PASS: actual completion selector and pre-cleanup variant capture preserve separate radio and eligibility verdicts
|
||||
PASS: actual cargo diagnostic stages separate absent/foreign magazines, used/empty/invalid rounds, well mismatch and exact truck storage/attachment without mutation
|
||||
PASS: actual native courier witness rejects missing radio/custody/swap/reboard evidence; CLI opt-in bounded; native success remains unqualified
|
||||
PASS: actual courier constructor/Tick waits for preparation, returns before physical checks, preserves fixed deadline and sticky stop/failure; Enfusion startup awaits native verification
|
||||
PASS: actual arranged native alarm fixture deadline, single emit, natural-route observation, original timestamp/area/detail assertions, natural observer proximity/activation wait, failure cleanup and independent canonical-body restoration; native delivery itself remains unqualified.
|
||||
PASS: actual convoy cover observation/snapshot/uplink/HOLD/RESUME/cleanup transitions; native boundaries mocked, non-convoy runner opt-in refused
|
||||
Enemy optics actual-service ownership, preservation, callback, deadline and bounded-inspection policies passed
|
||||
PASS: actual delivered cover freshness/lineage/replay and canonical executor; owned waypoint-only hold, one resume at preserved route index, invalid ownership/crew/ledger refusal and fail-closed native recreation
|
||||
PASS: actual Stinger show/set/help state precise actor-roll effects; read-only help, bounded values, malformed syntax and failed-save preservation; no rerolls/gameplay edits and no native persistence claim
|
||||
PASS: new/retasked search and radio delivery ammo gates; active tasks and delivered release preserved
|
||||
HQ convoy delivered-report planning and downlink regressions passed
|
||||
PASS: actual own-inventory ammo inspection deduplicates loaded/carried/shared wells, separates chambers/launchers, freezes scalar snapshots and treats unsupported/capped/foreign inventory as unknown
|
||||
PASS: actual carried PMN4 inventory, original-owner guards, bounded deduplication, independent unknown state and detached counts
|
||||
PASS: actual mounted hierarchy sampling, ownership exclusion, deduplication, completeness/caps, quarter threshold and detached validation; no runtime policy or ammunition mutation
|
||||
PASS: actual HQ original convoy-root admission rejects wrong force/server/group and never supplies replacement lookup
|
||||
PASS: production mounted structural seat scan ignores >128 carried/cargo descendants, shares exact native mount/magazine ownership, preserves attachment seats and exact occupants, rejects unknown/cyclic/oversize structures; native binding still requires qualification.
|
||||
PASS: native body fixture uses existing immutable actors, real production LOS/queued uplink, pre-delivery isolation, actual status overlap, bounded cleanup and no fabricated reports/spawns
|
||||
PASS: actual native fixture lookup selects exact BODY kind/identity/message from bounded evaluations, never sighting-only Get
|
||||
PASS: actual ammo snapshot comparison checks every scalar/category flag; native probe requires real roster rescan, loaded-round lower bound and separate immutable pending/Watch objects
|
||||
PASS: actual delivered slot-union bodies preserve overlap/disjoint evidence, replay idempotence, status subset integrity, full-wipe closure and formation-local bounds
|
||||
test_review_added_allowed_media_invalidates_snapshot (__main__.ReviewTests.test_review_added_allowed_media_invalidates_snapshot) ... ok
|
||||
test_review_added_source_directory_rejected (__main__.ReviewTests.test_review_added_source_directory_rejected) ... ok
|
||||
test_review_loose_root_resource_and_symlink_rejected (__main__.ReviewTests.test_review_loose_root_resource_and_symlink_rejected) ... ok
|
||||
test_review_metadata_media_and_sidecars_remain_allowed_and_bound (__main__.ReviewTests.test_review_metadata_media_and_sidecars_remain_allowed_and_bound) ... ok
|
||||
test_review_missing_link_rejected (__main__.ReviewTests.test_review_missing_link_rejected) ... ok
|
||||
test_review_package_guard_sees_new_scripts (__main__.ReviewTests.test_review_package_guard_sees_new_scripts) ... ok
|
||||
test_review_retargeted_private_link_rejected (__main__.ReviewTests.test_review_retargeted_private_link_rejected) ... ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 7 tests in 0.065s
|
||||
|
||||
OK
|
||||
PASS: actual report methods reproduce old starvation; status-first scheduler delivers check-ins and requires 30s without combat or actual visible contacts before negative reports
|
||||
PASS: actual actor group lookup retains controlled character membership when seated/inherited vehicle agents differ; missing control or parent refuses
|
||||
.................
|
||||
----------------------------------------------------------------------
|
||||
Ran 17 tests in 3.399s
|
||||
|
||||
OK
|
||||
PASS: actual convoy motion thresholds, native-only proof boundaries, physical cargo/crew ownership and pre-launch runner restrictions
|
||||
PASS: actual filled rotated-footprint TraceBox and nine terrain/water samples; broad tree/cable bounds alone accepted, actual collision/nonfinite trace refused, nonzero sweep and ENTS/OCEAN flags, bounded diagnostic query and reset
|
||||
PASS: actual road interpolation/projection/orientation, six35m starts,200m forward tail, preserved bends, short/far/degenerate/nonfinite/overdense/hairpin refusal and deterministic candidate ties
|
||||
PASS: actual authenticated convoy dispatch, active/ready admission gates, canonical receipt, safe unconsumed preflight retry, pool refusal, retained partial failure and consumed no-retry
|
||||
PASS: actual native readiness exact membership, one-time per-vehicle ledger admission/reservation, partial readiness retry without duplicate records and one-pass56-item cargo allocation without replenishment
|
||||
PASS: actual per-vehicle readiness reasons, native agent/activity counts, intended-seat diagnostics, five-second throttle and read-only observation
|
||||
PASS: actual convoy dispatch validates before receipt consumption, consumes once before native mutation, retains all12 partial-failure paths, accepts the selected non-USSR enemy, and allocates exact19 bodies without capacity shrinking
|
||||
PASS: own memberless prefab disables automatic spawn before initialization; actual admission rejects populated, immediate or authored-slot templates before finite crew creation
|
||||
PASS: actual native seated-group arrival outside35m, native waypoint removal, idempotent advance, and convoy waypoint idempotence/arrival/deadline, missing/dead/captured/reparented crew refusal, failed native waypoint release, original vehicle/member preservation and no replacement
|
||||
PASS: actual convoy receipt identity/one-use, shared60-body and128-formation caps, outstanding/native-ledger accounting, exact19-body composition, source reuse, mode/client guards and no consumed receipt refunds
|
||||
PASS: actual supply route cycling/arrival/stops, finite startup bounds, contact freshness, dismount hold, quiet interval, interrupted boarding, timeout and lost-truck release
|
||||
PASS: moving-convoy perception boundaries and scoped individual/group abandonment priorities
|
||||
PASS: actual supply startup reasons expose unchanged body budget/requirement, journal only failure changes, preserve retry cadence/caps and report the true final refusal
|
||||
PASS: actual StartOne plus actual pool preserve unconsumed receipt retry, reject consumed replay, skip impossible new-budget surveys, retain equality, retry caps and journal dedup; no FPS claim
|
||||
PASS: actual admission seeds use exact installed loaded prefab, reject replacement/foreign/projectile paths and preserve bounded immutable identity
|
||||
PASS: actual primary-before-mounted one-shot batch, shared96/128 caps, physical snapshot headroom, original ownership, callback refusal and admission pinning
|
||||
PASS: actual bounded HQ query validates only existing original binding without admission or replacement lookup
|
||||
PASS: exact optional PMN4 startup, primary callback independence, original owner,128 capacity/callback limits, terminal no-retry and callback-proven freeze
|
||||
PASS: production convoy spacing, physical arrival, stable follower targets, supply ownership, leader promotion and bounded stuck recovery
|
||||
PASS: convoy combat keeps native manoeuvres for unchanged contacts and refreshes when contact moves
|
||||
PASS: native convoy proof excludes pre-departure movement and ends via explicit fixture reset, not prohibited player death
|
||||
PASS: boarding retries only after approach/seat progress stops, capped at three, with delayed native reissue and completed-team preservation
|
||||
PASS: slow only owned vehicles near fit dismounted infantry; ignore passengers, casualties and released teams/vehicles
|
||||
PASS: restore missing native driving registration only for healthy owned seated crews; preserve existing association and refuse invalid/released vehicles
|
||||
PASS: actual body observer enforces owned physical roster, local death-only candidates, native trace gating, budget/cadence/caps, immutable body-only snapshots, radio retries and confirmed suppression
|
||||
PASS: own initial roster, explicit retained corpse evidence, unconscious/missing/ref transfer guards, fixed strength, no replacement adoption, detached samples, surviving radio sender, immutable convoy root/ledger, mounted capture release and lost-root unknown
|
||||
PASS: delivered-only status snapshots, two missed check-ins/reply deadline, last reported coordinates, episode/replay guards, confirmed-loss idempotence, detached/validated mounted payload replacement 256-record cap and detached carried-mine radio delivery/chronology
|
||||
PASS: actual failed-retask deadline rollback plus assignment cancellation/release preserves radio ownership, native waypoint lifecycle and failed-order retry boundaries
|
||||
PASS: actual force ledger, finite casualties/identity/cap, routes/arrival/elevation/overshoot, server and physical guards, staggered 256-record simulated hour without world queries
|
||||
PASS: actual equipment coordinator registration dedupe, startup delay, five member scans, finite component retries, unregister/stop terminal behavior and 256-group bound
|
||||
PASS: actual percentage selection, native/preferred launcher preservation, failure/removal fallback, pending-operation quarantine, capture, finite two-mine grants and no replenishment
|
||||
PASS: automatic inventory one-shot roll, exact item ownership, finite compatible ammo, rejection, capture/stop, deletion, loot and late callback quarantine
|
||||
PASS: enabled/valid catalog eligibility, category restrictions, content filtering, GUID deduplication across factions and bounded catalogs
|
||||
PASS: actual engineer mine preparation/deadline, original custody/identity, once-only callback removal, cancellation quarantine, withdrawal/clearance, native refusal and owned-action cleanup; native execution untested
|
||||
PASS: actual road mine-site annulus/bend geometry, deterministic bounded candidates, server/query limits, and native ground/water/obstruction rejection; no runtime placement claim
|
||||
PASS: actual HQ mine admission, one site query per tick, maximum two active/32 retained jobs, delivered-only original post, once-per-unit refusal latch, 256-item ceiling and maintenance/teardown ownership
|
||||
PASS: actual objective heading/threat/approach rules, persistent doctrine weight, fresh-contact coverage invalidation, stale-sweep rejection and atomic radio retask ownership
|
||||
PASS: actual bounded delivered-negative coverage, replay/freshness/expiry/invalid guards, oldest eviction, small-circle and nearest-unswept selection, reserved-cell exclusion and cleanup
|
||||
PASS: actual HQ active/pending reservations, interruption, committed replacement, bounded coverage and unchanged force counts
|
||||
PASS: actual bounded pursuit roles/objectives/scores, stale search degradation, physical/busy/home guards, finite lifetime and two-bearing escape gap; no hidden player reads or spawning
|
||||
PASS: actual HQ memory rules/service preserve delivered snapshots, chronology, replay bounds, decay, motion limits, identity and negative-search revisions
|
||||
.......
|
||||
----------------------------------------------------------------------
|
||||
Ran 7 tests in 0.032s
|
||||
|
||||
OK
|
||||
PASS: actual session Tick + journal router delivers each grant completion and new HQ line once, without repeats on empty/unavailable feeds or unauthorized ticks
|
||||
.....
|
||||
----------------------------------------------------------------------
|
||||
Ran 5 tests in 0.381s
|
||||
|
||||
OK
|
||||
PASS: actual current-controller/admin/mode authorization, per-round anti-replay, token-rotation refusal, command/snapshot throttles and client scope; owner-only replies and player-tool cleanup wiring
|
||||
PASS: mission provider registration is idempotent, optional dispatch is ordered, status aggregates, journals preserve cursors, aliases stay with their addons and topic help is bounded
|
||||
PASS: actual menu command routing covers all fourteen settings, rejects unsupported keys, gates companions, and matches unique authored widgets
|
||||
PASS: explicit weapon retention buttons use the same ready/authorized server command path
|
||||
PASS: actual summaries preserve queued/delivered meaning, clear counts and IDs; raw records, legacy display, cursor gaps and RPC limits remain intact
|
||||
PASS: actual admin body authorization, god restoration, vanilla item deposit, callback completion/failure, timeout quarantine and stop/revocation paths
|
||||
PASS: same-body revoke/regrant preserves pending insertions and timeout quarantine; new-body binding isolates late callbacks and never inherits god mode
|
||||
PASS: actual Intel commands distinguish status/start/failure, preserve authorization gate and reject malformed requests; spent ledger is idempotent, server-only and bounded
|
||||
PASS: actual reroll snapshot, authority, cancellation, ownership, accepted operations, quarantine, bounded work and stop methods; no native runtime claim
|
||||
PASS: production Intel feedback coalescing, rough secrecy, rate limit, bounded dedupe, local/remote delivery and round cleanup; native UI/RPC not exercised
|
||||
PASS: actual per-squad bounded report selector rotates visible targets, survives ordering/turnover, records only queued attempts, and preserves radio intake ordering
|
||||
PASS: actual action denial/clearing, server request failure, single submitted-result feedback, current rescuer identity and terminal/stop suppression; native UI/RPC pending
|
||||
PASS: actual physical denial precedence and transport-seat occupancy/reservation/access/lock checks
|
||||
PASS: actual initial admission exhaustion and ServerTick grace; new/pending/empty/controller/life guards, normal death preserved
|
||||
......................
|
||||
----------------------------------------------------------------------
|
||||
Ran 22 tests in 0.244s
|
||||
|
||||
OK
|
||||
......................
|
||||
----------------------------------------------------------------------
|
||||
Ran 22 tests in 27.223s
|
||||
|
||||
OK
|
||||
..................
|
||||
----------------------------------------------------------------------
|
||||
Ran 18 tests in 3.135s
|
||||
|
||||
OK
|
||||
.........
|
||||
----------------------------------------------------------------------
|
||||
Ran 9 tests in 2.449s
|
||||
|
||||
OK
|
||||
...............
|
||||
----------------------------------------------------------------------
|
||||
Ran 15 tests in 1.219s
|
||||
|
||||
OK
|
||||
PASS: actual field result/braking observer and Chat dispatch rules; one finite fixed candidate, deferred callback failure and guarded cleanup; no native measurement
|
||||
PASS: actual opt-in terrain audit records one fixed1681-point grid, preserves original survey refusal/success and exact no-allocation scope; malformed heights stop without retry; no native data acquired
|
||||
....
|
||||
----------------------------------------------------------------------
|
||||
Ran 4 tests in 0.674s
|
||||
|
||||
OK
|
||||
PASS: actual field PI/ramp/vector caps, antiwindup, braking hypothesis, immutable admission limits and segment bounds; no native physics tested
|
||||
PASS: actual100m whole-field survey sampling/4096cap, rotated coverage, all-node terrain and native trace refusal; original certificate lineage retained; no native qualification
|
||||
PASS: actual QualifyField preserves original identity/footprint/time, orders complete surveys before issuance, and refuses failed stages/moved body/expired or changed world; native boundaries faked
|
||||
PASS: WORKBENCH first-refusal diagnostics preserve ordinary predicates, query order/count/budget and opt-in scope; no native logging run
|
||||
PASS: actual field startup delegation, immutable lease/target, braking/settling/cancel transitions, early abort, callback scope, physical terminal policy and shared landing demand; native boundaries faked
|
||||
PASS: actual inherited airborne pre-CLIMB cancellation enables verified native autohover once, refuses failed enable and never writes after capture
|
||||
PASS: actual Core maintenance/default/tick/stop methods; empty/populated authority, terminal reentry, no tactical resume or new scheduler; native boundaries substituted
|
||||
PASS: actual finite registration, unique claims/tokens, retention/cancel/stop, readiness gating, capture/expiry retirement and bounded cross-kind order history and typed field/route construction; native boundaries faked
|
||||
PASS: actual WORKBENCH route observer returns exact retained route subtype and refuses absent/field controllers
|
||||
.....
|
||||
----------------------------------------------------------------------
|
||||
Ran 5 tests in 0.674s
|
||||
|
||||
OK
|
||||
......................
|
||||
----------------------------------------------------------------------
|
||||
Ran 22 tests in 0.187s
|
||||
|
||||
OK
|
||||
................
|
||||
----------------------------------------------------------------------
|
||||
Ran 16 tests in 11.300s
|
||||
|
||||
OK
|
||||
......
|
||||
----------------------------------------------------------------------
|
||||
Ran 6 tests in 0.019s
|
||||
|
||||
OK
|
||||
PASS: actual production bridge lookup, lease/world/mode/seat/capture guards, no allocation, native super ordering and read-only fixture hooks
|
||||
...............
|
||||
----------------------------------------------------------------------
|
||||
Ran 15 tests in 0.057s
|
||||
|
||||
OK
|
||||
.............
|
||||
----------------------------------------------------------------------
|
||||
Ran 13 tests in 5.221s
|
||||
|
||||
OK
|
||||
PASS: actual route gain/caps/braking, callback selection, old landing/cancellation control and matching read-only telemetry
|
||||
..............................
|
||||
----------------------------------------------------------------------
|
||||
Ran 30 tests in 0.427s
|
||||
|
||||
OK
|
||||
..............
|
||||
----------------------------------------------------------------------
|
||||
Ran 14 tests in 0.219s
|
||||
|
||||
OK
|
||||
.........
|
||||
----------------------------------------------------------------------
|
||||
Ran 9 tests in 0.127s
|
||||
|
||||
OK
|
||||
PASS: actual gate observer binds native registered action/context and current life, reads accumulated progress, refuses stale bindings and never revives outside original bounds
|
||||
PASS: actual read-only look observer methods enforce explicit scope, pinned native camera/body/identity, normalized pose, terminal cancellation and original sample/time bounds
|
||||
...........
|
||||
----------------------------------------------------------------------
|
||||
Ran 11 tests in 0.076s
|
||||
|
||||
OK
|
||||
.......................
|
||||
----------------------------------------------------------------------
|
||||
Ran 23 tests in 0.035s
|
||||
|
||||
OK
|
||||
PASS: actual initial WAITING task/guide copy, configured duration, unchanged interruption and rounded progress; native task assertion pending
|
||||
........
|
||||
----------------------------------------------------------------------
|
||||
Ran 8 tests in 0.012s
|
||||
|
||||
OK
|
||||
PASS: actual inventory adapter scope, grid placement, sole compatible host, refresh reuse, rollback, foreign hierarchy refusal and exactly-once native delegation; native compatibility pending
|
||||
.................................................................................
|
||||
----------------------------------------------------------------------
|
||||
Ran 81 tests in 0.554s
|
||||
|
||||
OK
|
||||
......
|
||||
----------------------------------------------------------------------
|
||||
Ran 6 tests in 0.086s
|
||||
|
||||
OK
|
||||
.................
|
||||
----------------------------------------------------------------------
|
||||
Ran 17 tests in 0.004s
|
||||
|
||||
OK
|
||||
...........
|
||||
----------------------------------------------------------------------
|
||||
Ran 11 tests in 0.086s
|
||||
|
||||
OK
|
||||
.........
|
||||
----------------------------------------------------------------------
|
||||
Ran 9 tests in 0.359s
|
||||
|
||||
OK
|
||||
PASS: actual observer nonce, admission pins, baseline/menu sequencing, snapshots, bounded clocks/samples, cleanup and one-attempt latch; native untested
|
||||
PASS: actual corridor caps/height/hold and whole-rectangle survey bounds, terrain refusal, native trace refusal and exact certificate lineage; native route unqualified
|
||||
PASS: actual route entry, fixed corridor/target, hover hold, cancellation landing freeze, shared lease/capture/deadline gate and unchanged native startup/tick sequence
|
||||
PASS: finite opt-in route fixture, original native input order, meaningful physical-arrival evidence and guarded cleanup; no native launch
|
||||
PASS: actual Chat route step result dispatch and scoped completion/cleanup wiring; six real early-parser refusal paths leave no prefix/profile output
|
||||
PASS: actual retained-service fixture entry, immutable controller/token/deadline/count bindings, observer getter and cleanup ownership ordering; native route validation pending
|
||||
PASS: actual measured cancellation gate, one-shot retained service Stop, no premature drain, immutable lease, fresh real controller readback and separate physical cancellation result policy
|
||||
PASS: actual rough-intel objective selection, exact precedence, source grid dimensions and unchanged other-phase dispatch; native UI pending
|
||||
.................................
|
||||
----------------------------------------------------------------------
|
||||
Ran 33 tests in 0.101s
|
||||
|
||||
OK
|
||||
...............
|
||||
----------------------------------------------------------------------
|
||||
Ran 15 tests in 0.035s
|
||||
|
||||
OK
|
||||
PASS: actual preparation status scope, persistent updates, spinner restoration, placeholder replacement/deletion/destruction, native observation persistence/timeout; rendering remains native-pending
|
||||
PASS: actual guide/observer monitors retry native refusal, cache successful delivery, deduplicate and preserve living/preparing/spectator boundaries; native UI not exercised
|
||||
PASS: actual native-end shutdown, existing terminal snapshots, reentrancy, unchanged native end data and stale preparation guards
|
||||
....
|
||||
----------------------------------------------------------------------
|
||||
Ran 4 tests in 1.469s
|
||||
|
||||
OK
|
||||
PASS: actual three-state result wording and UI refresh; stale winner IDs never manufacture escape
|
||||
...........
|
||||
----------------------------------------------------------------------
|
||||
Ran 11 tests in 0.121s
|
||||
|
||||
OK
|
||||
PASS: actual immutable target, bounded autohover demand, drift refusal, five-second hold and unchanged qualification/deadline
|
||||
PASS: actual admission attempt budget bounds blocked/missing prerequisites; preparation, spent life and async pending remain protected
|
||||
PASS: delayed admission retry retains controller ownership across same-account recycled connection IDs
|
||||
PASS: actual scene deadline overrides delayed native preload only for rejection; late completion cannot assign, ordinary verified admission preserved
|
||||
PASS: actual action permission matrix unchanged; useful phase/intel/consciousness denials, stale reason cleared, native door denial preserved; no native UI claim
|
||||
.....
|
||||
----------------------------------------------------------------------
|
||||
Ran 5 tests in 0.246s
|
||||
|
||||
OK
|
||||
PASS: actual aircraft cancellation/stage rules, ground-only completion, expiry/capture faults, input ownership and no physical shortcuts
|
||||
PASS: actual exact-instance single-use qualification, native-clock staleness/movement refusal, footprint bounds and ownership-safe ground/fault cleanup
|
||||
PASS: actual optional screenshot helper flag/identity/world/life revalidation, one queued attempt, delayed capture and mission/world cleanup; no native image/presentation claim
|
||||
PASS: actual yard diagnostic exact registered prison ownership, eight native-bound corner projections, no root-sibling escape, bounded duplicate/deep/wide hierarchy traversal; native projection/mask still unmeasured
|
||||
PASS: actual CurrentActor, SpawnPosition and observer-selection methods reject pending/unregistered/replaced/recycled/foreign/dead bodies; canonical selection/cycling, unconscious following and prison/geometry fallback preserved; native boundaries adapted
|
||||
PASS: actual native-map fixture ownership, cleanup and callback evidence fail closed; native execution remains separate
|
||||
PASS: actual shared-map callbacks bind exact map/config/root, preserve replacement UI/camera, defer focus, and remove only owned delayed work
|
||||
PASS: actual Intel/HQ methods and one-shot qualified readiness handoff deliver late actors once; duplicate readiness, accepted spawn, pickup/drop, death and original negative rolls do not mint assignments
|
||||
PASS: Workbench-only read accessor rejects unknown/nonserver identities; Chat observes all distinct ready crew before existing shell-depletion mutation
|
||||
PASS: actual native-event latch survives deselection, requires exact activity/order, detaches before cleanup, preserves failure/timeout and never infers completion from physical shot count
|
||||
.........
|
||||
----------------------------------------------------------------------
|
||||
Ran 9 tests in 0.112s
|
||||
|
||||
OK
|
||||
PASS: actual refresh-fixture gates pin immutable observations/actual downlinks/original activity, reject unaccepted or relabelled commits, stop queueing early and require all queued contacts claimed before replay
|
||||
..........................
|
||||
----------------------------------------------------------------------
|
||||
Ran 26 tests in 0.220s
|
||||
|
||||
OK
|
||||
PASS: actual refresh scheduler/delivery/cancellation/projectile methods reject interrupted or replayed reports, retain committed ownership, preserve immutable snapshots/aim geometry and isolate stopped or replaced orders; native radio/crew behavior remains separate
|
||||
.....................
|
||||
----------------------------------------------------------------------
|
||||
Ran 21 tests in 0.037s
|
||||
|
||||
OK
|
||||
...........
|
||||
----------------------------------------------------------------------
|
||||
Ran 11 tests in 0.037s
|
||||
|
||||
OK
|
||||
PASS: actual full-salvo gates require eight fresh committed physical launches, natural closure and exact finite inventory; reject partial/extra/replayed events
|
||||
PASS: actual reason/availability guidance and refresh matrix; no-target copy omits cycling, hint retry retained, existing command/admin paths unchanged; native UI pending
|
||||
PASS: actual client camera policy closes immediately on healing or mission end; late unconscious metadata cannot keep the view active
|
||||
PASS: actual input dispatch, one press per edge, menu-held suppression; actual revival camera handoff with editor close/retry, missing camera, replacement body and stopped round
|
||||
PASS: first-person pose survives missing samples without drift, follows body motion/rotation, resumes fresh pose and cannot leak between targets
|
||||
................usage: test_native_package.py [-h] [--project {core}] --session SESSION
|
||||
--compat COMPAT [--steam STEAM]
|
||||
[--timeout TIMEOUT]
|
||||
[--external-addons EXTERNAL_ADDONS]
|
||||
[--silent-workbench | --exit-after-init]
|
||||
[--continue-on-failure]
|
||||
test_native_package.py: error: argument --exit-after-init: not allowed with argument --silent-workbench
|
||||
................................
|
||||
----------------------------------------------------------------------
|
||||
Ran 48 tests in 13.074s
|
||||
|
||||
OK
|
||||
.......
|
||||
----------------------------------------------------------------------
|
||||
Ran 7 tests in 0.293s
|
||||
|
||||
OK
|
||||
..............
|
||||
----------------------------------------------------------------------
|
||||
Ran 14 tests in 2.251s
|
||||
|
||||
OK
|
||||
....
|
||||
----------------------------------------------------------------------
|
||||
Ran 4 tests in 0.280s
|
||||
|
||||
OK
|
||||
....
|
||||
----------------------------------------------------------------------
|
||||
Ran 4 tests in 0.057s
|
||||
|
||||
OK
|
||||
PASS: actual finite-courier age, token, exact ownership/callback and delivered-status admission reject stale, replayed, captured, canceled and ambiguous work
|
||||
PASS: actual native-gun ownership gate rejects player/foreign/replaced/dead occupant, faction change, missing seat and missing registry
|
||||
PASS: four-battery courier selection preserves pending trip/report/transfer identity, skips unavailable crews, and selects the next depleted battery without new stock
|
||||
PASS: 64 bounded distinct storage candidates; native gates, five-store barrier and finite-stock ownership retained; native placement pending
|
||||
PASS: 128 coarse+80 local refinement+169 airport grid candidates retain all native clearance gates; real terrain untested
|
||||
PASS: actual prison registration/crossing policies reject missing/duplicate/destroyed initial gate, incomplete ownership/scan, outside-only body, jumps and stale samples; physical exit independent of later gate damage
|
||||
PASS: actual prison door execution blocks direct AI/UI bypass while locked and delegates unchanged native action once after unlock and permission approval
|
||||
..................
|
||||
----------------------------------------------------------------------
|
||||
Ran 18 tests in 1.827s
|
||||
|
||||
OK
|
||||
.....
|
||||
----------------------------------------------------------------------
|
||||
Ran 5 tests in 1.071s
|
||||
|
||||
OK
|
||||
PASS: native local-admission snapshot rejects changed life/key/body/participant/pending state; authentication is not simulated
|
||||
PASS: actual mortar report ledger prevents duplicate response after cancellation, expiry and interleaved reports; native scheduler separate
|
||||
.........
|
||||
----------------------------------------------------------------------
|
||||
Ran 9 tests in 0.012s
|
||||
|
||||
OK
|
||||
....
|
||||
----------------------------------------------------------------------
|
||||
Ran 4 tests in 0.173s
|
||||
|
||||
OK
|
||||
PASS: actual aim renewal requires fresh same-report solve and original-command equivalence; native firing untested
|
||||
........
|
||||
----------------------------------------------------------------------
|
||||
Ran 8 tests in 0.014s
|
||||
|
||||
OK
|
||||
PASS: actual startup/generation/ownership/timeout/callback policies and native-counter wait; integration preserves one-shot allocation and pending-crew cancellation
|
||||
PASS: rapid mortar cycle counts eight physical rounds once and waits for native completion without a ninth aim or shell
|
||||
PASS: actual probe binds native events to fresh immutable commits, permits delayed emission, rejects unrelated expiry closure and premature stop
|
||||
PASS: actual noSplash Load body requires both explicit diagnostic and noSplash, preserves vanilla otherwise, and handles repeated Load/reload
|
||||
PASS: actual fixture method permits one native resilience operation and restores either prior protection state, including failure paths
|
||||
PASS: actual safe-exit boundary policy, native action/door selection, stop/cache cleanup, separate old mechanism and opt-in runner contracts
|
||||
PASS: actual one-shot deadline/stability policies and preparation ownership, fuel, cleanup integration contracts
|
||||
PASS: pending-only cancellation retires copied instance intent, preserves physical/control actors, and stops once
|
||||
PASS: actual short-cast hit, upward support normal, no self support and no dynamic support
|
||||
PASS: actual committed-ticket structure preserves reservation after death, rejects missing bodies/seats and ends at observation expiry
|
||||
PASS: actual pending callback expires an empty-server reservation once, preserves its full lease, and cancels on completion/Stop
|
||||
PASS: rescue lease expiry/reordering, fresh five-second settling, independent rescue ranges and grounded upright aircraft motion boundaries
|
||||
PASS: requested guard population requires complete physical conscious membership before deadline
|
||||
......................................
|
||||
----------------------------------------------------------------------
|
||||
Ran 38 tests in 0.018s
|
||||
|
||||
OK
|
||||
..........
|
||||
----------------------------------------------------------------------
|
||||
Ran 10 tests in 0.003s
|
||||
|
||||
OK
|
||||
.....
|
||||
----------------------------------------------------------------------
|
||||
Ran 5 tests in 0.914s
|
||||
|
||||
OK
|
||||
PASS: authored radio/optional-site bounds and physical horizontal/vertical boundaries
|
||||
...
|
||||
----------------------------------------------------------------------
|
||||
Ran 3 tests in 0.001s
|
||||
|
||||
OK
|
||||
PASS: all phase transitions, terminal states, defence boundaries, stale/future observations, intel discovery
|
||||
PASS: Core document-discovery alias, companion-only alias exclusion, strict integer parsing and setting boundaries
|
||||
PASS: player admission phase/life/identity/controller matrix, preload displacement limits, pending reservation overlap and owner exclusion
|
||||
PASS: actual gate and pre-inventory document guards reject noncanonical/faction/life/disconnect/server mismatches; canonical reconnect and unconscious carried intel preserved
|
||||
PASS: WB-only native fault injection restores both body mutations before checks/returns and requires eligible held-document negative/positive proof; runtime pending
|
||||
PASS: actual discovery coordinates disclose stable 500m cell center until identified, then exact point, including negative/boundary coordinates
|
||||
PASS: actual local admission context/selection/latch, same-round late identity, replacement/mode failure, fresh round and untouched network path
|
||||
PASS: prison search packs 16 unique 3m-spaced inside-wall centers, prioritizes inner/edge positions and never bypasses clearance
|
||||
PASS: physical body occupancy rejects overlap, permits diagonal neighboring slots, and excludes own body and unrelated broad-phase bounds
|
||||
PASS: recovery state excludes dead bodies, preserves reservations, requires controlled rescuers and distinguishes empty/all-dead teams
|
||||
PASS: authority-scoped slow recovery, bleeding pauses resilience, medicine unaffected, player-only lethal damage cap without healing
|
||||
PASS: bleeding severity survives low health, retains armour, causes no knockout and restores the actual damage/blood-loss cap
|
||||
PASS: viable passive recovery survives native delay; bleeding, disabled/full effects and low-blood resilience do not block defeat
|
||||
PASS: every minute round-trips, malformed clocks rejected, defaults limited to added keys, progression bounds and day duration aligned
|
||||
PASS: native settings policy matches calendar boundaries 1900-2050, date/profile parsing is strict, authored defaults preserve old worlds
|
||||
PASS: view-distance bounds, default, save failures, command parsing, temporary ownership, server/platform limits and lifecycle wiring
|
||||
.....
|
||||
----------------------------------------------------------------------
|
||||
Ran 5 tests in 0.619s
|
||||
|
||||
OK
|
||||
.
|
||||
----------------------------------------------------------------------
|
||||
Ran 1 test in 0.368s
|
||||
|
||||
OK
|
||||
PASS: radio authorization/discovery/phase matrix, exact distance limits, defender handover, interruption, empty samples, clock regression and duration boundary
|
||||
PASS: actual radio feedback policy, initial wait, interruption persistence, resumption and terminal/new-round reset
|
||||
...............
|
||||
----------------------------------------------------------------------
|
||||
Ran 15 tests in 2.090s
|
||||
|
||||
OK
|
||||
..............................................
|
||||
----------------------------------------------------------------------
|
||||
Ran 46 tests in 0.914s
|
||||
|
||||
OK
|
||||
PASS: legacy values preserved, unsupported fields reported, invalid data rejected, existing files protected, runtime bounds aligned
|
||||
PASS: failed initial settings promotion leaves defaults writable after restart; prior/fallback saves survive copy, readback and mismatch faults
|
||||
PASS: real-carrier shortest-hop paths, 500m boundary, three-hop cap, no-manpack failure, three-second originating-call interruption, unchanged downlink hop timing, completed-hop survival, interrupted final uplink, radio loss, capture, motion, timeout, reset and network bounds
|
||||
PASS: migrated aircraft availability policy (controller migration still pending)
|
||||
PASS: migrated salvo offsets are deterministic, spread and bounded (native firing and complete salvo qualification are separate)
|
||||
PASS: 35 prefabs have unique saved root entity IDs
|
||||
PASS: 299 original script entries tracked across 18 unfinished responsibilities
|
||||
PASS: 1 isolated addons, acyclic dependencies, 56 unique resources, exact vanilla/authorized external references
|
||||
All repository checks passed. Native compilation and multiplayer tests are separate requirements.
|
||||
@@ -0,0 +1,28 @@
|
||||
{
|
||||
"implementation": "Optional read-only --mine-stock variant of mounted-ammo: pin the first ordinary eligible convoy and initial batch, require 1\u20132 exact callback-proved inactive PMN4s and reciprocal storage custody, then recheck those same identities after natural production radio delivery. No gameplay changes, item creation/transfer or report injection.",
|
||||
"dependencies": "RHS: Status Quo, WCS Armaments and WCS BMP-1 remain declared external dependencies; seven installed addons in resolved closure including Parachute Framework and supporting packs.",
|
||||
"regression_programs": 271,
|
||||
"regressions": "passed",
|
||||
"review": "Independent actual-method/runner tests pass; removing callback identity proof or accepting empty stock causes runtime assertion failure. Pending optional stock cannot select a different convoy or replace the pinned batch.",
|
||||
"native": "docs/evidence/native-2026-10-01-convoy-mine-stock/report.json",
|
||||
"native_result": "Failed after 39 passing assertions, before mine-stock assertions or completed radio proof. The unarmed ammunition truck snapshot reports Complete=false, Weapons=0 and Magazines=0, failing the existing mounted cargo-exclusion guard. Two scripted test failures and thirteen underlying installed-resource errors are retained. No claim of native mine insertion or transfer.",
|
||||
"native_cleanup": "Confirmed; headless Gamescope, silent sink and per-test-stream mute; launched source and seven external-addon inputs unchanged.",
|
||||
"source_matches_frozen_native": true,
|
||||
"automatic_equipment_audit": "No reproduced PMN4 top-up race. Inspected installed mine catalog entries classify them as EXPLOSIVES, excluded by automatic equipment; same-actor one-shot state survives unconsciousness and capture/release remains terminal. Source tests pass; no multiplayer claim.",
|
||||
"remaining": "Native mine insertion, carried reporting/placement and actual transfer; human escape, true multiplayer, maintenance/mounted interactions, comparative FPS and clean release. Existing packaged candidate predates this source work.",
|
||||
"preservation": {
|
||||
"original_reference_files_unchanged": 533,
|
||||
"field_candidate_files_unchanged": 401,
|
||||
"inherited_working_paths": 61,
|
||||
"unchanged_inherited_paths": 59,
|
||||
"only_intended_insertions": [
|
||||
"tools/check.py",
|
||||
"tools/headless_workbench.py"
|
||||
],
|
||||
"regression_programs": 271
|
||||
},
|
||||
"source_sha256": {
|
||||
"addons/core/Scripts/Game/ERR/40_Chat/ERR_NativeMountedAmmoProbe.c": "2c3606d81bce045a7a64ac1f19d0155598fadc01067d2e4f0711a686c89b4c00"
|
||||
},
|
||||
"failure_audit": "Read-only review cannot identify the native cause from available logs. With Weapons=0, incompleteness originates in Collect/AddWeapon before muzzle processing. Inventory item count <=128 is distinct from hierarchy traversal node count. Next bounded diagnostic should record the existing pass failure reason/node count/first offending prefab or storage purpose, without another traversal or weakened guard."
|
||||
}
|
||||
Reference in New Issue
Block a user