A Civilization-style strategy game about governing Israel from 15 May 1948. Real ministers, real map, every fact sourced. Unity + deterministic C# sim.
using System;
using System.Collections.Generic;
using System.Linq;
using Statecraft.Sim;
public class EventTests
{
const string Shortage = @"
id: shortage
title: Bread lines
text: '{finance_minister} reports shortages.'
office: finance_minister
from: 1948-06-01
conditions:
- indicator: food_supply
max: 0.45
options:
- id: ration
text: Ration food
historical: true
recommended: true
effects:
- target: food_supply
delta: 0.2
- id: import
text: Buy abroad
alternative: { basis: design }
effects:
- target: fx_reserves
delta: -10
- id: escalate
text: Blame the border
alternative: { basis: design }
set_rung: 3
sources: [{ url: https://example.org/event, checked: 2026-10-18 }]
";
static Content Load(Dictionary<string, string> events) => ContentLoader.Load(Fixture.Write(events: events));
static GameState State(Content c, DateTime d)
{
var s = new GameState { Date = d, RngState = 3 };
EffectsSystem.Init(c, s); EconomySystem.Init(c, s);
return s;
}
[Fact]
public void TriggersWhenDateAndConditionsHoldOnlyOnce()
{
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = Shortage });
var why = new List<Cause>();
var s = State(c, new DateTime(1948, 5, 20));
EventSystem.Trigger(c, s, why); Assert.Empty(s.PendingEvents); // too early
s.Date = new DateTime(1948, 6, 1);
EventSystem.Trigger(c, s, why); Assert.Equal(new[] { "shortage" }, s.PendingEvents);
s.PendingEvents.Clear();
EventSystem.Trigger(c, s, why); Assert.Empty(s.PendingEvents); // fires once
}
[Fact]
public void ConditionBlocksTrigger()
{
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = Shortage });
var s = State(c, new DateTime(1948, 6, 1)); s.Indicators["food_supply"] = 0.9;
EventSystem.Trigger(c, s, new List<Cause>());
Assert.Empty(s.PendingEvents);
}
[Fact]
public void ChooseAppliesEffectsAndClearsPending()
{
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = Shortage });
var s = State(c, new DateTime(1948, 6, 1)); var why = new List<Cause>();
EventSystem.Trigger(c, s, why);
Assert.Null(EventSystem.Choose(c, s, "shortage", "import", why));
Assert.Equal(40, s.FxReserves);
Assert.Empty(s.PendingEvents);
Assert.Equal("That event is not waiting for a decision", EventSystem.Choose(c, s, "shortage", "ration", why));
}
/// <summary>R-EFX-001: a `food` effect moves the stock by whole units, rounding half away from zero, and the
/// stock stays in 0..int.MaxValue even at the range edge.</summary>
[Theory]
[InlineData("7", 0, 7)]
[InlineData("2.5", 100, 103)]
[InlineData("-2.5", 100, 97)]
[InlineData("2147483647", 100, 2147483647)]
public void AnOptionCanMoveTheFoodStock(string delta, int start, int expected)
{
var ev = Shortage.Replace("target: fx_reserves\n delta: -10", "target: food\n delta: " + delta);
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = ev });
var s = State(c, new DateTime(1948, 6, 1)); s.Food = start; var why = new List<Cause>();
EventSystem.Trigger(c, s, why);
Assert.Null(EventSystem.Choose(c, s, "shortage", "import", why));
Assert.Equal(expected, s.Food);
Assert.Contains(why, w => w.Target == "food" && w.Delta == expected - start);
}
/// <summary>R-EFX-001: beyond the int range the loader refuses the delta, naming file and field (an out-of-range
/// double-to-int cast is not the same on every runtime, docs/determinism.md).</summary>
[Fact]
public void AFoodDeltaBeyondTheIntRangeIsALoadError()
{
var ev = Shortage.Replace("target: fx_reserves\n delta: -10", "target: food\n delta: 3000000000");
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = ev }));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal("events[shortage].options[import].effects.food", ex.Field);
Assert.Contains("food delta out of range", ex.Message);
}
[Fact]
public void AFoodCutStopsAtAnEmptyStock()
{
var ev = Shortage.Replace("target: fx_reserves\n delta: -10", "target: food\n delta: -10");
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = ev });
var s = State(c, new DateTime(1948, 6, 1)); s.Food = 3; var why = new List<Cause>();
EventSystem.Trigger(c, s, why);
Assert.Null(EventSystem.Choose(c, s, "shortage", "import", why));
Assert.Equal(0, s.Food);
Assert.Contains(why, w => w.Target == "food" && w.Delta == -3);
}
/// <summary>R-EFX-001: an `arms` effect moves the national Arms stock (#781) as `food` moves Food: whole units,
/// rounding half away from zero, the stock in 0..int.MaxValue, and the cause carries the change that applied.</summary>
[Theory]
[InlineData("7", 0, 7)]
[InlineData("2.5", 100, 103)]
[InlineData("-2.5", 100, 97)]
[InlineData("-10", 3, 0)]
[InlineData("2147483647", 100, 2147483647)]
public void AnOptionCanMoveTheArmsStock(string delta, int start, int expected)
{
var ev = Shortage.Replace("target: fx_reserves\n delta: -10", "target: arms\n delta: " + delta);
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = ev });
var s = State(c, new DateTime(1948, 6, 1)); s.Arms = start; var why = new List<Cause>();
EventSystem.Trigger(c, s, why);
Assert.Null(EventSystem.Choose(c, s, "shortage", "import", why));
Assert.Equal(expected, s.Arms);
Assert.Contains(why, w => w.Target == "arms" && w.Delta == expected - start);
}
/// <summary>R-EFX-001: the event card's preview (R-EVT-005) names an Arms effect in whole units.</summary>
[Fact]
public void ThePreviewShowsAnArmsEffectInUnits()
{
var ev = Shortage.Replace("target: fx_reserves\n delta: -10", "target: arms\n delta: -2");
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = ev });
var s = State(c, new DateTime(1948, 6, 1));
var o = c.Events.Single().Options.Single(x => x.Id == "import");
Assert.Contains(EventSystem.OptionEffects(c, s, o), l => l.Target == "arms" && l.Delta == -2 && l.Message == "Arms -2 units");
}
/// <summary>R-EFX-001: an Arms delta beyond the int range is a load error naming file and field, as for Food.</summary>
[Fact]
public void AnArmsDeltaBeyondTheIntRangeIsALoadError()
{
var ev = Shortage.Replace("target: fx_reserves\n delta: -10", "target: arms\n delta: -3000000000");
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = ev }));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal("events[shortage].options[import].effects.arms", ex.Field);
Assert.Contains("arms delta out of range", ex.Message);
}
/// <summary>R-EFX-001: any target that is not an indicator, `treasury`, `fx_reserves`, `food` or `arms` is a load error
/// naming file and field.</summary>
[Fact]
public void AnUnknownTargetNamesTheField()
{
var ev = Shortage.Replace("target: fx_reserves", "target: steel");
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = ev }));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal("events[shortage].options[import].effects.steel", ex.Field);
Assert.Contains("unknown target", ex.Message);
}
/// <summary>#2512: the schema requires an effect's delta; a missing one is a load error naming file and field, not a
/// change of 0.</summary>
[Fact]
public void AMissingDeltaIsALoadError()
{
var ev = Shortage.Replace("target: fx_reserves\n delta: -10", "target: fx_reserves");
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = ev }));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal("events[shortage].options[import].effects.fx_reserves.delta", ex.Field);
Assert.Contains("required", ex.Message);
}
[Fact]
public void EventIndicatorEffectPersistsThroughEffectsRebuilds()
{
var ev = Shortage.Replace("target: food_supply\n delta: 0.2", "target: food_supply\n delta: 0.1");
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = ev });
var s = State(c, new DateTime(1948, 6, 1)); var why = new List<Cause>();
EventSystem.Trigger(c, s, why);
Assert.Null(EventSystem.Choose(c, s, "shortage", "ration", why));
Assert.Equal(0.5, s.Indicators["food_supply"], 9); // visible immediately: base 0.4 + 0.1
for (int i = 0; i < 3; i++)
{
var turn = new List<Cause>();
EffectsSystem.Apply(c, s, turn);
Assert.Equal(0.5, s.Indicators["food_supply"], 9);
Assert.DoesNotContain(turn, w => w.System == "effects" && w.Target == "food_supply"); // no fake reversal
}
Assert.Equal(0.1, s.IndicatorShifts["food_supply"], 9);
}
const string Swing = @"
id: swing
title: Mood swing
text: Public mood shifts.
from: 1948-06-01
options:
- id: up
text: Up
effects:
- target: morale
delta: 0.3
- id: down
text: Down
effects:
- target: morale
delta: -0.2
- id: sink
text: Sink
effects:
- target: morale
delta: -0.5
- id: rise
text: Rise
effects:
- target: morale
delta: 0.1
sources: [{ url: https://example.org/event, checked: 2026-10-18 }]
";
/// <summary>Morale (base 0.5, no effect contributions) set to level via its shift, then each option chosen in turn.</summary>
static List<(double level, double causeDelta)> Swings(double level, params string[] options)
{
var c = Load(new Dictionary<string, string> { ["swing.yaml"] = Swing });
var s = State(c, new DateTime(1948, 6, 1));
s.IndicatorShifts["morale"] = level - 0.5; s.Indicators["morale"] = level;
var result = new List<(double, double)>();
foreach (var o in options)
{
s.PendingEvents.Add("swing"); var why = new List<Cause>();
Assert.Null(EventSystem.Choose(c, s, "swing", o, why));
result.Add((s.Indicators["morale"], why.Single(w => w.Target == "morale").Delta));
}
return result;
}
[Fact]
public void EventPastTheTopStoresOnlyTheEffectiveChange()
{
var r = Swings(0.95, "up", "down");
Assert.Equal(1.0, r[0].level, 9);
Assert.Equal(0.8, r[1].level, 9); // not stuck at 1.0
}
[Fact]
public void EventPastTheBottomStoresOnlyTheEffectiveChange()
{
var r = Swings(0.02, "sink", "rise");
Assert.Equal(0.0, r[0].level, 9);
Assert.Equal(0.1, r[1].level, 9);
}
[Fact]
public void EventCauseAmountIsTheActualChange()
{
var r = Swings(0.95, "up", "down");
Assert.Equal(0.05, r[0].causeDelta, 9);
Assert.Equal(-0.2, r[1].causeDelta, 9);
}
// Morale: base 0.5, effect rationing_morale k -0.2, inertia 1, no office, so Base + Σ = 0.5 - 0.2 * rationing.
static void SetInner(Content c, GameState s, double rationing) { s.Policies["rationing"] = rationing; EffectsSystem.Apply(c, s, new List<Cause>()); }
static double ChooseSwing(Content c, GameState s, string option)
{
s.PendingEvents.Add("swing"); var why = new List<Cause>();
Assert.Null(EventSystem.Choose(c, s, "swing", option, why));
return why.Single(w => w.Target == "morale").Delta;
}
[Fact]
public void EventBelowAnOverBoundEffectSumIsVisibleAndSurvivesEffectChanges()
{
var c = Load(new Dictionary<string, string> { ["swing.yaml"] = Swing });
var s = State(c, new DateTime(1948, 6, 1));
SetInner(c, s, -4.0); // Base + Σ = 1.3
Assert.Equal(1.0, s.Indicators["morale"], 9);
Assert.Equal(-0.2, ChooseSwing(c, s, "down"), 9); // cause = visible change
Assert.Equal(0.8, s.Indicators["morale"], 9); // visible immediately
SetInner(c, s, -4.0); // a rebuild with the same effects keeps it
Assert.Equal(0.8, s.Indicators["morale"], 9);
SetInner(c, s, -2.5); // Base + Σ = 1.0
Assert.Equal(0.8, s.Indicators["morale"], 9);
SetInner(c, s, -1.0); // Base + Σ = 0.7
Assert.Equal(0.5, s.Indicators["morale"], 9);
}
[Fact]
public void OvershootingEventLeavesOnlyTheVisibleShift()
{
var c = Load(new Dictionary<string, string> { ["swing.yaml"] = Swing });
var s = State(c, new DateTime(1948, 6, 1));
SetInner(c, s, -2.0); // inner 0.9
Assert.Equal(0.1, ChooseSwing(c, s, "up"), 9); // +0.3 only moves it to 1.0
Assert.Equal(1.0, s.Indicators["morale"], 9);
Assert.Equal(0.1, s.IndicatorShifts["morale"], 9);
Assert.Equal(-0.2, ChooseSwing(c, s, "down"), 9);
Assert.Equal(0.8, s.Indicators["morale"], 9);
}
[Fact]
public void EventWithNoVisibleChangeReportsZero()
{
var c = Load(new Dictionary<string, string> { ["swing.yaml"] = Swing });
var s = State(c, new DateTime(1948, 6, 1));
SetInner(c, s, -4.0); // inner 1.0 (Base + Σ = 1.3)
Assert.Equal(0.0, ChooseSwing(c, s, "rise"), 9); // already at 1.0
Assert.Equal(1.0, s.Indicators["morale"], 9);
}
[Fact]
public void UnknownOptionIsRejected()
{
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = Shortage });
var s = State(c, new DateTime(1948, 6, 1)); var why = new List<Cause>();
EventSystem.Trigger(c, s, why);
Assert.Equal("That event has no such option", EventSystem.Choose(c, s, "shortage", "nap", why));
}
[Fact]
public void DelegationIsDeterministicAndClearsPending()
{
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = Shortage });
GameState Run()
{
var s = State(c, new DateTime(1948, 6, 1)); var why = new List<Cause>();
EventSystem.Trigger(c, s, why); EventSystem.Delegate(c, s, why);
return s;
}
var a = Run(); var b = Run();
Assert.Empty(a.PendingEvents);
Assert.Equal(a.Hash(), b.Hash());
}
[Fact]
public void RenderFillsOfficeHolder()
{
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = Shortage });
Assert.Equal("Def Two reports shortages.", EventSystem.Render(c, c.Events[0], new DateTime(1948, 6, 1)));
}
[Fact]
public void SensitiveEventCannotRewardTreasury()
{
var bad = Sensitive("massacre", "treasury", "50");
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = bad }));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal("events[shortage].options[import].effects.treasury", ex.Field);
}
[Fact]
public void HardAnchorNeedsAHistoricalOption()
{
var bad = Shortage.Replace("office: finance_minister", "anchor: hard\noffice: finance_minister")
.Replace(" historical: true\n", "");
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = bad }));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal("events[shortage].options", ex.Field);
Assert.Contains("hard anchor needs a historical option", ex.Message);
}
[Fact]
public void HardAnchorWithAHistoricalOptionLoads()
{
var ok = Shortage.Replace("office: finance_minister", "anchor: hard\noffice: finance_minister");
Assert.Equal("hard", Load(new Dictionary<string, string> { ["shortage.yaml"] = ok }).Events.Single().Anchor);
}
[Fact]
public void PlaceholderMustBeAnOffice()
{
var bad = Shortage.Replace("{finance_minister}", "{king}");
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = bad }));
Assert.Equal("events[shortage].text", ex.Field);
}
// def_two takes defense only on 1949-02-01: nobody holds it in [1949-01-01, 1949-02-01).
static readonly string GapPeople = Fixture.Files["people.yaml"].Replace(
"office: defense_minister\n from: 1949-01-01", "office: defense_minister\n from: 1949-02-01");
static Content LoadWithGap(string ev) =>
ContentLoader.Load(Fixture.Write(new Dictionary<string, string> { ["people.yaml"] = GapPeople },
new Dictionary<string, string> { ["shortage.yaml"] = ev }));
[Fact]
public void PlaceholderOfficeWithoutHolderForPartOfWindowFailsToLoad()
{
var bad = Shortage.Replace("{finance_minister}", "{defense_minister}");
var ex = Assert.Throws<ContentException>(() => LoadWithGap(bad));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal("events[shortage].text", ex.Field);
Assert.Contains("defense_minister", ex.Message);
Assert.Contains("1949-01-01", ex.Message);
}
[Fact]
public void PlaceholderOfficeLeftByAHoldersDeathFailsToLoad()
{
// def_two's finance term is open-ended; a death inside the latest government (from 1949-03-10) loads, but
// the office is then vacant from the date of death on, inside the open event window.
var people = Fixture.Files["people.yaml"].Replace(" name: Def Two\n", " name: Def Two\n died: 1949-06-01\n");
var ex = Assert.Throws<ContentException>(() => ContentLoader.Load(Fixture.Write(new Dictionary<string, string> { ["people.yaml"] = people },
new Dictionary<string, string> { ["shortage.yaml"] = Shortage })));
Assert.Equal("events[shortage].text", ex.Field);
Assert.Contains("office 'finance_minister' has no holder on 1949-06-01", ex.Message);
}
[Fact]
public void PlaceholderUncoveredAtWindowStartNamesThatDate()
{
var bad = Shortage.Replace("text: Ration food", "text: '{defense_minister} rations food'")
.Replace("from: 1948-06-01", "from: 1949-01-15\nto: 1949-03-01");
var ex = Assert.Throws<ContentException>(() => LoadWithGap(bad));
Assert.Equal("events[shortage].options[ration].text", ex.Field);
Assert.Contains("1949-01-15", ex.Message);
}
// Window ends 1949-01-01; nobody holds defense from then until 1949-02-01.
static readonly string LateEvent = Shortage.Replace("text: Ration food", "text: '{defense_minister} rations food'")
.Replace("from: 1948-06-01", "from: 1948-06-01\nto: 1949-01-01");
[Fact]
public void ChoosingAfterWindowEndFillsAtLastInWindowDate()
{
var c = LoadWithGap(LateEvent);
var s = State(c, new DateTime(1948, 12, 1)); var why = new List<Cause>();
EventSystem.Trigger(c, s, why);
s.Date = new DateTime(1949, 1, 15); // still pending after To, office unheld today
Assert.Null(EventSystem.Choose(c, s, "shortage", "ration", why));
Assert.Contains(why, w => w.Message == "Chosen: Pm One rations food");
}
[Fact]
public void DelegatingAfterWindowEndFillsAtLastInWindowDate()
{
var c = LoadWithGap(LateEvent);
c.People.First(p => p.Id == "def_two").Competence = 10; // always the recommended option (ration)
var s = State(c, new DateTime(1948, 12, 1)); var why = new List<Cause>();
EventSystem.Trigger(c, s, why);
s.Date = new DateTime(1949, 1, 1); // exactly To
EventSystem.Delegate(c, s, why);
Assert.Contains(why, w => w.Message.StartsWith("Delegated") && w.Message.EndsWith("Pm One rations food"));
}
[Fact]
public void PlaceholderFullyCoveredWindowLoads()
{
var ok = Shortage.Replace("{finance_minister}", "{defense_minister}")
.Replace("from: 1948-06-01", "from: 1948-06-01\nto: 1949-01-01"); // window ends where the gap starts
Assert.Single(LoadWithGap(ok).Events);
}
[Fact]
public void PlaceholderCoveredAcrossAHandoverLoads()
{
// Fixture: pm_one holds defense until 1949-01-01, def_two from then on (open-ended).
var ok = Shortage.Replace("{finance_minister}", "{defense_minister}");
Assert.Single(LoadWithStanding(ok).Events);
}
[Theory]
[InlineData("'{Finance} reports shortages.'", "text: Ration food", "events[shortage].text")]
[InlineData("'{finance_minister} reports { shortages.'", "text: Ration food", "events[shortage].text")]
[InlineData("'{finance_minister} reports shortages.'", "text: 'Ration } food'", "events[shortage].options[ration].text")]
public void StrayBracesAreRejected(string text, string optionText, string field)
{
var bad = Shortage.Replace("'{finance_minister} reports shortages.'", text).Replace("text: Ration food", optionText);
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = bad }));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal(field, ex.Field);
}
[Fact]
public void StrayBraceInTitleIsRejected()
{
var bad = Shortage.Replace("title: Bread lines", "title: 'Bread {lines'");
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = bad }));
Assert.Equal("events[shortage].title", ex.Field);
}
[Fact]
public void EffectTargetMustExist()
{
var bad = Shortage.Replace("target: food_supply", "target: bread");
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = bad }));
Assert.Equal("events[shortage].options[ration].effects.bread", ex.Field);
}
[Fact]
public void DuplicateEventIdIsAnError()
{
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["a.yaml"] = Shortage, ["b.yaml"] = Shortage }));
Assert.Equal("events/b.yaml", ex.File);
Assert.Equal("events[shortage].id", ex.Field);
}
/// <summary>The shortage event with a sensitive tag, its import option's effect replaced by <paramref name="target"/> and
/// <paramref name="delta"/>. Its ration option's food gain becomes a cost, since a sensitive option may not raise food.</summary>
static string Sensitive(string tag, string target, string delta) =>
Shortage.Replace("title: Bread lines", "title: Bread lines\ntags: [" + tag + "]")
.Replace("target: food_supply\n delta: 0.2", "target: food_supply\n delta: -0.2")
.Replace("target: fx_reserves\n delta: -10", "target: " + target + "\n delta: " + delta);
[Theory]
[InlineData("Massacre")]
[InlineData("War-Casualties")]
[InlineData("HOLOCAUST")]
[InlineData("Terror")]
public void SensitiveTagMatchingIgnoresCase(string tag)
{
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = Sensitive(tag, "treasury", "50") }));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal("events[shortage].options[import].effects.treasury", ex.Field);
}
[Fact]
public void SensitiveEventCannotRewardFxReserves()
{
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = Sensitive("terror", "fx_reserves", "50") }));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal("events[shortage].options[import].effects.fx_reserves", ex.Field);
}
[Theory]
[InlineData("treasury", "0")]
[InlineData("treasury", "-20")]
[InlineData("fx_reserves", "0")]
[InlineData("fx_reserves", "-20")]
public void SensitiveEventMayCostOrNotChangeMoney(string target, string delta)
{
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = Sensitive("massacre", target, delta) });
Assert.Single(c.Events);
}
/// <summary>The fixture with an intl_standing indicator, as the real model has.</summary>
static Content LoadWithStanding(string ev) =>
ContentLoader.Load(Fixture.Write(new Dictionary<string, string>
{
["model.yaml"] = Fixture.Files["model.yaml"].Replace("indicators:\n", "indicators:\n - id: intl_standing\n base: 0.5\n name: International standing\n"),
}, new Dictionary<string, string> { ["shortage.yaml"] = ev }));
/// <summary>R-EFX-002 (owner decision of 15 October 2026 on Q-EFX-2, "Extend it"): a sensitive option may not raise any
/// resource. The legacy indicators stand for Food (food_supply), Social cohesion (morale) and International Support
/// (intl_standing); `food` is Food's own target, and `arms` the Arms stock's (#781).</summary>
[Theory]
[InlineData("food_supply")]
[InlineData("morale")]
[InlineData("intl_standing")]
[InlineData("food")]
[InlineData("arms")]
public void SensitiveEventCannotRaiseFoodCohesionOrSupport(string target)
{
var ex = Assert.Throws<ContentException>(() => LoadWithStanding(Sensitive("war-casualties", target, "0.02")));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal($"events[shortage].options[import].effects.{target}", ex.Field);
Assert.Contains("sensitive events cannot reward", ex.Message);
}
[Theory]
[InlineData("food_supply", "0")]
[InlineData("morale", "-0.02")]
[InlineData("food", "0")]
[InlineData("food", "-5")]
[InlineData("arms", "0")]
[InlineData("arms", "-5")]
[InlineData("intl_standing", "-0.05")]
public void SensitiveEventMayCostOrNotChangeFoodCohesionOrSupport(string target, string delta)
{
Assert.Single(LoadWithStanding(Sensitive("terror", target, delta)).Events);
}
/// <summary>R-EFX-007 (Q-DEP-6(a)): a displacement option cannot raise any available resource target, Arms included
/// (#781). Score is kept as an explicit boundary: it is not an event-effect target yet, so the loader refuses it as
/// unknown.</summary>
[Theory]
[InlineData("treasury", "sensitive events cannot reward")]
[InlineData("fx_reserves", "sensitive events cannot reward")]
[InlineData("food", "sensitive events cannot reward")]
[InlineData("food_supply", "sensitive events cannot reward")]
[InlineData("morale", "sensitive events cannot reward")]
[InlineData("intl_standing", "sensitive events cannot reward")]
[InlineData("arms", "sensitive events cannot reward")]
[InlineData("score", "unknown target")]
public void ADisplacementOptionCannotRaiseAnything(string target, string reason)
{
var ex = Assert.Throws<ContentException>(() => LoadWithStanding(Sensitive("displacement", target, "0.02")));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal($"events[shortage].options[import].effects.{target}", ex.Field);
Assert.Contains(reason, ex.Message);
}
/// <summary>A non-sensitive event may still raise them.</summary>
[Fact]
public void AnUntaggedEventMayRaiseCohesionAndSupport()
{
var ok = Shortage.Replace("target: fx_reserves\n delta: -10", "target: intl_standing\n delta: 0.05");
Assert.Single(LoadWithStanding(ok).Events);
}
[Fact]
public void DuplicateOptionIdIsAnError()
{
var bad = Shortage.Replace("id: import", "id: ration");
var ex = Assert.Throws<ContentException>(() => Load(new Dictionary<string, string> { ["shortage.yaml"] = bad }));
Assert.Equal("events/shortage.yaml", ex.File);
Assert.Equal("events[shortage].options[ration].id", ex.Field);
}
static string DelegatedText(Content c, int competence, ulong seed)
{
c.People.First(p => p.Id == "def_two").Competence = competence;
var s = State(c, new DateTime(1948, 6, 1)); s.RngState = seed; var why = new List<Cause>();
EventSystem.Trigger(c, s, why); why.Clear();
EventSystem.Delegate(c, s, why);
return why.First(w => w.Message.StartsWith("Delegated")).Message;
}
[Fact]
public void MaximalCompetenceAlwaysPicksRecommendedOption()
{
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = Shortage });
for (ulong seed = 1; seed <= 30; seed++)
Assert.EndsWith("Ration food", DelegatedText(c, 10, seed));
}
[Fact]
public void MinimalCompetenceDelegateCanPickOtherOptions()
{
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = Shortage });
var picks = new HashSet<string>();
for (ulong seed = 1; seed <= 60; seed++) picks.Add(DelegatedText(c, 0, seed));
Assert.True(picks.Count > 1, "competence 0 should choose at random among options");
}
static string Simple(string id, string anchor, string from, string? to = null) =>
$"id: {id}\ntitle: '{id} for {{defense_minister}}'\ntext: Something happens.\nanchor: {anchor}\nfrom: {from}\n" +
(to == null ? "" : $"to: {to}\n") +
"options:\n - id: ok\n text: Accept\n historical: true\nsources: [{ url: \"https://example.org/event\", checked: 2026-10-18 }]\n";
[Fact]
public void ShortWindowInsideAQuarterTurnStillFires()
{
// start_rung 1 gives quarter turns: 1948-05-15 -> 1948-08-15. The window 1948-06-01..06-11 lies wholly inside it.
var c = ContentLoader.Load(Fixture.Write(
new Dictionary<string, string> { ["rules.yaml"] = Fixture.Files["rules.yaml"].Replace("start_rung: 5", "start_rung: 1") },
new Dictionary<string, string> { ["brief.yaml"] = Simple("brief", "soft", "1948-06-01", "1948-06-11") }));
var s = Simulation.NewGame(c, 1, Mode.Historical);
Assert.Empty(s.PendingEvents);
var r = Simulation.Step(c, s, new List<Command>());
Assert.Equal(new DateTime(1948, 8, 15), r.State.Date);
Assert.Equal(new[] { "brief" }, r.State.PendingEvents);
Assert.Contains(r.Why, w => w.Message == "New: brief for Pm One");
}
[Fact]
public void WindowThatEndedBeforeTheTurnDoesNotFire()
{
var c = ContentLoader.Load(Fixture.Write(
new Dictionary<string, string> { ["rules.yaml"] = Fixture.Files["rules.yaml"].Replace("start_rung: 5", "start_rung: 1") },
new Dictionary<string, string> { ["old.yaml"] = Simple("old", "soft", "1948-05-14", "1948-05-15") }));
var s = Simulation.NewGame(c, 1, Mode.Historical);
Assert.Empty(Simulation.Step(c, s, new List<Command>()).State.PendingEvents);
}
[Fact]
public void HardAnchorIsNeverLostToTheCap()
{
var c = ContentLoader.Load(Fixture.Write(events: new Dictionary<string, string>
{
["a.yaml"] = Simple("a", "soft", "1948-05-15"),
["b.yaml"] = Simple("b", "soft", "1948-05-15"),
["c.yaml"] = Simple("c", "soft", "1948-05-15"),
["z.yaml"] = Simple("z", "hard", "1948-05-15"),
}));
var s = Simulation.NewGame(c, 1, Mode.Historical);
Assert.Equal(new[] { "a", "b", "z" }, s.PendingEvents); // hard first for the cap, then the usual order
}
[Fact]
public void AllHardAnchorsFireEvenBeyondTheCap()
{
var c = ContentLoader.Load(Fixture.Write(events: new Dictionary<string, string>
{
["a.yaml"] = Simple("a", "soft", "1948-05-15"),
["h1.yaml"] = Simple("h1", "hard", "1948-05-15"),
["h2.yaml"] = Simple("h2", "hard", "1948-05-15"),
["h3.yaml"] = Simple("h3", "hard", "1948-05-15"),
["h4.yaml"] = Simple("h4", "hard", "1948-05-15"),
}));
var s = Simulation.NewGame(c, 1, Mode.Historical);
Assert.Equal(new[] { "h1", "h2", "h3", "h4" }, s.PendingEvents); // the soft one finds no slot left
}
[Fact]
public void TinyNegativeEffectNeverRendersAsMinusPlusZero()
{
var ev = Shortage.Replace("delta: -10", "delta: -0.0001");
var c = Load(new Dictionary<string, string> { ["shortage.yaml"] = ev });
var s = State(c, new DateTime(1948, 6, 1)); var why = new List<Cause>();
EventSystem.Trigger(c, s, why);
Assert.Null(EventSystem.Choose(c, s, "shortage", "import", why));
Assert.Contains(why, w => w.Message == "Foreign currency $0.0m (Bread lines)");
Assert.DoesNotContain(why, w => w.Message.Contains("-+"));
}
[Fact]
public void EventFiredAfterItsWindowNamesTheInWindowHolder()
{
// Quarter turns: 1948-11-15 -> 1949-02-15. defense_minister passes from Pm One to Def Two on 1949-01-01.
var c = ContentLoader.Load(Fixture.Write(
new Dictionary<string, string> { ["rules.yaml"] = Fixture.Files["rules.yaml"].Replace("start_rung: 5", "start_rung: 1") },
new Dictionary<string, string> { ["late.yaml"] = Simple("late", "soft", "1948-12-20", "1948-12-30") }));
var s = Simulation.NewGame(c, 1, Mode.Historical);
StepResult r = null!;
for (int i = 0; i < 3; i++) { r = Simulation.Step(c, s, new List<Command>()); s = r.State; }
Assert.Equal(new DateTime(1949, 2, 15), s.Date);
Assert.Contains(r.Why, w => w.Message == "New: late for Pm One");
}
// R-SWAMP-002, Phase 2 Q-CUT-4's rule: hula_drainage gained only a condition (site: hula), not new text or options, so
// its review status and the release gate's verdict on it are unchanged.
[Fact]
public void TheHulaConditionLeavesItsReleaseStatus()
{
var c = ContentLoader.Load(RealContentTests.ContentRoot());
var e = c.Events.Single(x => x.Id == "hula_drainage");
Assert.Equal(("hula", "fact-checked"), (e.Site, e.Status));
Assert.DoesNotContain("hula_drainage", ReleaseGate.SensitiveEvents(c));
Assert.DoesNotContain("hula_drainage", ReleaseGate.SensitiveUnreviewed(c));
}
}