jakub
6a667d8deb
Include the current addon, terrain integrations, tools, regression tests and recorded development evidence.
155 lines
12 KiB
Python
155 lines
12 KiB
Python
"""Execute actual HQ assignment ownership and failed-radio backoff bodies."""
|
|
from policy_harness import ROOT, body, run
|
|
import os,re
|
|
from pathlib import Path
|
|
p=Path(os.environ.get('ERR_HQ_SOURCE',ROOT/'addons/core/Scripts/Game/ERR/10_AI/ERR_HQ.c'))
|
|
unit='\n'.join(body(p,s) for s in ('void CancelPending(', 'ERR_HQTask PlannedTask(', 'void ReleaseAssignment(', 'void Release()'))
|
|
lost='\n'.join(body(p,s) for s in ('protected void FinishWatch(', 'protected void LostOrder(')).replace('protected ', '')
|
|
if 'protected float HuntCommitment(' in p.read_text(): lost=body(p,'protected float HuntCommitment(').replace('protected ', '')+'\n'+lost
|
|
if 'protected void ReconsiderHunt(' in p.read_text(): lost=body(p,'protected void ReconsiderHunt(').replace('protected ', '')+'\n'+lost
|
|
if 'protected void RememberCompletedHunt(' in p.read_text(): lost=body(p,'protected void RememberCompletedHunt(').replace('protected ', '')+'\n'+lost
|
|
retask=body(p,'protected void Retask(')
|
|
queue=retask[retask.index(' ERR_HQHuntWindow hunt = Hunt(belief.BeliefId);'):]
|
|
queue=queue[:queue.index(';',queue.index('if (hunt)'))+1]
|
|
def adapt(code):
|
|
code=code.replace('EngineerMine.', 'EngineerMine->')
|
|
code=code.replace('ref ', '')
|
|
code=code.replace('.IsEmpty()', '.empty()')
|
|
code=code.replace('null','nullptr').replace('Math.','Math::').replace('ERR_GameMode.Get()', 'ERR_GameMode::Get()')
|
|
code=code.replace('SCR_EntityHelper.DeleteEntityAndChildren', 'SCR_EntityHelper::DeleteEntityAndChildren')
|
|
code=code.replace('ERR_HQUnit unit', 'ERR_HQUnit* unit')
|
|
code=code.replace('ERR_HQTask ', 'ERR_HQTask* ').replace('ERR_GameMode ', 'ERR_GameMode* ')
|
|
code=code.replace('ERR_ForceRecord record;', 'ERR_ForceRecord* record=nullptr;')
|
|
code=code.replace('ERR_HQHuntWindow hunt', 'ERR_HQHuntWindow* hunt')
|
|
code=code.replace('foreach (ERR_HQUnit other : m_Units)', 'for (ERR_HQUnit* other : m_Units)')
|
|
code=re.sub(r'\b(mode|record|Group|unit|other|task|planned|hunt)\.', r'\1->', code)
|
|
code=code.replace('mode->Forces().FindGroup', 'mode->Forces()->FindGroup')
|
|
return code.replace('other->Task.', 'other->Task->')
|
|
run(r'''
|
|
#include <cassert>
|
|
#include <vector>
|
|
#include <algorithm>
|
|
#include <string>
|
|
struct Math {static float Min(float a,float b){return std::min(a,b);}static float Max(float a,float b){return std::max(a,b);}};
|
|
struct ERR_HQTask {int OperationId=0,ExecutionId=0;float ExpiresAt=120000;bool ReleaseOnly=false;int BeliefId=0;std::string WatchSourceId,SecuritySite;int WatchMessageId=0,WatchRequestId=0;bool Investigation(){return !WatchSourceId.empty();}};
|
|
struct ERR_HQReport {};
|
|
struct ERR_HQRoute {};
|
|
struct AIWaypoint {int deleted=0;};
|
|
struct SCR_AIGroup {int removals=0; AIWaypoint* last=nullptr;
|
|
void RemoveWaypoint(AIWaypoint* p){removals++;last=p;}};
|
|
struct ERR_ForceRecord {bool Eliminated=false;int Duty=2,HomeDuty=1,DutyTarget=200,HomePosition=100;};
|
|
struct Ledger {ERR_ForceRecord* record=nullptr;ERR_ForceRecord* FindGroup(SCR_AIGroup*){return record;}};
|
|
struct ERR_GameMode {Ledger ledger;static ERR_GameMode* current;
|
|
static ERR_GameMode* Get(){return current;} Ledger* Forces(){return &ledger;}};
|
|
ERR_GameMode* ERR_GameMode::current=nullptr;
|
|
struct SCR_EntityHelper {static void DeleteEntityAndChildren(AIWaypoint* p){p->deleted++;}};
|
|
struct ERR_HQHuntWindow {float CompletedUntil=0;float NextHunt=0;};
|
|
struct MineJob {int stops=0;void Stop(){stops++;}};
|
|
struct TestWorld{operator bool(){return true;}float GetWorldTime(){return 0;}};struct TestGame{operator bool(){return true;}TestWorld GetWorld(){return {};}};TestGame GetGame(){return {};}struct ExecutionDouble{operator bool(){return false;}void Stop(float,bool){}void Receive(ERR_HQTask*,float){}};
|
|
struct ERR_HQUnit {ExecutionDouble Execution;int Id=1;MineJob* EngineerMine=nullptr;
|
|
SCR_AIGroup* Group=nullptr;AIWaypoint* Waypoint=nullptr;
|
|
ERR_HQTask *Task=nullptr,*PendingTask=nullptr;
|
|
ERR_HQReport *Assignment=nullptr,*PendingOrder=nullptr;
|
|
void* PendingConvoyOrder=nullptr;
|
|
ERR_HQRoute* Downlink=nullptr;bool PendingCheckin=false;
|
|
'''+adapt(unit)+r'''};
|
|
struct Watch {int calls=0;std::string source;int message=0,request=0;
|
|
bool FinishInvestigation(std::string s,int m,int r,float){calls++;source=s;message=m;request=r;return true;}};
|
|
struct HQ {struct Operations{void Release(int,int,float){}}m_Operations;Watch m_Watch;std::vector<ERR_HQUnit*> m_Units;ERR_HQHuntWindow window;
|
|
ERR_HQHuntWindow* Hunt(int){return &window;}
|
|
'''+adapt(lost)+'\nvoid QueueHorizon(ERR_HQTask* task,int id){struct Belief{int BeliefId;};Belief belief{id};'+adapt(queue)+'}'+r'''};
|
|
int main(){
|
|
ERR_GameMode mode;ERR_GameMode::current=&mode;ERR_ForceRecord record;mode.ledger.record=&record;
|
|
SCR_AIGroup group;ERR_HQReport oldReport,newReport;ERR_HQTask oldTask,newTask;ERR_HQRoute route;
|
|
oldTask.BeliefId=1;newTask.BeliefId=2;AIWaypoint oldWaypoint;
|
|
ERR_HQUnit u;u.Group=&group;u.Waypoint=&oldWaypoint;u.Assignment=&oldReport;u.Task=&oldTask;
|
|
u.PendingOrder=&newReport;u.PendingTask=&newTask;u.Downlink=&route;
|
|
assert(u.PlannedTask()==&newTask);
|
|
u.CancelPending();
|
|
assert(!u.PendingOrder&&!u.PendingTask&&!u.Downlink);
|
|
assert(u.Task==&oldTask&&u.Assignment==&oldReport&&u.Waypoint==&oldWaypoint);
|
|
assert(oldWaypoint.deleted==0&&group.removals==0&&record.Duty==2);
|
|
assert(u.PlannedTask()==&oldTask);
|
|
// Expiry of the current task must leave its replacement radio transaction intact.
|
|
u.PendingOrder=&newReport;u.PendingTask=&newTask;u.Downlink=&route;
|
|
MineJob miner;u.EngineerMine=&miner;
|
|
u.ReleaseAssignment();assert(miner.stops==1);
|
|
assert(!u.Assignment&&!u.Task&&!u.Waypoint);
|
|
assert(u.PendingOrder==&newReport&&u.PendingTask==&newTask&&u.Downlink==&route);
|
|
assert(oldWaypoint.deleted==1&&group.removals==1&&group.last==&oldWaypoint);
|
|
assert(record.Duty==record.HomeDuty&&record.DutyTarget==record.HomePosition);
|
|
u.ReleaseAssignment();assert(oldWaypoint.deleted==1&&group.removals==1);
|
|
u.Release();assert(!u.PendingOrder&&!u.PendingTask&&!u.Downlink);
|
|
// Elimination and absent group/mode cannot rewrite casualty state or double-delete.
|
|
AIWaypoint detached;u.Waypoint=&detached;u.Group=nullptr;record.Eliminated=true;record.Duty=9;
|
|
ERR_GameMode::current=nullptr;u.Release();assert(detached.deleted==1&&record.Duty==9);
|
|
ERR_GameMode::current=&mode;u.Group=&group;u.ReleaseAssignment();assert(record.Duty==9);
|
|
// A failed initial dispatch can retry after a short backoff.
|
|
HQ hq;hq.m_Units={&u};hq.window.NextHunt=300000;
|
|
u.PendingOrder=&newReport;u.PendingTask=&newTask;u.Downlink=&route;
|
|
hq.LostOrder(&u,1000);assert(hq.window.NextHunt==16000&&!u.PendingOrder);
|
|
// Failed retask preserves delivered assignment and its active hunt window.
|
|
u.Task=&newTask;u.Assignment=&oldReport;u.Waypoint=&oldWaypoint;
|
|
u.PendingOrder=&newReport;u.PendingTask=&newTask;u.Downlink=&route;hq.window.NextHunt=300000;
|
|
hq.LostOrder(&u,1000);assert(hq.window.NextHunt==300000&&u.Task==&newTask&&u.Waypoint==&oldWaypoint);
|
|
// Another group's pending hunt prevents duplicate retry commitments.
|
|
u.Task=nullptr;u.Assignment=nullptr;u.Waypoint=nullptr;
|
|
ERR_HQUnit peer;peer.PendingTask=&newTask;peer.PendingOrder=&newReport;hq.m_Units.push_back(&peer);
|
|
u.PendingTask=&newTask;u.PendingOrder=&newReport;u.Downlink=&route;
|
|
hq.LostOrder(&u,2000);assert(hq.window.NextHunt==300000);
|
|
// Execute the actual Retask deadline extension, then fail its downlink.
|
|
// The existing short delivered hunt must not inherit the failed long horizon.
|
|
{HQ h;ERR_HQUnit owner;ERR_HQTask delivered,pending;ERR_HQReport r;ERR_HQRoute link;AIWaypoint w;
|
|
delivered.BeliefId=7;delivered.ExpiresAt=120000;pending.BeliefId=7;pending.ExpiresAt=600000;
|
|
owner.Task=&delivered;owner.Assignment=&r;owner.Waypoint=&w;
|
|
owner.PendingTask=&pending;owner.PendingOrder=&r;owner.Downlink=&link;h.m_Units={&owner};h.window.NextHunt=300000;
|
|
h.QueueHorizon(&pending,7);assert(h.window.NextHunt==780000);
|
|
h.LostOrder(&owner,30000);assert(h.window.NextHunt==300000);
|
|
assert(owner.Task==&delivered&&owner.Assignment==&r&&owner.Waypoint==&w&&!owner.PendingTask);
|
|
// A surviving peer's longer pending order remains fully reserved.
|
|
ERR_HQUnit peer;ERR_HQTask active,replacement;
|
|
active.BeliefId=7;active.ExpiresAt=400000;replacement.BeliefId=7;replacement.ExpiresAt=700000;
|
|
peer.Task=&active;peer.Assignment=&r;peer.PendingTask=&replacement;peer.PendingOrder=&r;h.m_Units.push_back(&peer);
|
|
owner.PendingTask=&pending;owner.PendingOrder=&r;h.window.NextHunt=1000000;
|
|
h.LostOrder(&owner,30000);assert(h.window.NextHunt==880000&&peer.PendingTask==&replacement&&peer.Task==&active);
|
|
// An unrelated pending replacement cannot conceal its original same-track task.
|
|
replacement.BeliefId=8;owner.PendingTask=&pending;owner.PendingOrder=&r;h.window.NextHunt=1000000;
|
|
h.LostOrder(&owner,30000);assert(h.window.NextHunt==580000);
|
|
// Orphan pointers and non-pursuit orders cannot hold a hunt. A still-owned
|
|
// expired active search preserves its completed interval.
|
|
owner.Task=nullptr;owner.Assignment=nullptr;peer.Assignment=nullptr;peer.PendingOrder=nullptr;
|
|
owner.PendingTask=&pending;owner.PendingOrder=&r;h.window.NextHunt=1000000;
|
|
h.LostOrder(&owner,30000);assert(h.window.NextHunt==45000);
|
|
for(int kind=0;kind<4;kind++){
|
|
peer.Assignment=&r;active.ExpiresAt=400000;active.ReleaseOnly=false;active.SecuritySite="";active.WatchSourceId="";
|
|
if(kind==0){active.ReleaseOnly=true;}if(kind==1){active.SecuritySite="site";}if(kind==2){active.WatchSourceId="patrol";}if(kind==3){active.ExpiresAt=30000;}
|
|
owner.PendingTask=&pending;owner.PendingOrder=&r;h.window.NextHunt=1000000;
|
|
h.LostOrder(&owner,30000);assert(h.window.NextHunt==(kind==3?210000:45000));}
|
|
// Clamping only: even a surviving long commitment must not raise earlier pacing.
|
|
active.ExpiresAt=400000;owner.PendingTask=&pending;owner.PendingOrder=&r;h.window.NextHunt=40000;
|
|
h.LostOrder(&owner,30000);assert(h.window.NextHunt==40000);
|
|
}
|
|
// A failed pending watch investigation completes only that pending lineage.
|
|
ERR_HQTask activeWatch,pendingWatch;activeWatch.WatchSourceId="patrol-A";activeWatch.WatchMessageId=41;activeWatch.WatchRequestId=1;
|
|
pendingWatch.WatchSourceId="patrol-B";pendingWatch.WatchMessageId=42;pendingWatch.WatchRequestId=2;
|
|
u.Task=&activeWatch;u.Waypoint=&oldWaypoint;u.Assignment=&oldReport;
|
|
u.PendingTask=&pendingWatch;u.PendingOrder=&newReport;u.Downlink=&route;
|
|
hq.LostOrder(&u,3000);assert(hq.m_Watch.calls==1&&hq.m_Watch.source=="patrol-B"&&hq.m_Watch.message==42&&hq.m_Watch.request==2);
|
|
assert(u.Task==&activeWatch&&u.Waypoint==&oldWaypoint&&u.Assignment==&oldReport);
|
|
assert(!u.PendingTask&&!u.PendingOrder&&!u.Downlink&&hq.window.NextHunt==300000);
|
|
// Dropped status-check-in transport cannot finish the delivered investigation.
|
|
u.PendingCheckin=true;u.Downlink=&route;hq.LostOrder(&u,4000);
|
|
assert(!u.PendingCheckin&&!u.Downlink&&u.Task==&activeWatch&&hq.m_Watch.calls==1);
|
|
ERR_HQTask recall;recall.ReleaseOnly=true;u.PendingTask=&recall;u.PendingOrder=&newReport;u.Downlink=&route;
|
|
hq.LostOrder(&u,5000);assert(!u.PendingTask&&u.Task==&activeWatch&&u.Waypoint==&oldWaypoint&&hq.m_Watch.calls==1);
|
|
u.Task=nullptr;u.Waypoint=nullptr;u.Assignment=nullptr;
|
|
ERR_HQTask security;security.SecuritySite="radio-1";u.PendingTask=&security;u.PendingOrder=&newReport;u.Downlink=&route;
|
|
hq.window.NextHunt=300000;hq.LostOrder(&u,5000);
|
|
assert(!u.PendingTask&&!u.Downlink&&hq.window.NextHunt==300000&&hq.m_Watch.calls==1);
|
|
// Unrelated belief cannot suppress bounded retry, and existing sooner retry remains sooner.
|
|
peer.PendingTask=&oldTask;u.PendingTask=&newTask;hq.window.NextHunt=5000;
|
|
hq.LostOrder(&u,2000);assert(hq.window.NextHunt==5000);
|
|
}
|
|
''')
|
|
print('PASS: actual failed-retask deadline rollback plus assignment cancellation/release preserves radio ownership, native waypoint lifecycle and failed-order retry boundaries')
|