jakub
6a667d8deb
Include the current addon, terrain integrations, tools, regression tests and recorded development evidence.
119 lines
6.3 KiB
Python
119 lines
6.3 KiB
Python
"""Execute town activation and no-pop-in policy, including split/invalid observers."""
|
|
from policy_harness import ROOT, body, run
|
|
p=ROOT/'addons/core/Scripts/Game/ERR/10_AI/ERR_TownGarrisons.c'
|
|
code=body(p,'static bool Safe(')+'\n'+body(p,'static bool Approached(')
|
|
code=code.replace('array<vector> players','Array<Vec>* players').replace('vector ', 'Vec ').replace('foreach (','for (').replace(' : players)', ' : *players)').replace('players.', 'players->').replace('vector.DistanceXZ','Vec::DistanceXZ').replace('ERR_ForceRules.FiniteVector','Finite')
|
|
run(r'''
|
|
#include <cassert>
|
|
#include <cmath>
|
|
#include <limits>
|
|
#include <vector>
|
|
struct Vec{float x,y,z;static float DistanceXZ(Vec a,Vec b){return std::hypot(a.x-b.x,a.z-b.z);}};
|
|
bool Finite(Vec v){return std::isfinite(v.x)&&std::isfinite(v.y)&&std::isfinite(v.z);}
|
|
template<class T>struct Array:std::vector<T>{using std::vector<T>::vector;bool IsEmpty(){return this->empty();}};
|
|
constexpr float DISTANCE=700;
|
|
'''+code+r'''
|
|
int main(){
|
|
Array<Vec> empty,near={{0,1000,0}},far={{701,0,0}},edge={{700,0,0}},split={{700,0,0},{-699,0,0}};
|
|
Vec origin{0,0,0};
|
|
assert(!Safe(origin,nullptr)&&!Safe(origin,&empty)&&!Approached(origin,&empty));
|
|
assert(!Safe(origin,&near)&&Approached(origin,&near)); // Horizontal distance, including helicopters
|
|
assert(Safe(origin,&far)&&!Approached(origin,&far));
|
|
assert(Safe(origin,&edge)&&Approached(origin,&edge)); // Exact 700m is safe and activates
|
|
assert(!Safe(origin,&edge,702)); // Planning leaves a small ground-placement margin
|
|
assert(!Safe(origin,&split)); // A distant lead player cannot hide a nearby teammate
|
|
split[1]={-701,0,0}; assert(Safe(origin,&split));
|
|
split[0]={699.99f,0,0}; assert(!Safe(origin,&split)); // Crossing boundary before birth rejects it
|
|
split[0]={std::numeric_limits<float>::quiet_NaN(),0,0}; assert(!Safe(origin,&split));
|
|
assert(!Safe(split[0],&edge)&&!Approached(split[0],&edge));
|
|
Array<Vec> objectEdge={{1000,0,0}},approaching={{1400,0,0}},outside={{1401,0,0}};
|
|
assert(Safe(origin,&objectEdge,1000)&&!Safe(origin,&objectEdge,1002));
|
|
assert(Approached(origin,&approaching,1400)&&!Approached(origin,&outside,1400));
|
|
objectEdge.push_back({999.9f,0,0});assert(!Safe(origin,&objectEdge,1000));
|
|
|
|
}
|
|
''')
|
|
print('PASS: town trigger and hard 700m exclusion for all observers, empty/invalid positions and final-check crossings')
|
|
|
|
# Execute the production guard split and geometric support policy, including
|
|
# unsafe chimney openings, steep faces and invalid trace values.
|
|
guards=body(p,'static int Fixed(')+'\n'+body(p,'static bool Selected(')+'\n'+body(p,'static bool Support(')
|
|
guards=guards.replace('ERR_ForceRules.Finite','std::isfinite').replace('Math.AbsFloat','std::fabs')
|
|
run(r'''
|
|
#include <cassert>
|
|
#include <cmath>
|
|
#include <limits>
|
|
'''+guards+r'''
|
|
int main(){
|
|
for(int count=0;count<=16;++count){
|
|
int fixed=Fixed(count),response=count-fixed;
|
|
assert(fixed+response==count&&fixed>=response&&fixed-response<=1);
|
|
assert(Fixed(count,0)==count && Fixed(count,2)==0);
|
|
}
|
|
for(int every=1;every<=4;every++) {
|
|
int selected=0;
|
|
for(int ordinal=1;ordinal<=32;ordinal++) {
|
|
bool decision=Selected(ordinal,every);
|
|
selected+=decision;
|
|
assert(Selected(ordinal,every)==decision); // Repeated visits never reroll
|
|
}
|
|
assert(selected==32/every);
|
|
}
|
|
assert(!Selected(0,1)&&!Selected(1,0)&&!Selected(1,5));
|
|
assert(Fixed(8)==4&&Fixed(1)==1&&Fixed(0)==0);
|
|
assert(Support(.5f,1.f,0.f));
|
|
assert(!Support(1.f,1.f,0.f)); // No floor below this footprint corner
|
|
assert(!Support(-1.f,1.f,0.f)); // Exhausted trace budget
|
|
assert(!Support(.5f,.84f,0.f)); // Steep/sloped face
|
|
assert(!Support(.5f,1.f,.21f)); // Edge/hole: corner is on a different floor
|
|
auto nan=std::numeric_limits<float>::quiet_NaN();
|
|
assert(!Support(nan,1.f,0.f)&&!Support(.5f,nan,0.f)&&!Support(.5f,1.f,nan));
|
|
}
|
|
''')
|
|
print('PASS: object guard split, hard 1000m exclusion / 1400m activation, footprint support, slopes, holes and invalid traces')
|
|
|
|
# Fixed sentries use the real admission hook; responders keep normal HQ eligibility.
|
|
admitted=body(p,'override protected void Admitted(').replace('override protected ','').replace('ERR_TownGarrison town','Town* town').replace('town.','town->').replace('town->ObjectSite.Id','town->ObjectSite->Id').replace('town->Hold.SetCompletionRadius','town->Hold->SetCompletionRadius').replace('ERR_HQ hq = ERR_HQ.Cast(m_Mode.Command());','HQ* hq = currentHQ;').replace('hq.Dedicate','hq->Dedicate')
|
|
run(r'''
|
|
#include <cassert>
|
|
struct Site{int Id=17;};
|
|
struct Hold{float radius=60;void SetCompletionRadius(float value){radius=value;}};
|
|
struct Town{bool FixedGuard=false;Site*ObjectSite;Hold*Hold;int Group=19;};
|
|
struct HQ{int calls=0;void Dedicate(int group,int site){assert(group==19&&site==17);calls++;}};
|
|
HQ*currentHQ;
|
|
'''.replace('Hold*Hold','struct Hold*Hold')+admitted+r'''
|
|
int main(){
|
|
HQ hq;currentHQ=&hq;Site site;Hold post;Town response{false,&site,&post};
|
|
Admitted(&response);assert(hq.calls==0&&post.radius==60);
|
|
Town fixed{true,&site,&post};Admitted(&fixed);assert(hq.calls==1&&post.radius==2);
|
|
}
|
|
''')
|
|
print('PASS: actual fixed-post admission reserves only stationary guards from HQ retasking and tightens their defend radius')
|
|
|
|
import re
|
|
structure=body(p,'static bool Structure(').replace('EMapDescriptorType.', 'EMapDescriptorType::')
|
|
labels=sorted(set(re.findall(r'EMapDescriptorType::(\w+)',structure)))
|
|
run(r'''
|
|
#include <cassert>
|
|
#include <string>
|
|
#include <algorithm>
|
|
#include <cctype>
|
|
struct string:std::string{
|
|
using std::string::string;
|
|
void ToLower(){std::transform(begin(),end(),begin(),[](unsigned char c){return std::tolower(c);});}
|
|
bool Contains(const char*s){return find(s)!=npos;}
|
|
};
|
|
namespace EMapDescriptorType{enum {'''+','.join(labels)+r'''};}
|
|
'''+structure+r'''
|
|
int main(){
|
|
assert(Structure("Prefabs/Structures/Industrial/Houses/Workshop.et",-1));
|
|
assert(Structure("Prefabs/Structures/Watchtower.et",-1));
|
|
assert(Structure("Prefabs/Custom/FactoryChimney.et",-1));
|
|
assert(Structure("UnknownMod/Asset.et",EMapDescriptorType::MDT_TOWER));
|
|
assert(!Structure("UnknownMod/Asset.et",-1));
|
|
for(const char*path:{"Prefabs/Props/Industrial/Barrel.et","Prefabs/Structures/BuildingParts/Industrial/Wall.et","Prefabs/Structures/Military/Flags/Flag.et","Prefabs/Structures/Ruins/House_Chimney.et","Prefabs/Vehicles/Military/Truck.et"})
|
|
assert(!Structure(path,-1));
|
|
}
|
|
''')
|
|
print('PASS: production site classification accepts structures/descriptors and excludes industrial props, fragments, flags, ruins and vehicles')
|