zfxaction26_2/src/ReactorMaintenance.Simulation/Models.cs

namespace ReactorMaintenance.Simulation;

public enum CellKind
{
    Empty,
    Floor,
    Wall,
    Reactor,
    CoolingPump,
    Generator,
    PressureRegulator,
    DiagnosticTerminal,
    ControlTerminal
}

public enum PipeMedium
{
    None,
    Pressure,
    Coolant,
    Fuel
}

public enum FailureKind
{
    PipeBurst,
    Ignition,
    Meltdown,
    StabilityCollapse,
    ReactorReady
}

public sealed record GridPosition(int X, int Y)
{
    public IEnumerable<GridPosition> Neighbors()
    {
        yield return new(X - 1, Y);
        yield return new(X + 1, Y);
        yield return new(X, Y - 1);
        yield return new(X, Y + 1);
    }
}

public sealed record HazardState
{
    public HazardState Clamp()
    {
        return this with
        {
            Heat = Rules.Clamp(Heat),
            Smoke = Rules.Clamp(Smoke),
            FuelVapor = Rules.Clamp(FuelVapor),
            LiquidFuel = Rules.Clamp(LiquidFuel),
            CoolantPooling = Rules.Clamp(CoolantPooling),
            ElectricalCharge = Rules.Clamp(ElectricalCharge),
            Stability = Rules.Clamp(Stability)
        };
    }

    public int Heat { get; init; }
    public int Smoke { get; init; }
    public int FuelVapor { get; init; }
    public int LiquidFuel { get; init; }
    public int CoolantPooling { get; init; }
    public int ElectricalCharge { get; init; }
    public int Stability { get; init; } = 10;
    public bool Fire { get; init; }
}

public sealed record CellState
{
    public CellKind Kind { get; init; } = CellKind.Floor;
    public PipeMedium Pipe { get; init; }
    public int Flow { get; init; }
    public int Pressure { get; init; }
    public int Integrity { get; init; } = 10;
    public int LeakRate { get; init; }
    public bool PipeOpen { get; init; } = true;
    public bool Powered { get; init; }
    public bool DoorLocked { get; init; }
    public HazardState Hazards { get; init; } = new();

    public bool IsWalkable => Kind != CellKind.Wall && Kind != CellKind.Empty;
    public bool HasPipe => Pipe != PipeMedium.None;
}

public sealed record GlobalState
{
    public int Turn { get; init; }
    public int ActionsPerTurn { get; init; } = 3;
    public int CoreHeat { get; init; } = 5;
    public int FacilityStability { get; init; } = 10;
    public int Power { get; init; } = 5;
    public int Cooling { get; init; } = 0;
    public bool ReactorActivated { get; init; }
    public bool Lost { get; init; }
    public string Status { get; init; } = "STABILIZE SYSTEMS";
}

public sealed record Forecast(FailureKind Kind, GridPosition? Position, int Turns, string Message);

public sealed record LevelState
{
    public static LevelState Create(string name, int width, int height)
    {
        if (width < 4 || height < 4)
            throw new ArgumentOutOfRangeException(nameof(width), "Levels must be at least 4x4.");

        var cells = CreateCells(width, height);
        for (var y = 0; y < height; y++)
        for (var x = 0; x < width; x++)
            if (x == 0 || y == 0 || x == width - 1 || y == height - 1)
                cells[y * width + x] = cells[y * width + x] with { Kind = CellKind.Wall };

        return new()
        {
            Name = name,
            Width = width,
            Height = height,
            Cells = cells,
            Robot = new(1, 1)
        };
    }

    public CellState GetCell(GridPosition position)
    {
        EnsureInBounds(position);
        return Cells[Index(position)];
    }

    public LevelState SetCell(GridPosition position, CellState cell)
    {
        EnsureInBounds(position);
        var cells = Cells.ToArray();
        cells[Index(position)] = cell;
        return this with { Cells = cells };
    }

    public bool InBounds(GridPosition position)
    {
        return position.X >= 0 && position.Y >= 0 && position.X < Width && position.Y < Height;
    }

    public int Index(GridPosition position)
    {
        return position.Y * Width + position.X;
    }

    private void EnsureInBounds(GridPosition position)
    {
        if (!InBounds(position))
            throw new ArgumentOutOfRangeException(nameof(position), $"Position {position.X},{position.Y} is outside {Width}x{Height}.");
    }

    private static CellState[] CreateCells(int width, int height)
    {
        return Enumerable.Range(0, width * height).Select(_ => new CellState()).ToArray();
    }

    public string Name { get; init; } = "New Reactor";
    public int Width { get; init; } = 16;
    public int Height { get; init; } = 12;
    public CellState[] Cells { get; init; } = CreateCells(16, 12);
    public GridPosition Robot { get; init; } = new(1, 1);
    public GlobalState Global { get; init; } = new();
    public IReadOnlyList<Forecast> Forecasts { get; init; } = Array.Empty<Forecast>();
}

internal static class Rules
{
    public static int Clamp(int value)
    {
        return Math.Clamp(value, 0, 10);
    }
}