"""Execute production supply-circuit and combat timing policies with native boundaries doubled."""
from policy_harness import ROOT, body, run
import re,os
from pathlib import Path
D=ROOT/'addons/core/Scripts/Game/ERR/10_AI'
TACTICS=Path(os.environ.get('ERR_SUPPLY_TACTICS_SOURCE',D/'ERR_SupplyConvoyTactics.c'))

def cpp(s):
 s=re.sub(r'//[^\n]*','',s).replace('protected ','').replace('Teams.IsEmpty()', 'Teams.empty()').replace('override ','').replace('foreach (','for (').replace('null','nullptr')
 s=s.replace('m_Task.', 'm_Task->').replace('m_Mode.', 'm_Mode->').replace('m_Service.', 'm_Service->')
 for typ in ('ERR_SupplyConvoyTask','ERR_ConvoyVehicle','ERR_SupplyTeam','ERR_ForceRoute','ERR_ConvoyBoardingProgress','IEntity'):
  s=re.sub(r'\b'+typ+r' (?=\w)',typ+'* ',s)
 for obj in ('task','stagingVehicle','vehicle','departure','team','lost','boarding','stranded','leg','infantryTeam','member','delayed','foot','covering'):
  s=s.replace(obj+'.',obj+'->')
 for cls in ('Math','ERR_SupplyConvoyRules','ERR_HQ','ERR_ForceRules','ERR_Actors','vector','string'):
  s=s.replace(cls+'.',cls+'::')
 s=s.replace('m_Support[supporting].','m_Support[supporting]->').replace('Orders[0].','Orders[0]->')
 s=s.replace('string::Empty','string{}').replace('string.Empty','string{}')
 s=s.replace('bool surviving, pending;','bool surviving=false, pending=false;').replace('bool pending;', 'bool pending=false;')
 s=s.replace('float nearest = 400; bool found;', 'float nearest = 400; bool found=false;')
 s=s.replace('m_Support[released].', 'm_Support[released]->').replace('Vehicles[released].', 'Vehicles[released]->').replace('infantryTeam->Group.', 'infantryTeam->Group->')
 s=s.replace('->Column.', '->Column->').replace('->Combat.', '->Combat->')
 s=s.replace('->Receipt.', '->Receipt->').replace('Vehicles[2].', 'Vehicles[2]->')
 s=s.replace('.Entity.', '.Entity->').replace('->Entity.', '->Entity->')
 return s
