Organize simulation systems and balancing profiles

src/ReactorMaintenance.Simulation/Effects/CellIntegrityEffect.cs

@@ -0,0 +1,35 @@
+using ReactorMaintenance.Simulation;
+
+namespace ReactorMaintenance.Simulation.Effects;
+
+public sealed class CellIntegrityEffect : ISimulationEffect
+{
+    public CellState Apply(CellState cell)
+    {
+        var integrity = cell.Integrity;
+        var hazards = cell.Hazards;
+
+        if (cell is { HasPipe: true } && cell.Pressure > Balancing.Current.OverpressureThreshold)
+            integrity -= cell.Pressure - Balancing.Current.OverpressureThreshold;
+
+        if (hazards.Heat >= Balancing.Current.HeatIntegrityDamageThreshold || hazards.Fire)
+        {
+            integrity -= cell.HasPipe ? Balancing.Current.PipeFireIntegrityDamage : Balancing.Current.MinHazardValue;
+            hazards = hazards with { Stability = hazards.Stability - Balancing.Current.FireStabilityDamage };
+        }
+
+        cell = cell with {
+            Integrity = Rules.Clamp(integrity),
+            Hazards = hazards.Clamp()
+        };
+
+        if (integrity > Balancing.Current.MinHazardValue || !cell.HasPipe)
+            return cell;
+
+        return cell with {
+            LeakRate = Math.Max(cell.LeakRate, Balancing.Current.BurstLeakRate),
+            Flow = Balancing.Current.BrokenPipeFlow,
+            PipeOpen = false
+        };
+    }
+}

src/ReactorMaintenance.Simulation/Effects/FireAndElectricalHazardEffect.cs

@@ -0,0 +1,30 @@
+using ReactorMaintenance.Simulation;
+
+namespace ReactorMaintenance.Simulation.Effects;
+
+public sealed class FireAndElectricalHazardEffect : ISimulationEffect
+{
+    public CellState Apply(CellState cell)
+    {
+        var hazards = cell.Hazards;
+        if (hazards.CoolantPooling >= Balancing.Current.ElectrifiedCoolantPoolingThreshold && cell.Powered)
+            hazards = hazards with { ElectricalCharge = hazards.ElectricalCharge + Balancing.Current.ElectricalChargeIncrease };
+
+        var hasFuel = hazards.FuelVapor >= Balancing.Current.FuelVaporFireThreshold || hazards.LiquidFuel >= Balancing.Current.LiquidFuelFireThreshold;
+        var hasIgnition = hazards.Heat >= Balancing.Current.HeatIgnitionThreshold || hazards.ElectricalCharge >= Balancing.Current.ElectricalIgnitionThreshold || cell is { Kind: ECellKind.Generator, Powered: true };
+        if ((hasFuel && hasIgnition) || hazards.Fire)
+        {
+            hazards = hazards with {
+                Fire = hasFuel || hazards.Fire,
+                Heat = hazards.Heat + Balancing.Current.FireHeatIncrease,
+                Smoke = hazards.Smoke + Balancing.Current.FireSmokeIncrease,
+                LiquidFuel = Math.Max(Balancing.Current.MinHazardValue, hazards.LiquidFuel - Balancing.Current.FireLiquidFuelConsumption),
+                FuelVapor = Math.Max(Balancing.Current.MinHazardValue, hazards.FuelVapor - Balancing.Current.FireFuelVaporConsumption)
+            };
+        }
+        else if (hazards.Smoke > Balancing.Current.MinHazardValue)
+            hazards = hazards with { Smoke = hazards.Smoke - Balancing.Current.SmokeDecay };
+
+        return cell with { Hazards = hazards.Clamp() };
+    }
+}

src/ReactorMaintenance.Simulation/Effects/IAreaSimulationEffect.cs

@@ -0,0 +1,8 @@
+using ReactorMaintenance.Simulation;
+
+namespace ReactorMaintenance.Simulation.Effects;
+
+public interface IAreaSimulationEffect
+{
+    CellState[] Apply(LevelState level, CellState[] cells);
+}

src/ReactorMaintenance.Simulation/Effects/ISimulationEffect.cs

@@ -0,0 +1,8 @@
+using ReactorMaintenance.Simulation;
+
+namespace ReactorMaintenance.Simulation.Effects;
+
+public interface ISimulationEffect
+{
+    CellState Apply(CellState cell);
+}

src/ReactorMaintenance.Simulation/Effects/MachineEffect.cs

