Refactor simulation effects and forecast hazards

tests/ReactorMaintenance.Simulation.Tests/SimulationEngineTests.cs

@@ -17,7 +17,7 @@ public sealed class SimulationEngineTests
 
         var forecasts = m_Engine.Forecast(level);
 
-        Assert.Contains(forecasts, forecast => forecast.Kind == EFailureKind.Ignition && forecast.Position == new GridPosition(2, 2));
+        Assert.Contains(forecasts, forecast => forecast.Kind == EFailureKind.Ignition && forecast.Position == new GridPosition(2, 2) && forecast.Turns == 1);
     }
 
     [Fact]
@@ -35,6 +35,22 @@ public sealed class SimulationEngineTests
         Assert.True(next.GetCell(new(3, 3)).Hazards.ElectricalCharge >= 2);
     }
 
+    [Fact]
+    public void ActiveFireSpreadsSmokeToOpenNeighbors()
+    {
+        var level = LevelState.Create("Smoke", 6, 6)
+                              .SetCell(new(2, 2), new() {
+                                  Hazards = new() {
+                                      Fire = true,
+                                      Smoke = 6
+                                  }
+                              });
+
+        var next = m_Engine.AdvanceTurn(level);
+
+        Assert.True(next.GetCell(new(2, 3)).Hazards.Smoke > 0);
+    }
+
     [Fact]
     public void OverpressurePredictsPipeBurst()
     {
@@ -50,6 +66,64 @@ public sealed class SimulationEngineTests
         Assert.Contains(forecasts, forecast => forecast.Kind == EFailureKind.PipeBurst && forecast.Turns == 2);
     }
 
+    [Fact]
+    public void ForecastCapsFutureSimulationWhenNoTerminalConditionOccurs()
+    {
+        var engine = new SimulationEngine([], [], [new StepCountingHazard()]);
+        var level = LevelState.Create("Stable", 6, 6);
+
+        var forecasts = engine.Forecast(level);
+
+        Assert.Equal(12, forecasts.Count);
+        Assert.Equal(12, forecasts.Max(forecast => forecast.Turns));
+    }
+
+    [Fact]
+    public void ForecastPredictsMeltdownFromFutureSimulation()
+    {
+        var level = LevelState.Create("Meltdown", 6, 6)
+                              .SetCell(new(2, 2), new() {
+                                  Kind = ECellKind.Reactor,
+                                  Hazards = new() { Heat = 9 }
+                              });
+
+        var forecasts = m_Engine.Forecast(level);
+
+        Assert.Contains(forecasts, forecast => forecast.Kind == EFailureKind.Meltdown && forecast.Turns == 1);
+    }
+
+    [Fact]
+    public void ForecastReportsAlreadyLostLevelAtCurrentTurn()
+    {
+        var level = LevelState.Create("Lost", 6, 6) with {
+            Global = new() {
+                CoreHeat = 10,
+                Lost = true,
+                Status = "CORE MELTDOWN"
+            }
+        };
+
+        var forecasts = m_Engine.Forecast(level);
+
+        Assert.Contains(forecasts, forecast => forecast.Kind == EFailureKind.Meltdown && forecast.Turns == 0);
+    }
+
+    [Fact]
+    public void ForecastPredictsStabilityCollapseFromFutureSimulation()
+    {
+        var level = LevelState.Create("Collapse", 6, 6)
+                              .SetCell(new(2, 2), new() {
+                                  Kind = ECellKind.Generator,
+                                  Hazards = new() { Stability = 3 }
+                              }) with {
+            Global = new() { FacilityStability = 1 }
+        };
+
+        var forecasts = m_Engine.Forecast(level);
+
+        Assert.Contains(forecasts, forecast => forecast.Kind == EFailureKind.StabilityCollapse && forecast.Turns == 1);
+    }
+
     [Fact]
     public void StableReactorWithPowerAndCoolingCanActivate()
     {
@@ -92,4 +166,12 @@ public sealed class SimulationEngineTests
     }
 
     private readonly SimulationEngine m_Engine = new();
+
+    private sealed class StepCountingHazard : Hazard
+    {
+        public override IEnumerable<Forecast> Predict(LevelState level, int turns)
+        {
+            yield return new(EFailureKind.PipeBurst, new(turns, 0), turns, $"STEP {turns}");
+        }
+    }
 }