Generators

Four static entry points, one shape. Namespace SimpleStates. Each clamps the settings, rolls candidates until one matches (or MaxAttempts runs out), analyzes it exactly, stamps the persisted summary, and attaches the transient Analysis + Report.

Solvers

Static, allocation-light, pure C#. Every generated board arrives pre-analyzed; call these to re-analyze saved or hand-built boards (the analysis is transient and never serialized).

Both classic solvers produce identical analyses — they are cross-checked field-for-field in the test harness. Malformed rule data (arrays shorter than SwitchCount) is rejected with a warning instead of throwing.

StatesPuzzle

The serializable puzzle unit (stored inside the ScriptableObjects). Board state is a bitmask: bit d set = state d on. Start = all off (0), Goal = all on.

Plus: AllStatesMask, IsLightsOut, StampSummary(), factories StatesPuzzle.Classic(…) / Ordered(…), and label helpers StateTag/SwitchTag/StateName/SwitchName ("ST3", "Switch 1"). Two-letter tags because switch and state share an initial — ST3 is a state, SW3 is a switch.

Ordered rules

An OrderedRule is a gate plus effects. The switch fires only when every condition holds; then all effects apply.

The generator emits set-on chains, decoys, and (per policy) traps — Effect.Set(state, false) gated on that state being on. The data model carries the full condition/effect vocabulary, so hand-built rules can use all of it; the BFS solver handles any combination.

PuzzleAnalysis

Everything the solver learns. Classic counts every valid switch set; Ordered counts shortest sequences.

GenerationSettings & GenerationReport

Every settings field is documented in the Generating page's table. Clamp() coerces all fields into valid ranges; Clone() copies a recipe. The report:

Enums

ScriptableObjects

Storage lives in Runtime/ScriptableObjects. Both types implement IPuzzleProvider (AppendTo(List<StatesPuzzle>)), so one list can mix singles and packs.

Reading a saved puzzle

using SimpleStates;

// Assigned in the inspector, or loaded any way you like:
[SerializeField] StatesPuzzlePack pack;

void Start()
{
    StatesPuzzle p = pack.Get(0);

    // The persisted verdict — no solving needed:
    Debug.Log($"{p.Mode} · {p.StateCount} states · unique={p.Unique} · {p.Difficulty}★");

    // Classic play is three lines of state:
    long state = p.Start;
    state ^= p.ClassicRules[2];              // press P3
    bool won = state == p.Goal;

    // Need the full picture (all solutions, roles, steps)? Recompute:
    p.Analysis = p.IsMod3 ? Mod3Solver.Analyze(p)
        : p.Mode == PuzzleMode.Ordered ? OrderedSolver.Analyze(p)
        : ClassicSolver.Analyze(p);
}

For grid boards, cell (x, y) is index y * GridWidth + x — the same index is both the state bit and the switch index (and the CellStart/CellGoal slot on Trilight).

Demo runtime (SimpleStates.Demo)

The demo assembly's play loop is reusable as-is — StatesGame is a complete referee for any board:

Around it: StatesLevelRenderer (board + optional switch/state prefab slots), StatesInput (click / R / F), StatesDemo (flow), StatesMenu + StatesHud (Canvas UI), StatesBeeper (procedural SFX). See Demos.