Plan: run the in-engine suites on CI without the extraction

.github/workflows/checks.yml

@@ -1,7 +1,9 @@
-# The checks a contributor can pass without the original game: the repo's content gate, dotnet
-# format, StyleCop, and the unit tests (tests needing extracted game data skip themselves). The
-# engine suites and goldens need Godot and an install, so they stay with RunTests.ps1 locally.
-# Three OSes, because the scripts must work wherever a contributor runs them.
+# The checks a contributor can pass without the original game. The checks job runs the repo's
+# content gate, dotnet format, StyleCop, and the unit tests (tests needing extracted game data skip
+# themselves) on three OSes, because the scripts must work wherever a contributor runs them. The
+# engine job runs the in-engine suites on the ci tier headless on Linux with no extraction, through
+# RunCiSuites.ps1; a listed suite that fails or skips turns it red. The rest of the engine catalog,
+# the goldens and the hitch check need an install or a renderer, so they stay with RunTests.ps1.
 name: Checks
 
 on:
@@ -75,3 +77,95 @@ jobs:
 
       - name: Unit tests
         run: dotnet test CSVM/CSVM.sln --nologo
+
+  engine:
+    name: engine suites (tier:ci, headless)
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    defaults:
+      run:
+        shell: pwsh
+    env:
+      GODOT_RELEASE: 4.7-stable
+      GODOT_BUILD: Godot_v4.7-stable_mono_linux_x86_64
+      GODOT_EXE: Godot_v4.7-stable_mono_linux.x86_64
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 8.0.x
+
+      # Keyed on the release, so a version bump downloads and verifies afresh. A cached copy was
+      # verified against the release's SHA512-SUMS.txt before it was stored.
+      - name: Cache Godot
+        id: godot-cache
+        uses: actions/cache@v4
+        with:
+          path: ~/godot
+          key: godot-${{ env.GODOT_BUILD }}
+
+      - name: Download and verify Godot
+        if: steps.godot-cache.outputs.cache-hit != 'true'
+        run: |
+          $base = "https://github.com/godotengine/godot/releases/download/$env:GODOT_RELEASE"
+          $zip = "$env:GODOT_BUILD.zip"
+          $dir = Join-Path $HOME 'godot'
+          New-Item -ItemType Directory -Force $dir | Out-Null
+          Set-Location $dir
+          curl -fsSL --retry 3 -o $zip "$base/$zip"
+          if ($LASTEXITCODE) { exit $LASTEXITCODE }
+          curl -fsSL --retry 3 -o SHA512-SUMS.txt "$base/SHA512-SUMS.txt"
+          if ($LASTEXITCODE) { exit $LASTEXITCODE }
+          $rows = @(Get-Content SHA512-SUMS.txt | Where-Object { ($_ -split '\s+')[-1].TrimStart('*') -eq $zip })
+          if ($rows.Count -ne 1) { throw "SHA512-SUMS.txt lists $zip $($rows.Count) times, not once" }
+          $want = ($rows[0] -split '\s+')[0].ToLowerInvariant()
+          $got = (Get-FileHash -Algorithm SHA512 $zip).Hash.ToLowerInvariant()
+          if ($got -ne $want) { throw "$zip has SHA-512 $got; the release publishes $want" }
+          Write-Host "$zip matches the SHA-512 the release publishes"
+          # unzip, not Expand-Archive, which drops the executable bit.
+          unzip -q $zip
+          if ($LASTEXITCODE) { exit $LASTEXITCODE }
+          chmod +x "$env:GODOT_BUILD/$env:GODOT_EXE"
+          Remove-Item $zip, SHA512-SUMS.txt
+
+      - name: Locate Godot
+        run: |
+          $godot = Join-Path $HOME "godot/$env:GODOT_BUILD/$env:GODOT_EXE"
+          if (-not (Test-Path $godot)) { throw "No Godot executable at $godot" }
+          "GODOT=$godot" | Out-File -FilePath $env:GITHUB_ENV -Append -Encoding utf8
+
+      # Without fontconfig Godot's Linux build logs an engine error on every font lookup, and
+      # RunCiSuites.ps1 refuses to start. Installed only when the runner image lacks it.
+      - name: fontconfig
+        run: |
+          if (-not (@(/sbin/ldconfig -p) | Where-Object { $_ -match 'libfontconfig\.so\.1' })) {
+            sudo apt-get update
+            sudo apt-get install -y libfontconfig1
+          }
+
+      - name: Build
+        run: dotnet build CSVM/CSVM.sln --nologo
+
+      - name: Import
+        run: |
+          & $env:GODOT --headless --path CSVM --import
+          if ($LASTEXITCODE) { exit $LASTEXITCODE }
+
+      - name: Engine suites
+        run: ./RunCiSuites.ps1 -Godot $env:GODOT
+
+      - name: Upload report and logs
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: engine-suites
+          # .scratch is a hidden folder, which upload-artifact skips unless told otherwise.
+          include-hidden-files: true
+          if-no-files-found: warn
+          path: |
+            .scratch/test-report.json
+            .scratch/ci-suites/godot.out
+            .scratch/ci-suites/godot.err
+            .scratch/ci-suites/godot.log
+            .scratch/logs/

