Allow off-airport extraction across terrains; record Workshop 0.0.124

tests/test_generated_sites.py

@@ -8,7 +8,7 @@ s=s.replace('System.GetTickCount','Clock::Now').replace('Replication.IsServer','
 s=s.replace('float floor;','float floor=0;').replace('protected ', '').replace('ref ERR_SiteDefinition retained', 'Site* retained').replace('retained.', 'retained->').replace('m_Definition.', 'm_Definition->').replace('ERR_LocationKind.', 'Kind::')
 s=s.replace('foreach (Site* site : m_Definition->Sites)', 'for (Site* site : m_Definition->Sites)')
 s=s.replace('bool fits;', 'bool fits=false;')
-s=s.replace('ERR_Actors.', 'ERR_Actors::').replace('ERR_CampTerrain.', 'ERR_CampTerrain::').replace('ERR_RescueLanding.', 'ERR_RescueLanding::')
+s=s.replace('ERR_Actors.', 'ERR_Actors::').replace('ERR_CampTerrain.', 'ERR_CampTerrain::').replace('ERR_RescueLanding.', 'ERR_RescueLanding::').replace('ERR_AirfieldPlacement.', 'ERR_AirfieldPlacement::')
 run(r'''
 #include <cassert>
 #include <string>
@@ -19,12 +19,13 @@ struct vector{float a[3];float& operator[](int i){return a[i];}};vector Vector(f
 vector operator+(vector a,vector b){return Vector(a[0]+b[0],a[1]+b[1],a[2]+b[2]);}
 namespace ERR_Actors{vector Ground(vector p){return p;}}
 namespace ERR_CampTerrain{vector Rotate(vector p,float){return p;}}
+namespace ERR_AirfieldPlacement{bool clear=true;int groundChecks=0,airportChecks=0;bool Clear(vector){airportChecks++;return clear;}bool ClearGround(vector){groundChecks++;return clear;}}
 namespace ERR_RescueLanding{bool fits=true;bool Fits(vector){return fits;}}
 namespace Result{enum Value{FAILED=-1,PENDING,READY};}using ERR_PrepareResult=Result::Value;
 namespace Clock {int now=0,step=1;int Now(){int t=now;now+=step;return t;}}
 bool Server(){return true;}float RandomFloat(float a,float b){return (a+b)/2;}template<class...T>void PrintFormat(T...){}
 namespace Kind{enum{PRISON,RADIO,EXTRACTION,OUTPOST,DEPOT,MORTAR,HOSPITAL};}
-struct Site{int Kind=Kind::PRISON;bool required=false;string Label="Test site";vector Position=Vector(10,0,20),AircraftOffset=Vector(12,0,0);float Heading=0;bool PlacementResolved=false,RandomClear=true;string Id="site";};
+struct Site{int Kind=Kind::PRISON;bool required=false;string Label="Test site";vector Position=Vector(10,0,20),AircraftOffset=Vector(12,0,0);float Heading=0;bool PlacementResolved=false,RandomClear=true,RequireAirfield=false;string Id="site";};
 template<class T>struct Array:std::vector<T>{using std::vector<T>::operator=;int Count(){return this->size();}int Find(T v){auto i=std::find(this->begin(),this->end(),v);return i==this->end()?-1:i-this->begin();}void Remove(int i){this->erase(this->begin()+i);}void InsertAt(T v,int i){this->insert(this->begin()+i,v);}};
 struct Definition{bool TerrainGenerated=false;Array<Site*> Sites;Site* required=nullptr;bool Valid(){return !required||Sites.Find(required)>=0;}};
 struct Terrain{string Rejection(){return "terrain";}bool clear=true;Site* refused=nullptr;int queries=0;bool SiteAt(Site* site,vector,float,float& height){queries++;height=42;return clear&&site!=refused;}};
@@ -74,6 +75,12 @@ int main(){
  {Clock::now=0;Scheduler s;Site before,a,after;a.Kind=Kind::HOSPITAL;
  s.definition.Sites={&before,&a,&after};s.definition.required=&a;s.m_Pending={&a};s.m_Attempts=12000;s.m_Terrain.clear=false;
  assert(s.Tick()==Result::FAILED&&s.definition.Sites.size()==3&&s.definition.Sites[1]==&a&&!a.PlacementResolved);}
+ // Primary pad failures retry before commitment; authored fallback cannot bypass them.
+ {Clock::now=0;Scheduler s;Site a;a.Kind=Kind::EXTRACTION;s.m_Pending={&a};ERR_AirfieldPlacement::clear=false;
+ assert(s.Tick()==Result::PENDING&&!a.PlacementResolved);s.m_Attempts=12000;
+ assert(s.Tick()==Result::FAILED&&!a.PlacementResolved);ERR_AirfieldPlacement::clear=true;}
+ {Clock::now=0;Scheduler s;Site a;a.Kind=Kind::EXTRACTION;s.m_Pending={&a};int checks=ERR_AirfieldPlacement::groundChecks;
+ while(s.Tick()==Result::PENDING){}assert(a.PlacementResolved&&ERR_AirfieldPlacement::groundChecks>checks&&ERR_AirfieldPlacement::airportChecks==0);}
  // Extraction candidates without secondary fleet space remain uncommitted and are retried.
  {Clock::now=0;Scheduler s;Site a;a.Kind=Kind::EXTRACTION;s.m_Pending={&a};s.definition.Sites={&a};ERR_RescueLanding::fits=false;
  assert(s.Tick()==Result::PENDING&&!a.PlacementResolved);ERR_RescueLanding::fits=true;
@@ -113,3 +120,47 @@ int main(){Scenario s;
 }
 ''')
 print('PASS: actual background activation waits an hour empty without consuming placement time; disconnect does not reset active budget')
+
+# Execute actual spacing policy in both placement orders: randomized extraction
+# must not be committed outside the prison's escape boundary.
+spacing=body(p,'protected bool Separated(')
+for before,after in [('protected ',''),('ERR_SiteDefinition candidate','Site* candidate'),('foreach (ERR_SiteDefinition other :','for (Site* other :'),('candidate.','candidate->'),('other.','other->'),('m_Definition.','m_Definition->'),('ERR_LocationKind.','Kind::'),('vector.DistanceXZ','DistanceXZ'),('ERR_GameMode.Get().EscapeRadius()','escapeRadius')]:
+ spacing=spacing.replace(before,after)
+run(r'''
+#include <cassert>
+#include <cmath>
+#include <vector>
+struct vector{float x,z;};float DistanceXZ(vector a,vector b){return std::hypot(a.x-b.x,a.z-b.z);}
+namespace Kind{enum{PRISON,RADIO,EXTRACTION,OUTPOST,DEPOT,MORTAR,HOSPITAL};}
+struct Site{int Kind=Kind::PRISON;bool RandomClear=true,PlacementResolved=true;vector Position{0,0};};
+struct Definition{std::vector<Site*> Sites;};
+struct Placement{Definition definition;Definition* m_Definition=&definition;float escapeRadius=5000;
+'''+spacing+r'''
+};
+int main(){
+ for(bool reverse:{false,true}){
+ Placement s;Site a,b;a.Kind=reverse?Kind::PRISON:Kind::EXTRACTION;b.Kind=reverse?Kind::EXTRACTION:Kind::PRISON;
+ s.definition.Sites={&a,&b};
+ assert(s.Separated(&a,{1000,0},false));
+ assert(!s.Separated(&a,{4900,0},false));
+ assert(!s.Separated(&a,{6000,0},true)); // authored fallback has identical safety
+ assert(!s.Separated(&a,{100,0},false));
+ b.PlacementResolved=false;assert(s.Separated(&a,{6000,0},false)); // unused authored seed
+ }
+}
+''')
+print('PASS: actual separation keeps randomized extraction within the escape boundary in both placement orders, including fallback')
+
+# Exercise the production randomized-kind rejection expression, including extraction.
+validation=body(ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_SiteDefinition.c','bool Valid(')
+random_rule=next(line.strip() for line in validation.splitlines() if 'if (site.RandomClear' in line)
+rule=random_rule.replace('ERR_LocationKind.','Kind::')
+run(r'''
+#include <cassert>
+#include <initializer_list>
+namespace Kind{enum{PRISON,RADIO,EXTRACTION,OUTPOST,DEPOT,MORTAR,HOSPITAL};}
+struct Site{bool RandomClear=true;int Kind=Kind::EXTRACTION;};
+bool Accept(Site site){''' + rule + r''' return true;}
+int main(){for(int kind:{Kind::PRISON,Kind::RADIO,Kind::EXTRACTION,Kind::OUTPOST,Kind::DEPOT,Kind::MORTAR,Kind::HOSPITAL}){Site site;site.Kind=kind;assert(Accept(site));}Site invalid;invalid.Kind=99;assert(!Accept(invalid));}
+''')
+print('PASS: scenario validation admits randomized extraction definitions and rejects unsupported randomized site kinds')