common=r'''
#include <cassert>
#include <cmath>
#include <limits>
#include <vector>
#include <string>
struct string:std::string{using std::string::string;string(std::string s):std::string(s){}template<class...T>static string Format(T...){return "event";}};
struct vector{float x=0;static float Distance(vector a,vector b){return std::abs(a.x-b.x);}static float DistanceXZ(vector a,vector b){return Distance(a,b);}};
template<class T>struct Array:std::vector<T>{using std::vector<T>::vector;int Count(){return this->size();}bool IsEmpty(){return this->empty();}};
namespace Math{int RandomInt(int low,int){return low;}float RandomFloat(float low,float){return low;}}
namespace ERR_HQ{void Event(string,string){}}
namespace ERR_ForceRules{bool Finite(float v){return std::isfinite(v);}bool FiniteVector(vector v){return Finite(v.x);}}
'''
next_base=cpp(body(D/'ERR_SupplyConvoySystem.c','static int NextBase('))
run(common+'struct ERR_SupplyConvoyRules{'+next_base+r'''};
struct Entity{vector position;vector GetOrigin(){return position;}};
struct ERR_ForceRoute{Array<vector> points;void Add(vector p){points.push_back(p);}void Seal(){}};
struct Receipt{string SourceId="test";};
struct Combat{bool Held=false;};
struct Column{bool live=true;int resets=0;bool Tick(float){return live;}void Reset(float,bool){resets++;}};
struct ERR_ConvoyVehicle{int InterceptToken=0;bool Released=false,Arrived=false,SupplyHeld=false;struct Combat combat;struct Combat* Combat=&combat;int cleared=0,RouteIndex=3;struct Entity entity;struct Entity* Entity=&entity;
 void ClearOrder(){cleared++;}void Tick(void*,ERR_ForceRoute*,float){}};
struct ERR_SupplyConvoyTask{struct Column column;struct Column* Column=&column;Array<ERR_ConvoyVehicle*> Vehicles;float TravelDeadline=1000,Departure=0;bool Waiting=false,stopped=false;int LastBase=-1,Legs=0;
 Array<vector> Bases={{0},{1000},{2000}};ERR_ForceRoute* Route=nullptr;struct Receipt receipt;struct Receipt* Receipt=&receipt;
 void Stop(void*,string){stopped=true;}};
struct Service{void* m_Mode=nullptr;
'''+cpp(body(Path(os.environ.get('ERR_SUPPLY_SERVICE_SOURCE',D/'ERR_SupplyConvoyService.c')),'protected void Circuit('))+r'''};
int main(){
 for(int last=0;last<5;last++)for(int roll=0;roll<4;roll++){int next=ERR_SupplyConvoyRules::NextBase(5,last,roll);assert(next>=0&&next<5&&next!=last);}
 assert(ERR_SupplyConvoyRules::NextBase(1,0,0)==-1);assert(ERR_SupplyConvoyRules::NextBase(3,3,0)==-1);
 Service s;ERR_SupplyConvoyTask t;ERR_ConvoyVehicle a,b;t.Vehicles={&a,&b};
 s.Circuit(&t,999);assert(!t.Waiting&&!a.Arrived);s.Circuit(&t,1000);assert(!a.Arrived&&!b.Arrived&&!t.Waiting); // timeout is not arrival
 a.Arrived=b.Arrived=true;a.SupplyHeld=true;s.Circuit(&t,2000);assert(!t.Waiting);
 a.SupplyHeld=false;b.combat.Held=true;s.Circuit(&t,3000);assert(!t.Waiting);
 b.combat.Held=false;s.Circuit(&t,4000);assert(t.Waiting&&t.Departure==49000);
 s.Circuit(&t,48999);assert(t.Legs==0);s.Circuit(&t,49000);assert(t.Legs==1&&!t.Waiting&&!a.Arrived&&!b.Arrived&&t.LastBase==0&&t.column.resets==1);
 a.entity.position={250};b.entity.position={249};s.Circuit(&t,50000);assert(!a.Arrived&&!b.Arrived&&!t.Waiting); // no 250m shortcut
 a.Arrived=true;b.Arrived=true;s.Circuit(&t,51000);assert(t.Waiting);s.Circuit(&t,96000);assert(t.LastBase==1&&t.Legs==2);
 a.Released=true;b.Released=true;t.column.live=false;s.Circuit(&t,97000);assert(t.stopped); // no replacements
}
''')
run(common+r'''
struct ERR_ConvoyBoardingProgress{};
struct Group{int GetFaction(){return 1;}};struct IEntity{};struct Mode{int EnemyFaction(){return 1;}};
namespace ERR_Actors{bool Alive(IEntity*){return true;}struct Group* Group(IEntity*){return nullptr;}}
struct PositionEntity{vector GetOrigin(){return {};}};
struct ERR_ConvoyVehicle{bool Released=false;void* Group=nullptr;PositionEntity* Entity=nullptr;};
struct ERR_SupplyTeam{Array<PositionEntity*> Orders;bool SearchPlanned=false;vector SearchPosition;void VehicleUse(void*,void*,bool){}ERR_ConvoyBoardingProgress* BoardingProgress=nullptr;float BoardingRetryAt=0;bool Released=false,aboard=true,living=true;struct Group nativeGroup;struct Group* Group=&nativeGroup;Array<IEntity*> Members;int orders=0;void Clear(){}
 bool Aboard(void*,bool required){return aboard==required;}bool Living(){return living;}void Release(void*){Released=true;}void Add(int){orders++;}};
struct Receipt{string SourceId="test";};
struct ERR_SupplyConvoyTask{Array<ERR_ConvoyVehicle*> Vehicles;Array<ERR_SupplyTeam*> Teams;struct Receipt receipt;struct Receipt* Receipt=&receipt;};
struct Tactics{ERR_SupplyConvoyTask* m_Task;Mode mode;Mode* m_Mode=&mode;Array<ERR_SupplyTeam*>m_Support;bool m_Stopped=false,m_TruckWithdrawn=false,seeing=false,truck=true;
 int m_State=0,starts=0,reorders=0,withdraws=0,finishes=0,m_DismountAttempts=0,flanks=0;float m_NextDismount=0;void Flank(int,bool){flanks++;}float m_LastContact=-1,m_NextOrders=0,m_BoardDeadline=0;vector m_Contact;
 bool Observe(void*,vector& p,float&){p={100};return seeing;}void Start(vector p,float){m_Contact=p;m_State=1;m_TruckWithdrawn=false;starts++;}
 bool PlanFlank(int,bool,int){return true;}void Claim(void*,vector,float){}void ContinueSearch(float){}void Orders(bool,float){reorders++;}bool InfantryAboard(bool required){for(auto t:m_Task->Teams)if(!t->Released&&!t->Aboard(nullptr,required))return false;return true;}
 void Support(int i,bool hold){if(i==2&&!hold)withdraws++;}bool Usable(int){return truck;}void Clear(){}int Board(void*,bool){return 1;}
 float infantryDistance=100;float InfantryDistance(void*){return infantryDistance;}void ProtectInfantry(){}void RefreshBoarding(float){}void Finish(float){m_State=0;finishes++;}
'''+cpp(body(TACTICS,'void Report('))+cpp(body(TACTICS,'bool Tick('))+r'''};
int main(){
 ERR_SupplyConvoyTask task;ERR_ConvoyVehicle driver;task.Vehicles={&driver,&driver,&driver};ERR_SupplyTeam left,right;task.Teams={&left,&right};Tactics t{&task};
 t.Report({100},std::numeric_limits<float>::quiet_NaN(),0);assert(t.starts==0);
 t.Report({100},-1,0);t.Report({100},10,0);t.Report({100},0,60001);assert(t.starts==0);
 t.Report({100},1000,1000);assert(t.starts==1&&t.m_State==1);t.Report({0},999,1001);assert(t.m_LastContact==1000);
 assert(t.Tick(180999)&&t.m_State==1&&t.withdraws==0);left.aboard=right.aboard=false;
 assert(t.Tick(181000)&&t.m_State==2&&t.withdraws==1&&left.orders==1&&right.orders==1&&t.m_BoardDeadline==481000);
 assert(t.Tick(480999));left.aboard=true;assert(!t.Tick(481000)&&t.finishes==1&&!left.Released&&right.Released);
 right.Released=false;t.Report({100},500000,500000);t.Tick(680000);assert(t.m_State==2);
 t.seeing=true;t.Tick(680001);assert(t.m_State==1&&t.starts==3); // fresh contact interrupts reboarding
 t.seeing=false;t.truck=false;t.Tick(860001);assert(t.m_State==0&&left.Released&&right.Released); // truck lost: release surviving infantry
 t.m_Stopped=true;t.Report({100},900000,900000);assert(t.starts==3&&!t.Tick(900000));
 left.Released=right.Released=false;left.aboard=right.aboard=true;Tactics retry{&task};retry.Report({100},0,0);
 for(int i=1;i<=9;i++){retry.Report({100},10000*i,10000*i);retry.Tick(10000*i);}
 assert(retry.m_DismountAttempts==6&&retry.flanks==12); // six attempts per still-mounted team, no infinite retry
 left.aboard=right.aboard=false;Tactics safety{&task};safety.Report({100},0,0);safety.infantryDistance=24;
 safety.Tick(1000);assert(!safety.m_TruckWithdrawn&&safety.withdraws==0); // do not drive through troops at the doors
 safety.infantryDistance=25;safety.Tick(2000);assert(safety.m_TruckWithdrawn&&safety.withdraws==1);

}
''')
startup=cpp(body(D/'ERR_SupplyConvoySystem.c','void Tick('))
run(common+r'''
struct Service{int count=0;int Count(){return count;}};
struct Startup{Service* m_Service;bool m_Stopped=false,m_Automatic=true,create=false;int m_Target=3,m_Attempts=0,calls=0;
 float m_Began=-1,m_Next=0;string m_Reason,m_LastFailure;int notes=0;void NoteFailure(){notes++;}string Status(){return m_Reason;}
 bool StartOne(){calls++;if(create)m_Service->count++;return create;}
'''+startup+r'''};
int main(){
 Service service;Startup s{&service};s.Tick(1000,true);s.Tick(30999,true);assert(!s.calls);s.Tick(31000,false);assert(!s.calls);s.Tick(36000,true);assert(s.calls==1);
 s.create=true;s.Tick(41000,true);s.Tick(46000,true);s.Tick(51000,true);assert(service.count==3&&s.calls==4);s.Tick(56000,true);assert(s.calls==4);
 Service noRoad;Startup fail{&noRoad};fail.Tick(0,true);for(int i=0;i<200;i++)fail.Tick(30000+5000*i,true);assert(fail.calls==120&&fail.m_Attempts==120);
 Startup off{&noRoad};off.m_Target=0;off.Tick(0,true);off.Tick(30000,true);assert(!off.calls);
 off.m_Target=3;off.m_Automatic=false;off.Tick(90000,true);assert(!off.calls);
}
''')
retain=body(TACTICS,'protected static bool RetainOriginal(')+'\n'+body(TACTICS,'static bool Retain(')
retain=retain.replace('protected ','').replace('Teams.IsEmpty()', 'Teams.empty()')
retain=retain.replace('IEntity actor','IEntity* actor').replace('IEntity vehicle','IEntity* vehicle')
retain=retain.replace('SCR_VehicleDamageManagerComponent damage = SCR_VehicleDamageManagerComponent.Cast(vehicle.FindComponent(SCR_VehicleDamageManagerComponent));','SCR_VehicleDamageManagerComponent* damage = vehicle->damage;')
for name in ('ERR_Actors','CompartmentAccessComponent','EDamageState'):retain=retain.replace(name+'.',name+'::')
retain=retain.replace('damage.', 'damage->')
run(r"""
#include <cassert>
#include <map>
enum class EDamageState{UNDAMAGED,DAMAGED,DESTROYED};
struct SCR_VehicleDamageManagerComponent{float health=1;bool engine=true,gear=true;EDamageState state=EDamageState::UNDAMAGED;float GetHealthScaled(){return health;}bool GetEngineFunctional(){return engine;}bool GetGearboxFunctional(){return gear;}EDamageState GetState(){return state;}};
struct IEntity{bool player=false,fit=true;IEntity* vehicle=nullptr;SCR_VehicleDamageManagerComponent* damage=nullptr;};
namespace ERR_Actors{bool Player(IEntity* a){return a->player;}bool CanFight(IEntity* a){return a->fit;}}
namespace CompartmentAccessComponent{IEntity* GetVehicleIn(IEntity* a){return a->vehicle;}}
struct Map:std::map<IEntity*,IEntity*>{bool Contains(IEntity* a){return count(a);}IEntity* Get(IEntity* a){return at(a);}}s_Crews,s_Couriers;
"""+retain+r"""
int main(){
 IEntity driver,truck,other;SCR_VehicleDamageManagerComponent health;truck.damage=&health;driver.vehicle=&truck;
 assert(!Retain(&driver,&truck));s_Crews[&driver]=&truck;assert(RetainOriginal(&driver,&truck));assert(Retain(&driver,&truck));assert(!Retain(&driver,&other));
 driver.player=true;assert(!Retain(&driver,&truck));driver.player=false;driver.fit=false;assert(!Retain(&driver,&truck));driver.fit=true;
 health.state=EDamageState::DAMAGED;health.health=.9;assert(Retain(&driver,&truck));health.health=.25;assert(!Retain(&driver,&truck));health.health=1;
 health.engine=false;assert(!Retain(&driver,&truck));health.engine=true;health.gear=false;assert(!Retain(&driver,&truck));health.gear=true;
 health.state=EDamageState::DESTROYED;assert(!Retain(&driver,&truck));health.state=EDamageState::UNDAMAGED;driver.vehicle=nullptr;assert(!Retain(&driver,&truck));
}
""")
boarding=body(TACTICS,'static AIWaypoint Board(')
boarding=boarding.replace('AIWaypoint Board','AIWaypoint* Board').replace('Vehicle truck','Vehicle* truck').replace('truck.', 'truck->').replace('waypoint.', 'waypoint->').replace('specific.', 'specific->').replace('null','nullptr')
boarding=boarding.replace('SCR_BoardingWaypoint waypoint','SCR_BoardingWaypoint* waypoint').replace('SCR_BoardingEntityWaypoint specific','SCR_BoardingEntityWaypoint* specific')
boarding=boarding.replace('SCR_BoardingWaypoint.Cast(', 'dynamic_cast<SCR_BoardingWaypoint*>(').replace('SCR_BoardingEntityWaypoint.Cast(', 'dynamic_cast<SCR_BoardingEntityWaypoint*>(').replace('ERR_Actors.Spawn','ERR_Actors::Spawn').replace('EAIWaypointCompletionType.All','EAIWaypointCompletionType::All')
run(r"""
#include <cassert>
#include <string>
using ResourceName=std::string;
enum class EAIWaypointCompletionType{Leader,All};
struct Vehicle{int GetOrigin(){return 7;}};
struct AIWaypoint{virtual ~AIWaypoint(){}bool commanded=false;int radius=9;EAIWaypointCompletionType completion=EAIWaypointCompletionType::Leader;void SetCompletionRadius(int n){radius=n;}void SetCompletionType(EAIWaypointCompletionType type){completion=type;}};
void Command(AIWaypoint*w){w->commanded=true;}
struct SCR_BoardingWaypoint:AIWaypoint{bool driver=true,gunner=true,cargo=false;void SetAllowance(bool d,bool g,bool c){driver=d;gunner=g;cargo=c;}};
struct SCR_BoardingEntityWaypoint:SCR_BoardingWaypoint{Vehicle* vehicle=nullptr;void SetEntity(Vehicle* v){vehicle=v;}};
namespace ERR_Actors{bool fail=false;AIWaypoint* Spawn(ResourceName resource,int){if(fail)return nullptr;if(resource.find("GetIn.et")!=std::string::npos)return new SCR_BoardingEntityWaypoint();return new SCR_BoardingWaypoint();}}
"""+boarding+r"""
int main(){
 Vehicle truck;assert(!Board(nullptr,false));
 auto out=dynamic_cast<SCR_BoardingWaypoint*>(Board(&truck,false));assert(out&&out->commanded&&out->completion==EAIWaypointCompletionType::All&&out->radius==100&&!out->driver&&!out->gunner&&out->cargo);
 auto in=dynamic_cast<SCR_BoardingEntityWaypoint*>(Board(&truck,true));assert(in&&in->commanded&&in->radius==100&&in->completion==EAIWaypointCompletionType::All&&in->vehicle==&truck&&!in->driver&&!in->gunner&&in->cargo);
 delete out;delete in;ERR_Actors::fail=true;assert(!Board(&truck,true));
}
""")
delivery=body(D/'ERR_SupplyConvoyService.c','override bool CanResumeCombat(')+'\n'+body(D/'ERR_SupplyConvoyService.c','override bool ApplyCombatOrder(')
delivery=delivery.replace('override ','').replace('ERR_SupplyConvoyTask.Cast(task)','dynamic_cast<ERR_SupplyConvoyTask*>(task)')
for typ in ('ERR_ConvoyTask','ERR_SupplyConvoyTask','ERR_ConvoyCombatOrder'):delivery=re.sub(r'\b'+typ+r' (?=\w)',typ+'* ',delivery)
for name in ('supply','order'):delivery=delivery.replace(name+'.',name+'->')
delivery=delivery.replace('Tactics.','Tactics->').replace('super.ApplyCombatOrder','Base::ApplyCombatOrder')
run(r"""
#include <cassert>
struct ERR_ConvoyTask{virtual ~ERR_ConvoyTask(){}};
struct ERR_ConvoyCombatOrder{bool Hold=true;int Position=3;float ObservedAt=100;};
struct Tactics{int state=0,reports=0;int State(){return state;}void Report(int,float,float){reports++;}};
struct ERR_SupplyConvoyTask:ERR_ConvoyTask{struct Tactics tactics;struct Tactics* Tactics=&tactics;};
struct Base{bool accept=true;int applied=0;bool ApplyCombatOrder(ERR_ConvoyTask*,ERR_ConvoyCombatOrder*,float){applied++;return accept;}};
struct Service:Base{
"""+delivery+r"""
};
int main(){
 Service service;ERR_SupplyConvoyTask task;ERR_ConvoyCombatOrder order;
 for(int state=0;state<3;state++){task.tactics.state=state;assert(service.CanResumeCombat(&task)==(state==0));assert(service.ApplyCombatOrder(&task,&order,100));}
 assert(task.tactics.reports==3);order.Hold=false;assert(!service.ApplyCombatOrder(&task,&order,100));assert(service.applied==3);
 task.tactics.state=0;assert(service.ApplyCombatOrder(&task,&order,100));assert(task.tactics.reports==3);
 service.accept=false;order.Hold=true;assert(!service.ApplyCombatOrder(&task,&order,100)&&task.tactics.reports==3);
 assert(!service.CanResumeCombat(nullptr));
 assert(!service.ApplyCombatOrder(nullptr,&order,100));assert(!service.ApplyCombatOrder(&task,nullptr,100));
}
""")
print('PASS: actual supply route cycling/arrival/stops, finite startup bounds, contact freshness, dismount hold, quiet interval, interrupted boarding, timeout and lost-truck release')