CSVM.Tests/LoadoutTests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using System.Linq;
 using CSVM.Flight.Weapons;
 using Xunit;
 
@@ -13,6 +14,11 @@ namespace CSVM.Tests;
 [Trait("Tier", "Quick")]
 public class LoadoutTests
 {
+    // Every firepoint and pylon the rig can carry, the shape the lab loadout covers.
+    private static readonly string[] FullRig = Enumerable.Range(1, 8)
+        .SelectMany(i => new[] { $"firepoint{i}", $"pylon{i}" })
+        .ToArray();
+
     private static string ConfigPath =>
         Path.Combine(TestData.RepoRoot, "CSVM", "data", "stock_loadouts.json");
 
@@ -205,6 +211,43 @@ public void ArmedIsTheOneSpellingAndHonoursInfiniteAmmo()
         Assert.True(pylon.Armed(infinite: false));
     }
 
+    [Fact]
+    public void TheRigLoadoutKeepsAWeaponTheStockFitNames()
+    {
+        // A named weapon sits outside the caliber matrix; rebuilding the slot from Caliber and Ammo
+        // alone binds a matrix weapon in its place. A slot stock leaves out takes the first gun's.
+        var stock = new LoadoutDef { Def = "rig_probe" };
+        stock.Guns.Add(new GunSpec { Slot = 1, Caliber = 30, Ammo = "slug", WeaponId = "wep_named" });
+        stock.Guns.Add(new GunSpec { Slot = 2, Caliber = 50, Ammo = "ap" });
+
+        var rig = Loadout.RigDef(FullRig, stock);
+
+        Assert.Equal(new[] { 1, 2, 3, 4 }, rig.Guns.Select(g => g.Slot));
+        Assert.Equal("wep_named", rig.Guns[0].WeaponId);
+        Assert.Null(rig.Guns[1].WeaponId);
+        Assert.Equal((50, "ap"), (rig.Guns[1].Caliber, rig.Guns[1].Ammo));
+        Assert.Equal("wep_named", rig.Guns[2].WeaponId);
+        Assert.Equal(new[] { "firepoint7", "firepoint8" }, rig.Guns[0].Markers);
+    }
+
+    [Fact]
+    public void EveryShippedFitsRigLoadoutStillComposesItsWeaponFromCaliberAndAmmo()
+    {
+        // No shipped fit names a weapon. Every rig slot therefore carries none, and Bind composes
+        // the matrix id from Caliber and Ammo.
+        foreach (var (def, loadout) in Load().All)
+        {
+            var rig = Loadout.RigDef(FullRig, loadout);
+            Assert.Equal(4, rig.Guns.Count);
+            foreach (var gun in rig.Guns)
+            {
+                var stockGun = loadout.Guns.FirstOrDefault(g => g.Slot == gun.Slot) ?? loadout.Guns[0];
+                Assert.True(gun.WeaponId == null, $"{def} slot {gun.Slot}: {gun.WeaponId}");
+                Assert.Equal((stockGun.Caliber, stockGun.Ammo), (gun.Caliber, gun.Ammo));
+            }
+        }
+    }
+
     private static StockLoadouts Load() => StockLoadouts.Load(ConfigPath);
 
     // A fit of N pylons, every one carrying the stock high explosive the hangar writes.

CSVM.Tests/NameResolverTests.cs

@@ -328,6 +328,56 @@ public void AWildcardInstancedDefsMissedNameReachesNoOtherNode()
         Assert.Equal(1, resolver.GlobalTierRefused);
     }
 