@@ -0,0 +1,18 @@
+using ReactorMaintenance.Simulation;
+
+namespace ReactorMaintenance.Simulation.Effects;
+
+public sealed class MachineEffect : ISimulationEffect
+{
+    public CellState Apply(CellState cell)
+    {
+        var hazards = cell.Kind switch {
+            ECellKind.Generator when cell.Powered => cell.Hazards with { Heat = cell.Hazards.Heat + Balancing.Current.GeneratorHeatIncrease },
+            ECellKind.CoolingPump when cell.Powered => cell.Hazards with { Heat = cell.Hazards.Heat - Balancing.Current.CoolingPumpHeatReduction },
+            ECellKind.Reactor => cell.Hazards with { Heat = cell.Hazards.Heat + Balancing.Current.ReactorHeatIncrease },
+            _ => cell.Hazards
+        };
+
+        return cell with { Hazards = hazards.Clamp() };
+    }
+}

src/ReactorMaintenance.Simulation/Effects/PipeLeakEffect.cs

@@ -0,0 +1,28 @@
+using ReactorMaintenance.Simulation;
+
+namespace ReactorMaintenance.Simulation.Effects;
+
+public sealed class PipeLeakEffect : ISimulationEffect
+{
+    public CellState Apply(CellState cell)
+    {
+        if (!cell.HasPipe || cell.LeakRate <= Balancing.Current.MinHazardValue)
+            return cell;
+
+        var hazards = cell.Pipe switch {
+            EPipeMedium.Fuel => cell.Hazards with {
+                LiquidFuel = cell.Hazards.LiquidFuel + cell.LeakRate,
+                FuelVapor = cell.Hazards.FuelVapor + (cell.Pressure >= Balancing.Current.PressurizedFuelLeakPressureThreshold ? cell.LeakRate : Math.Max(Balancing.Current.MinHazardValue, cell.Hazards.Heat - Balancing.Current.PassiveFuelVaporHeatOffset) / Balancing.Current.PassiveFuelVaporDivisor)
+            },
+            EPipeMedium.Coolant => cell.Hazards with {
+                CoolantPooling = cell.Hazards.CoolantPooling + cell.LeakRate,
+                Heat = cell.Hazards.Heat - Math.Max(Balancing.Current.MinimumCoolantHeatReduction, cell.LeakRate / Balancing.Current.CoolantHeatReductionDivisor),
+                Smoke = cell.Hazards.Smoke + (cell.Hazards.Heat >= Balancing.Current.CoolantSteamHeatThreshold ? Balancing.Current.CoolantSteamSmokeIncrease : Balancing.Current.MinHazardValue)
+            },
+            EPipeMedium.Pressure => cell.Hazards with { Smoke = cell.Hazards.Smoke + (cell.Pressure >= Balancing.Current.PressureLeakSmokeThreshold ? Balancing.Current.PressureLeakSmokeIncrease : Balancing.Current.MinHazardValue) },
+            _ => cell.Hazards
+        };
+
+        return cell with { Hazards = hazards.Clamp() };
+    }
+}

src/ReactorMaintenance.Simulation/Effects/SmokeSpreadEffect.cs

@@ -0,0 +1,37 @@
+using ReactorMaintenance.Simulation;
+
+namespace ReactorMaintenance.Simulation.Effects;
+
+public sealed class SmokeSpreadEffect : IAreaSimulationEffect
+{
+    public CellState[] Apply(LevelState level, CellState[] cells)
+    {
+        var next = cells.ToArray();
+        for (var y = Balancing.Current.FirstGridCoordinate; y < level.Height; y++)
+        {
+            for (var x = Balancing.Current.FirstGridCoordinate; x < level.Width; x++)
+            {
+                var position = new GridPosition(x, y);
+                var cell = cells[level.Index(position)];
+                if (cell.Hazards.Smoke < Balancing.Current.SmokeSpreadThreshold)
+                    continue;
+
+                SpreadToNeighbors(level, next, position);
+            }
+        }
+
+        return next;
+    }
+
+    private static void SpreadToNeighbors(LevelState level, CellState[] next, GridPosition position)
+    {
+        foreach (var neighbor in position.Neighbors().Where(level.InBounds))
+        {
+            var neighborCell = next[level.Index(neighbor)];
+            if (!neighborCell.IsWalkable || neighborCell.DoorLocked)
+                continue;
+
+            next[level.Index(neighbor)] = neighborCell with { Hazards = neighborCell.Hazards with { Smoke = Rules.Clamp(neighborCell.Hazards.Smoke + Balancing.Current.SmokeSpreadIncrease) } };
+        }
+    }
+}