A Civilization-style strategy game about governing Israel from 15 May 1948. Real ministers, real map, every fact sourced. Unity + deterministic C# sim.
#nullable enable
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using NUnit.Framework;
using Statecraft.Game.Map;
using Statecraft.Game.Map.Collection;
using Statecraft.Sim;
using UnityEditor.SceneManagement;
using UnityEngine;
using Object = UnityEngine.Object;
/// <summary>#1800: the base compiles these fixtures too; reflection is confined to the new, absent-on-base API.</summary>
public class CollectionLeaveTests
{
Action<string, CollectionDetail, Action<GameObject?>> people = null!, rural = null!;
readonly List<Action<GameObject?>> delayed = new List<Action<GameObject?>>();
GameObject prefab = null!;
int acquired, released;
readonly Dictionary<CollectionDetail, int> acquiredBy = new Dictionary<CollectionDetail, int>(), releasedBy = new Dictionary<CollectionDetail, int>();
int Acquired(CollectionDetail detail) => acquiredBy.TryGetValue(detail, out int n) ? n : 0;
int Released(CollectionDetail detail) => releasedBy.TryGetValue(detail, out int n) ? n : 0;
sealed class Lease : IDisposable
{
Action? release;
public Lease(Action release) { this.release = release; }
public void Dispose() { var call = release; release = null; call?.Invoke(); }
}
[SetUp] public void Setup()
{
acquired = released = 0; delayed.Clear(); acquiredBy.Clear(); releasedBy.Clear();
people = CivilianPeople.Request; rural = RuralLife.Request;
prefab = GameObject.CreatePrimitive(PrimitiveType.Cube);
prefab.name = "TEST ONLY original"; prefab.transform.position = Vector3.one * -100000;
CivilianPeople.Request = RuralLife.Request = (_, __, answer) => answer(prefab);
}
[TearDown] public void Reset()
{
CivilianPeople.Request = people; RuralLife.Request = rural;
EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
CollectionResidencyMetrics.Stop();
}
MapScene Map()
{
EditorSceneManager.OpenScene("Assets/Map.unity", OpenSceneMode.Single);
prefab = GameObject.CreatePrimitive(PrimitiveType.Cube); prefab.transform.position = Vector3.one * -100000;
var map = Object.FindFirstObjectByType<MapScene>(); map.Build(); return map;
}
Component Layer(bool isRural, MapScene map) => isRural ? RuralLife.Show(map)! :
CivilianPeople.ShowAt(map, new DateTime(1949, 1, 1), Array.Empty<Placement>(), ContentLoader.Load(Statecraft.Game.Paths.Content))!;
static int Count(Component layer) => ((System.Collections.ICollection)layer.GetType().GetField("Placed")!.GetValue(layer)!).Count;
/// <summary>Placed Far originals: every civilian figure (each has its Far), or RuralLife's Far rows.</summary>
static int FarCount(Component layer)
{
int n = 0;
foreach (var placed in (System.Collections.IEnumerable)layer.GetType().GetField("Placed")!.GetValue(layer)!)
{
// RuralLife.Placed is a (Key, Model, Detail, ...) value tuple: its Detail is the runtime field Item3.
var detail = placed.GetType().GetField("Item3");
if (detail == null || detail.FieldType != typeof(CollectionDetail)
|| (CollectionDetail)detail.GetValue(placed)! == CollectionDetail.Far) n++;
}
return n;
}
/// <summary>Live Near original instances: a figure's "Near" child or a rural ":near" instance.</summary>
static int NearInstances(Component layer) =>
layer.GetComponentsInChildren<Transform>(true).Count(t => t.name == "Near" || t.name.EndsWith(":near", StringComparison.Ordinal));
void Configure(Component layer, bool delay)
{
// The baseline has neither API; still drive its existing visible/leave behaviour and observe the regression.
var configure = layer.GetType().GetMethod("ConfigureResidency", BindingFlags.Instance | BindingFlags.NonPublic);
if (configure == null) return;
var policyType = configure.GetParameters()[0].ParameterType;
var policy = Activator.CreateInstance(policyType, 1000000f, 1000001f, 100000f, 110000f, 0, "TEST ONLY");
Func<string, CollectionDetail, Action<GameObject?>, IDisposable> acquire = (_, __, answer) =>
{
acquired++; acquiredBy[__] = Acquired(__) + 1;
if (delay) delayed.Add(answer); else answer(prefab);
return new Lease(() => { released++; releasedBy[__] = Released(__) + 1; });
};
configure.Invoke(layer, new object[] { policy!, acquire });
}
static void Camera(Component layer, float height)
{
var go = new GameObject("TEST ONLY camera"); var camera = go.AddComponent<Camera>();
go.transform.position = new Vector3(0, height, 0); go.transform.rotation = Quaternion.Euler(90, 0, 0);
layer.GetType().GetMethod("Choose", BindingFlags.Instance | BindingFlags.NonPublic)!.Invoke(layer,
new object[] { default(UnityEngine.Rendering.ScriptableRenderContext), camera });
Object.DestroyImmediate(go);
}
[TestCase(false)] [TestCase(true)]
public void LeavingDestroysOriginalsAndRevisitAcquiresAgain(bool isRural)
{
var layer = Layer(isRural, Map()); Configure(layer, false);
Camera(layer, 10000); Assert.Greater(Count(layer), 0);
var first = layer.transform.GetChild(0); int stableAcquires = acquired;
Camera(layer, 10000);
Assert.AreSame(first, layer.transform.GetChild(0), "an unchanged camera demand must not rebuild every frame");
Assert.AreEqual(stableAcquires, acquired);
// Owner ruling 29 (30 Oct 2026): "Far models map-wide (Recommended)": Far stays map-wide; only Near loads/unloads by camera.
// Leaving keeps every Far original and its lease, and retires (destroys and releases) every Near one.
int far = FarCount(layer), nearFirst = Acquired(CollectionDetail.Near);
Assert.Greater(far, 0, "Far originals are drawn at 10 km");
Assert.Greater(nearFirst, 0, "the close 10 km camera took Near leases (people and rural)");
Assert.AreEqual(nearFirst > 0, NearInstances(layer) > 0, "Near leases have Near instances");
Camera(layer, 250000);
Assert.AreEqual(far, FarCount(layer), "leaving keeps every map-wide Far original");
Assert.AreSame(first, layer.transform.GetChild(0), "the Far instances are not rebuilt");
Assert.AreEqual(0, NearInstances(layer), "hiding is not retirement");
Assert.AreEqual(Acquired(CollectionDetail.Near), Released(CollectionDetail.Near), "every old Near lease retired");
Assert.AreEqual(0, Released(CollectionDetail.Far), "no Far lease retires on leave");
int farBefore = Acquired(CollectionDetail.Far), nearBefore = Acquired(CollectionDetail.Near);
Camera(layer, 10000); Assert.AreEqual(far, FarCount(layer));
Assert.AreEqual(farBefore, Acquired(CollectionDetail.Far), "revisit re-acquires no Far");
Assert.AreEqual(nearFirst, Acquired(CollectionDetail.Near) - nearBefore, "revisit acquires the same Near set again");
Assert.AreEqual(nearFirst > 0, NearInstances(layer) > 0);
Object.DestroyImmediate(layer.gameObject); Assert.AreEqual(acquired, released);
}
[TestCase(false)] [TestCase(true)]
public void ADelayedAnswerCannotResurrectALeftCategory(bool isRural)
{
var layer = Layer(isRural, Map()); Configure(layer, true);
Camera(layer, 10000); Camera(layer, 250000);
foreach (var answer in delayed.ToArray()) answer(prefab);
// Owner ruling 29 (30 Oct 2026): "Far models map-wide (Recommended)": Far stays map-wide; only Near loads/unloads by camera.
// A Far demand never left, so its late answer draws; a late Near answer for the departed view cannot.
Assert.Greater(Acquired(CollectionDetail.Near), 0, "the close 10 km camera asked for Near (people and rural)");
Assert.AreEqual(0, NearInstances(layer), "no Near original is resurrected");
Assert.AreEqual(Acquired(CollectionDetail.Near), Released(CollectionDetail.Near), "every departed Near lease retired");
Assert.AreEqual(0, Released(CollectionDetail.Far), "the map-wide Far leases are kept");
Assert.Greater(FarCount(layer), 0, "the Far answers draw map-wide");
}
}