+    [Fact]
+    public void APeekResolvesLikeTheDispatchAndTalliesNothing()
+    {
+        // A read-only query asks the same tiers: the anchor's own node, the world answering an
+        // exact def, and the refusal a shared def's instance meets. Only the dispatch's form counts.
+        var crate01 = Node("crate01");
+        var crateHealthy = Node("healthy");
+        var crate02 = Node("crate02");
+        var stray = Node("door1");
+        var resolver = Build(
+            (crate01, "crate01", null),
+            (crateHealthy, "healthy", crate01),
+            (crate02, "crate02", null),
+            (stray, "door1", null));
+        var shared = Def("crate**", rootName: "healthy");
+        var healthy = new List<string> { "healthy" };
+        var door = new List<string> { "door1" };
+
+        Assert.Equal(new[] { crateHealthy }, resolver.PeekScoped(healthy, shared, crate01));
+        Assert.Empty(resolver.PeekScoped(healthy, shared, crate02));
+        Assert.Equal(new[] { stray }, resolver.PeekScoped(door, Def("crate01"), crate01));
+        Assert.Equal(0, resolver.GlobalTierRefused);
+        Assert.Equal(resolver.PeekScoped(healthy, shared, crate02), resolver.ResolveScoped(healthy, shared, crate02));
+        Assert.Equal(1, resolver.GlobalTierRefused);
+    }
+
+    [Fact]
+    public void APeekClaimsNothingAndLeavesTheLaterClaimOwed()
+    {
+        // A peek that memoized its answer unclaimed would hand the real query a memo hit, and the
+        // node would never be claimed. So the peek writes no memo, and the real query claims as usual.
+        var boat = Node("boat1");
+        var anchor = Node("harbour");
+        var resolver = Build((anchor, "harbour", null), (boat, "boat1", anchor));
+        var claimed = new List<TestNode>();
+        resolver.Claimed = claimed.Add;
+        var def = Def("harbour");
+        var path = new List<string> { "boat1" };
+
+        Assert.Equal(new TestNode?[] { anchor }, resolver.PeekAnchors(def));
+        Assert.Equal(new[] { boat }, resolver.PeekScoped(path, def, anchor));
+        Assert.Equal(new[] { boat }, resolver.Peek(() => resolver.FindAll("boat1", null)));
+        Assert.Empty(claimed);
+
+        Assert.Equal(new[] { boat }, resolver.ResolveScoped(path, def, anchor));
+        Assert.Equal(new[] { boat }, claimed);
+        Assert.Equal(new TestNode?[] { anchor }, resolver.Anchors(def));
+        Assert.Contains(anchor, claimed);
+    }
+
     [Fact]
     public void AnExactlyNamedDefStillFallsThroughToTheGlobalTier()
     {

CSVM.Tests/OceanBaseTextureTests.cs

@@ -0,0 +1,33 @@
+using CSVM.Mech3;
+using Xunit;
+
+namespace CSVM.Tests;
+
+/// <summary>
+/// Which water textures are the open-sea base sheet the Enhanced wave ocean replaces
+/// (<see cref="SceneBuilder.IsOceanBaseTexture"/>). C1 and C1C paint their sea with
+/// <c>water1</c>, and C1's opaque coast tiles <c>water1_trans1/2</c> sit beside it and must stay.
+/// </summary>
+public class OceanBaseTextureTests
+{
+    [Theory]
+    [InlineData("wtr00000.tif")]
+    [InlineData("WTR00000.TIF")]
+    [InlineData("wtr00000")]
+    [InlineData("water1.tif")]
+    [InlineData("water1")]
+    [InlineData("Water1.tif")]
+    public void TheBaseSheetIsMatched(string texture) => Assert.True(SceneBuilder.IsOceanBaseTexture(texture));
+
+    [Theory]
+    [InlineData("water1_trans1.tif")]
+    [InlineData("water1_trans2.tif")]
+    [InlineData("water10.tif")]
+    [InlineData("water2.tif")]
+    [InlineData("srf0001.tif")]
+    [InlineData("wakefront1.tif")]
+    [InlineData("z3_foggrad.tif")]
+    [InlineData("beach1.tif")]
+    [InlineData("")]
+    public void CoastTilesSurfAndOverlaysAreNot(string texture) => Assert.False(SceneBuilder.IsOceanBaseTexture(texture));
+}

CSVM.Tests/OceanCalmZoneTests.cs

@@ -0,0 +1,91 @@
+using CSVM.Effects;
+using Godot;
+using Xunit;
+
+namespace CSVM.Tests;
+
+/// <summary>
+/// The ship calm zone the wave ocean flattens its waves in (<see cref="OceanCalmZone"/>). It is a
+/// box along the hull's heading, grown over the waterline and the wake sheets' footprints. The
+/// shader's smoothstep fades the waves back in past it.
+/// </summary>
+public class OceanCalmZoneTests
+{
+    private const float Eps = 1e-3f;
+
+    [Fact]
+    public void AnEmptyZoneIsADiscAtItsOrigin()
+    {
+        var zone = new OceanCalmZone(new Vector2(100f, -40f), new Vector2(0f, 1f));
+        Assert.True(zone.IsEmpty);
+        Assert.Equal(Vector2.Zero, zone.HalfExtents);
+        Assert.Equal(5f, zone.Distance(new Vector2(103f, -36f)), Eps);
+    }
+
+    [Fact]
+    public void TheBoxRunsAlongTheHeading()
+    {
+        var zone = new OceanCalmZone(Vector2.Zero, new Vector2(0f, 3f));
+        zone.Add(new Vector2(-10f, -100f));
+        zone.Add(new Vector2(10f, 50f));
+        Assert.Equal(new Vector2(0f, 1f), zone.Axis);
+        Assert.Equal(75f, zone.HalfExtents.X, Eps);
+        Assert.Equal(10f, zone.HalfExtents.Y, Eps);
+        Assert.Equal(0f, zone.Center.X, Eps);
+        Assert.Equal(-25f, zone.Center.Y, Eps);
+        Assert.Equal(0f, zone.Distance(new Vector2(9f, -99f)), Eps);
+        Assert.Equal(5f, zone.Distance(new Vector2(0f, 55f)), Eps);
+        Assert.Equal(5f, zone.Distance(new Vector2(-15f, 0f)), Eps);
+        // Past a corner the distance is to the corner, which rounds the zone's ends.
+        Assert.Equal(5f, zone.Distance(new Vector2(13f, 54f)), Eps);
+    }
+
+    [Fact]
+    public void AMeshFootprintTurnsWithItsShip()
+    {
+        // A sheet 10 m wide and 100 m long, on a ship turned 30 degrees and moved off the origin.
+        var basis = new Basis(Vector3.Up, Mathf.DegToRad(30f));
+        var ship = new Transform3D(basis, new Vector3(-5000f, 0f, -10000f));
+        var sheet = new Aabb(new Vector3(-5f, 0.1f, -50f), new Vector3(10f, 9f, 100f));
+        var heading = new Vector2(basis.Z.X, basis.Z.Z);
+        var zone = new OceanCalmZone(new Vector2(ship.Origin.X, ship.Origin.Z), heading);
+        zone.Add(sheet, ship);
+        Assert.Equal(50f, zone.HalfExtents.X, Eps);
+        Assert.Equal(5f, zone.HalfExtents.Y, Eps);
+        Assert.Equal(-5000f, zone.Center.X, 0.01f);
+        Assert.Equal(-10000f, zone.Center.Y, 0.01f);
+        var bow = new Vector2(ship.Origin.X, ship.Origin.Z) + (heading.Normalized() * 60f);
+        Assert.Equal(10f, zone.Distance(bow), 0.01f);
+    }
+
+    [Fact]
+    public void AWakeBehindTheHullStretchesTheZoneOverBoth()
+    {
+        // The hull's waterline from -60 to 60 m along its heading, a wake sheet trailing it to -200.
+        var ship = new Transform3D(Basis.Identity, new Vector3(0f, 0f, 0f));
+        var zone = new OceanCalmZone(Vector2.Zero, new Vector2(0f, 1f));
+        zone.Add(new Aabb(new Vector3(-10f, -5f, -60f), new Vector3(20f, 10f, 120f)), ship);
+        zone.Add(new Aabb(new Vector3(-25f, 0.2f, -200f), new Vector3(50f, 0.1f, 140f)), ship);
+        Assert.Equal(130f, zone.HalfExtents.X, Eps);
+        Assert.Equal(25f, zone.HalfExtents.Y, Eps);
+        Assert.Equal(-70f, zone.Center.Y, Eps);
+        Assert.Equal(0f, zone.Distance(new Vector2(24f, -199f)), Eps);
+    }
+
+    [Fact]
+    public void AHeadingWithNoLengthFallsBackToX()
+    {
+        var zone = new OceanCalmZone(Vector2.Zero, Vector2.Zero);
+        Assert.Equal(new Vector2(1f, 0f), zone.Axis);
+    }
+
+    [Theory]
+    [InlineData(0f, 0f)]
+    [InlineData(6f, 0f)]
+    [InlineData(31f, 0.5f)]
+    [InlineData(56f, 1f)]
+    [InlineData(500f, 1f)]
+    [InlineData(18.5f, 0.15625f)]
+    public void TheFadeIsTheShadersSmoothstep(float distance, float expected) =>
+        Assert.Equal(expected, OceanCalmZone.Calm(distance, 6f, 50f), Eps);
+}