# Mounted groups retain their native spawn origin; sighting distance must follow vehicles.
distance=cpp(body(TACTICS,'protected float DistanceToConvoy(')).replace('Math.Min','Math::Min')
observe=cpp(body(TACTICS,'protected bool Observe('))
for typ in ('SCR_AIGroup','SCR_AIGroupPerception','PerceptionManager','SCR_AITargetInfo'):
 observe=re.sub(r'\b'+typ+r' (?=\w)',typ+'* ',observe)
for obj in ('group','perception','manager','target'):observe=observe.replace(obj+'.',obj+'->')
observe=observe.replace('out vector position','vector& position').replace('inout float nearest','float& nearest').replace('bool found;','bool found=false;')
observe=observe.replace('GetGroupUtilityComponent().','GetGroupUtilityComponent()->').replace('GetFaction().','GetFaction()->').replace('GetGame().','GetGame()->').replace('EAITargetInfoCategory.','EAITargetInfoCategory::')
run(common+r"""
namespace Math{float Min(float a,float b){return a<b?a:b;}}
struct Entity{vector position;vector GetOrigin(){return position;}};
struct ERR_ConvoyVehicle{bool Released=false;struct Entity* Entity=nullptr;};
struct ERR_SupplyConvoyTask{Array<ERR_ConvoyVehicle*> Vehicles;};
struct Faction{bool hostile=true;bool IsFactionEnemy(Faction* other){return other->hostile;}};
enum class EAITargetInfoCategory{IDENTIFIED,SUSPECTED};
struct SCR_AITargetInfo{void* m_Entity=this;Faction* m_Faction=nullptr;float m_fTimestamp=10;EAITargetInfoCategory m_eCategory=EAITargetInfoCategory::IDENTIFIED;vector m_vWorldPos={5100};};
struct SCR_AIGroupPerception{Array<SCR_AITargetInfo*> m_aTargets;};
struct Utility{SCR_AIGroupPerception* m_Perception=nullptr;bool allowed=true;bool IsPositionAllowed(vector){return allowed;}};
struct SCR_AIGroup{Faction faction;Utility utility;Utility* GetGroupUtilityComponent(){return &utility;}Faction* GetFaction(){return &faction;}vector GetOrigin(){return {0};}};
struct PerceptionManager{float now=10;float GetTime(){return now;}};
struct Game{PerceptionManager manager;PerceptionManager* GetPerceptionManager(){return &manager;}}game;
Game* GetGame(){return &game;}
struct Observer{ERR_SupplyConvoyTask* m_Task;
"""+distance+observe+r"""
};
int main(){
 Entity car{{5000}},lost{{0}};ERR_ConvoyVehicle live{false,&car},released{true,&lost};ERR_SupplyConvoyTask task{{&live,&released}};Observer observer{&task};
 Faction enemy;SCR_AITargetInfo target;target.m_Faction=&enemy;SCR_AIGroupPerception perception{{&target}};SCR_AIGroup group;group.utility.m_Perception=&perception;
 vector position;float nearest=400;assert(observer.Observe(&group,position,nearest)&&position.x==5100&&nearest==100);
 target.m_vWorldPos={100};nearest=400;assert(!observer.Observe(&group,position,nearest)); // stale group/spawn origin is irrelevant
 target.m_vWorldPos={5401};assert(!observer.Observe(&group,position,nearest));target.m_vWorldPos={5100};
 target.m_eCategory=EAITargetInfoCategory::SUSPECTED;assert(!observer.Observe(&group,position,nearest));target.m_eCategory=EAITargetInfoCategory::IDENTIFIED;
 target.m_fTimestamp=4;assert(!observer.Observe(&group,position,nearest));target.m_fTimestamp=11;assert(!observer.Observe(&group,position,nearest));target.m_fTimestamp=5;
 assert(observer.Observe(&group,position,nearest));nearest=400;enemy.hostile=false;assert(!observer.Observe(&group,position,nearest));enemy.hostile=true;
 group.utility.allowed=false;assert(!observer.Observe(&group,position,nearest));group.utility.allowed=true;
 live.Released=true;assert(!observer.Observe(&group,position,nearest));assert(!observer.Observe(nullptr,position,nearest));
}
""")
# Execute original-held predicate plus real group/individual gates together.
retain_group=body(TACTICS,'static bool RetainGroup(')
retain_group=retain_group.replace('SCR_AIGroup group','SCR_AIGroup* group').replace('IEntity vehicle','IEntity* vehicle').replace('IEntity leader','IEntity* leader').replace('IEntity actor','IEntity* actor')
retain_group=retain_group.replace('array<AIAgent>','Array<AIAgent*>').replace('foreach (AIAgent agent :','for (AIAgent* agent :').replace('null','nullptr')
retain_group=retain_group.replace('group.','group->').replace('agent.','agent->').replace('ERR_Actors.','ERR_Actors::').replace('CompartmentAccessComponent.','CompartmentAccessComponent::')
source=TACTICS.read_text()
overrides=[]
for cls in ('SCR_AIGetOutVehicle','SCR_AIGetOutActivity'):
 section=source[source.index('modded class '+cls):];section=section[:section.index('\nclass ') if '\nclass ' in section else len(section)]
 for method in ('CustomEvaluate','EvaluatePriorityLevel'):
  a=section.index('override float '+method+'(');b=section.index('\n }',a)+3
  overrides.append(section[a:b].replace('override ','').replace('m_Utility.','m_Utility->').replace('ERR_ConvoyMountedCrew.','ERR_ConvoyMountedCrew::').replace('super.','Base::'))
run(r"""
#include <cassert>
#include <map>
#include <vector>
template<class T>struct Array:std::vector<T>{using std::vector<T>::vector;bool IsEmpty(){return this->empty();}int Count(){return this->size();}};
struct SCR_AIGroup;
enum class EDamageState{UNDAMAGED,DAMAGED,DESTROYED};
struct SCR_VehicleDamageManagerComponent{float health=1;bool engine=true,gear=true;EDamageState state=EDamageState::UNDAMAGED;float GetHealthScaled(){return health;}bool GetEngineFunctional(){return engine;}bool GetGearboxFunctional(){return gear;}EDamageState GetState(){return state;}};
struct IEntity{bool player=false,fit=true;IEntity* vehicle=nullptr;SCR_VehicleDamageManagerComponent* damage=nullptr;SCR_AIGroup* group=nullptr;};
struct AIAgent{IEntity* actor=nullptr;IEntity* GetControlledEntity(){return actor;}};
struct SCR_AIGroup{int players=0;IEntity* leader=nullptr;Array<AIAgent*> agents;int GetPlayerCount(bool){return players;}IEntity* GetLeaderEntity(){return leader;}void GetAgents(Array<AIAgent*>&a){a=agents;}};
namespace ERR_Actors{bool Player(IEntity*a){return a->player;}bool CanFight(IEntity*a){return a->fit;}SCR_AIGroup* Group(IEntity*a){return a->group;}}
namespace CompartmentAccessComponent{IEntity* GetVehicleIn(IEntity*a){return a->vehicle;}}
struct Map:std::map<IEntity*,IEntity*>{bool Contains(IEntity*a){return count(a);}IEntity* Get(IEntity*a){return at(a);}};
struct ERR_ConvoyMountedCrew{inline static Map s_Crews,s_Couriers;
"""+retain+retain_group+r"""
};
struct Utility{IEntity* m_OwnerEntity;SCR_AIGroup* m_Owner;};
struct Base{float CustomEvaluate(){return 1162;}float EvaluatePriorityLevel(){return 1000;}};
struct Individual:Base{Utility* m_Utility=nullptr;struct{IEntity* m_Value=nullptr;}m_Vehicle;
"""+''.join(overrides[:2])+r"""
};
struct Activity:Base{Utility* m_Utility=nullptr;struct{IEntity* m_Value=nullptr;}m_Vehicle;
"""+''.join(overrides[2:])+r"""
};
int main(){
 IEntity truck,other,driver,courier,replacement;SCR_VehicleDamageManagerComponent damage;truck.damage=&damage;
 SCR_AIGroup group,foreign;group.leader=&courier;driver.vehicle=&truck;courier.vehicle=&truck;driver.group=&group;courier.group=&group;
 AIAgent d{&driver},c{&courier},r{&replacement};group.agents={&c,&d};
 auto& held=ERR_ConvoyMountedCrew::s_Crews;auto& permits=ERR_ConvoyMountedCrew::s_Couriers;held[&driver]=&truck;held[&courier]=&truck;permits[&courier]=&truck;
 Utility utility{&courier,&group};Individual individual;Activity activity;individual.m_Utility=&utility;individual.m_Vehicle.m_Value=&truck;activity.m_Utility=&utility;activity.m_Vehicle.m_Value=&truck;
 // Original non-driver leader may dismount alone; group and original driver stay retained.
 assert(individual.CustomEvaluate()==1162&&individual.EvaluatePriorityLevel()==1000);
 assert(activity.CustomEvaluate()==0&&activity.EvaluatePriorityLevel()==0);
 assert(ERR_ConvoyMountedCrew::Retain(&driver,&truck));
 courier.vehicle=nullptr;activity.m_Vehicle.m_Value=nullptr;
 assert(activity.CustomEvaluate()==0&&activity.EvaluatePriorityLevel()==0);
 assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&other));
 group.players=1;assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));group.players=0;
 // Neither missing/dead/foreign members nor unheld replacements prove original seated crew.
 driver.fit=false;assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));driver.fit=true;
 driver.player=true;assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));driver.player=false;
 driver.group=&foreign;assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));driver.group=&group;
 driver.vehicle=nullptr;assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));driver.vehicle=&truck;
 held.erase(&driver);replacement.vehicle=&truck;replacement.group=&group;group.agents={&c,&d,&r};assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));held[&driver]=&truck;
 group.agents.assign(33,&d);assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));group.agents={nullptr,&c,&d};
 // Emergency abandonment remains available, independent of courier permission.
 damage.health=.25;assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));damage.health=1;
 damage.engine=false;assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));damage.engine=true;
 damage.gear=false;assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));damage.gear=true;
 damage.state=EDamageState::DESTROYED;assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));damage.state=EDamageState::UNDAMAGED;
 truck.damage=nullptr;assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));truck.damage=&damage;
 assert(ERR_ConvoyMountedCrew::RetainGroup(&group,nullptr));held.erase(&courier);assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,nullptr));
 assert(ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));group.agents.clear();assert(!ERR_ConvoyMountedCrew::RetainGroup(&group,&truck));
 assert(!ERR_ConvoyMountedCrew::RetainGroup(nullptr,&truck));
}
""")
print('PASS: moving-convoy perception boundaries and scoped individual/group abandonment priorities')

# Exercise the real refusal/status/journal methods without changing allocator policy.
diag='\n'.join(body(D/'ERR_SupplyConvoySystem.c',name) for name in
 ('protected string RefusalReason(', 'protected string BudgetStatus(', 'protected void NoteFailure(', 'void Tick(', 'string Status('))
diag=cpp(diag).replace('ERR_ConvoyReceipt receipt','ERR_ConvoyReceipt* receipt').replace('receipt.','receipt->').replace('m_Pool.','m_Pool->')
run(r'''
#include <cassert>
#include <cmath>
#include <string>
#include <sstream>
#include <vector>
struct string:std::string{using std::string::string;string(std::string s):std::string(s){}bool IsEmpty(){return empty();}
 template<class T>static std::string Text(T v){std::ostringstream o;o<<v;return o.str();}
 template<class... T>static string Format(string format,T... values){int i=0;
  auto replace=[&](auto value){auto tag="%"+std::to_string(++i);auto at=format.find(tag);if(at!=std::string::npos)format.replace(at,tag.size(),Text(value));};
  (replace(values),...);return format;}};
namespace ERR_HQ{std::vector<string> events;void Event(string,string detail){events.push_back(detail);}}
namespace ERR_ForceRules{bool Finite(float v){return std::isfinite(v);}}
struct Pool{int committed=108,limit=135,planned=25;int CommittedBodies(){return committed;}int BodyLimit(){return limit;}int PlannedBodies(){return planned;}};
struct ERR_ConvoyReceipt{bool Consumed=false;};
struct Service{int count=0;int Count(){return count;}};
struct Startup{Service* m_Service;Pool* m_Pool;bool m_Stopped=false,m_Automatic=true,create=false;
 int m_Target=3,m_Attempts=0,calls=0;float m_Began=-1,m_Next=0;string m_Reason,m_LastFailure,nextReason="no clear separated road formation in this bounded survey";
 bool StartOne(){calls++;m_Reason=nextReason;if(create)m_Service->count++;return create;}
'''+diag+r'''};
int main(){
 Service service;Pool pool;Startup s{&service,&pool};
 assert(s.BudgetStatus()=="body budget: 108/135 committed; each convoy requires 25");
 pool.committed=112;assert(s.BudgetStatus()=="body budget: 112/135 committed; each convoy requires 25");
 assert(s.RefusalReason(nullptr)=="insufficient shared body budget for another original convoy");
 pool.committed=110;assert(s.RefusalReason(nullptr)=="configured convoy or shared formation capacity unavailable");
 ERR_ConvoyReceipt consumed;consumed.Consumed=true;
 assert(s.RefusalReason(&consumed)=="original convoy slot already consumed; no replacement");
 s.m_Pool=nullptr;assert(s.BudgetStatus()=="body budget unavailable"&&s.RefusalReason(nullptr)=="convoy allocator unavailable");s.m_Pool=&pool;
 s.Tick(0,true);assert(ERR_HQ::events.empty());
 s.Tick(30000,false);assert(ERR_HQ::events.size()==1&&ERR_HQ::events.back().find("waiting for existing force admission")!=string::npos);
 s.Tick(35000,false);assert(ERR_HQ::events.size()==1&&s.calls==0&&s.m_Attempts==0);
 s.Tick(40000,true);assert(ERR_HQ::events.size()==2&&s.calls==1&&s.m_Attempts==1);
 s.Tick(45000,true);assert(ERR_HQ::events.size()==2&&s.calls==2); // retries remain silent
 pool.committed=112;s.nextReason=s.RefusalReason(nullptr);s.Tick(50000,true);
 assert(ERR_HQ::events.size()==3&&ERR_HQ::events.back().find("112/135")!=string::npos);
 assert(ERR_HQ::events.back().find("requires 25")!=string::npos);
 s.Tick(55000,true);assert(ERR_HQ::events.size()==3);
 s.create=true;s.Tick(60000,true);assert(service.count==1&&s.m_LastFailure.empty());
 s.create=false;s.Tick(65000,true);assert(ERR_HQ::events.size()==4); // new post-success failure visible
 assert(s.m_Target==3&&pool.limit==135&&pool.planned==25); // diagnostics never relax allocation
 Service blockedService;Startup blocked{&blockedService,&pool};blocked.nextReason=blocked.RefusalReason(nullptr);
 ERR_HQ::events.clear();blocked.Tick(0,true);
 for(int i=0;i<200;i++)blocked.Tick(30000+5000*i,true);
 assert(blocked.calls==120&&blocked.m_Attempts==120&&ERR_HQ::events.size()==2);
 assert(ERR_HQ::events.back().find("bounded startup attempts exhausted")!=string::npos);
 assert(ERR_HQ::events.back().find("insufficient shared body budget")!=string::npos);
 assert(ERR_HQ::events.back().find("could not find a clear") == string::npos);
}
''')
print('PASS: actual supply startup reasons expose unchanged body budget/requirement, journal only failure changes, preserve retry cadence/caps and report the true final refusal')
# Execute the entire actual combat-start method: exact detour cancellation must
# precede ordinary waypoint/tactics ownership; foreign claims prevent takeover.
start=cpp(body(TACTICS,'protected void Start(')).replace('intercept.','intercept->')
start=start.replace('"0 0 1"','vector(0,0,1)').replace('Vector(','vector(')
run(r'''
#include <cassert>
#include <vector>
#include <string>
#include <cmath>
using string=std::string;
struct vector{float v[3]={};vector(float x=0,float y=0,float z=0):v{x,y,z}{}float&operator[](int i){return v[i];}vector operator-(vector b){return {v[0]-b[0],v[1]-b[1],v[2]-b[2]};}float Length(){return std::sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);}void Normalize(){float n=Length();for(auto&x:v)x/=n;}};
template<class T>using Array=std::vector<T>;
struct Order{};struct Combat{bool Held=false;};struct Entity{vector GetOrigin(){return {};}};
struct ERR_ConvoyVehicle{int InterceptToken=0,clears=0,cancels=0;bool own=true,Released=false;Order order;Order*InterceptOrder=&order;struct Combat combat;struct Combat*Combat=&combat;struct Entity entity;struct Entity*Entity=&entity;
 void ClearIntercept(Order*p){cancels++;if(own&&p==&order)InterceptToken=0;}void ClearOrder(){clears++;}};
struct Column{int resets=0;void Reset(float){resets++;}};struct Receipt{string SourceId="original";};
struct ERR_SupplyTeam{bool SearchPlanned=true;int SearchStep=2;};
struct Task{bool Waiting=true;Array<ERR_SupplyTeam*>Teams;Array<ERR_ConvoyVehicle*>Vehicles;struct Column column;struct Column*Column=&column;struct Receipt receipt;struct Receipt*Receipt=&receipt;};
namespace ERR_HQ{int events=0;void Event(string,string){events++;}}
struct Tactics{Task*m_Task;int m_State=0,m_DismountAttempts=0,m_NextDismount=0,clears=0,orders=0;float m_NextSearch=0;bool m_TruckWithdrawn=true,m_OrdersIssued=true;vector m_Contact,m_Forward,m_Left;
 void Clear(){clears++;}void Orders(bool,float){orders++;}
'''+start+r'''
};
int main(){
 ERR_ConvoyVehicle a,b,truck;Task task;task.Vehicles={&a,&b,&truck};Tactics tactics{&task};
 a.InterceptToken=400001;b.InterceptToken=400002;b.own=false;
 tactics.Start({100,0,0},1000);assert(a.InterceptToken==0&&b.InterceptToken==400002&&tactics.clears==0&&task.column.resets==0&&tactics.orders==0&&!a.combat.Held);
 truck.Released=true;truck.Entity=nullptr; // retired transport slot must never be dereferenced
 b.own=true;tactics.Start({100,0,0},2000);assert(b.InterceptToken==0&&tactics.clears==1&&task.column.resets==1&&tactics.orders==1&&a.combat.Held&&b.combat.Held&&a.clears==1&&tactics.m_TruckWithdrawn);
}
''')
print('PASS: actual combat start releases only exact intercept claims before owning route/orders; foreign claim defers combat takeover')