What it is

Simple Maze is a maze generator with a solver built in. You choose the grid, the size and what goes in the maze, and it carves one for you. Then it solves the maze exactly, so you know for certain that it can be finished, how many moves the best solution takes and how many different best solutions there are.

Everything is deterministic. The same settings and the same seed always give the same maze, and every maze keeps the settings and seed it was made from. When the generator can't give you exactly what you asked for, it says so in the maze's notes instead of quietly handing you something else.

The four grids

Features

How it works

Why "verified"

Lots of generators make mazes that are probably fine. Simple Maze proves the things you design around:

• The par is real. It is the shortest solution that exists, counting every key, door, gate and portal, so a 40-move maze really takes 40 moves.
• Gimmicks are part of the proof. Doors, gates and gems are solved together with the maze, and by default every door and every switch's first gate stands in the way, so its key or switch is really needed.
• Getting stuck is detected. One-way sides, traps and rolling can leave a player somewhere they can't finish from. Every maze reports it, and you can ask for mazes where it never happens.
• Misses are reported. When a target star count, a coverage or a gimmick can't be met, the maze's notes say what happened and what you got instead.

Getting started

Open Window > Living Failure > Simple Maze > Maze Generator, pick a preset, press Generate and look at the analysis on the right. Then open the demo scene and play. The Quick Start walks through the whole loop in about five minutes.

1. Install

Import the package. Everything lives under Assets/SimpleMaze/, and nothing is added to your scenes until you ask for it.

The core (the generator, the solver, the play rules and the maze data) has no package dependencies. The demo uses the Input System and Unity UI packages. It reads the keyboard through the Input System, so set Project Settings > Player > Active Input Handling to Input System Package or Both before you play it.

2. Generate a maze

Open Window > Living Failure > Simple Maze > Maze Generator. You can also get there from Assets > Create > Simple Maze > Maze Generator.

3. Read the analysis

The pane on the right shows the selected maze. From the top:

• The verdict: the par in steps or rolls, whether the best solution is unique or how many there are, and the difficulty out of 5. A warning shows when a player can get stuck.
• Board: a picture of the maze with a legend, tabs for each floor, and a zoom. Hover a cell to see what is in it.
• Best solution: a slider that steps through the solution, with the players moving, keys and gems disappearing as they're taken and gates flipping. Below it is the move list and a Copy solution button.
• Facts and Generation report: the numbers (dead ends, loops, decisions, coverage and more) and every note the generator left.
• Export: save the maze as a PNG or SVG, as a printable sheet, an answer key or the colour view.

4. Save it

Press Save and choose:

• Current saves the selected maze as a MazePuzzleAsset.
• Pack (all) saves every maze in the set as one ordered MazePuzzlePack.
• Pack (unique only) saves just the mazes with exactly one best solution.

Both asset types have inspectors with the same analysis pane, plus Verify, which solves the maze again and refreshes its stored verdict, and Re-roll, which makes a new maze from the same settings with a fresh seed. A pack also has Export all, which writes every maze as a printable picture and its answer key into a folder you pick.

5. Play the demo

Open Assets/SimpleMaze/Scenes/SimpleMazeDemo.unity and press Play. The demo opens on a welcome screen. Press Let's play, pick a mode, then choose Endless for a new maze to your order or Level Pack for the ready-made levels.

The controls are also listed at the bottom of the screen while you play:

• Arrows or WASD move or roll, and Q, E, Z and C take the diagonal sides on hex, triangle and circular mazes.
• Space or Enter takes the stairs (or Page Up and Page Down).
• U (or Backspace, or Ctrl+Z) undoes a move, R restarts and H shows a hint.
• F lets the solver play the rest of the maze from where you are, and F or R stops it.
• Tab or 1 to 4 switches player when several players each have a goal of their own.
• [ and ] or a right-drag turn the view, Home and End tilt it, the mouse wheel or + and - zoom, and V resets it.
• M mutes the sound and Esc goes back to the menu.

6. Use it in your game

Make a maze in code, check what the solver found, and read the rest straight off the MazeData:

using SimpleMaze;

var settings = new MazeSettings
{
    Grid = TopologySpec.Circle(10),
    Endpoints = Endpoints.OutsideIn,   // start on the rim, goal in the centre
    Keys = 2,
    TargetDifficulty = 3,              // keep trying until it rates 3 stars
};
MazeData maze = MazeGenerator.GenerateVerified(settings);
Debug.Log($"Par {maze.Par} steps, {maze.Difficulty} stars, solvable: {maze.Solvable}");

To run your own game on it, keep a MazePlay and ask MazeRules what each move does. These are the same rules the solver used, so your game always agrees with the par:

MazePlay play = MazeRules.NewGame(maze);
int here = play.Positions[0];
int next = maze.Topology.Neighbor(here, 0);       // the cell through side 0

if (MazeRules.TryStep(maze, play, 0, next, out string reason))
{
    if (MazeRules.IsSolved(maze, play)) Debug.Log("Solved!");
}
else Debug.Log(reason);                            // why it can't go: a wall, a locked door...

Or let the demo's 3D view draw and play it for you. MazeGame adds a MazeView3D to the same object and builds the whole maze from primitives:

using SimpleMaze.Demo;

var game = new GameObject("Maze").AddComponent<MazeGame>();
game.Begin(maze);
game.View.FrameCamera(Camera.main, -1);           // -1 frames every floor

A saved maze works the same way: give your script a MazePuzzleAsset field and use its Maze, or a MazePuzzlePack and its Get(index). See the API Reference for the rest.

Where to next

• Generating explains every setting and what it does.
• Demos shows how the demo scene is put together and how to change it.
• Troubleshooting covers notes, fallbacks and limits.

The Maze Generator window

Open Window > Living Failure > Simple Maze > Maze Generator. The settings are on the left in six sections (Board, Carving, Shape, Players and movement, Gimmicks and Quality), and the mazes you've made are on the right with the analysis pane. Fields only appear when they apply, so Rings shows for a circular board and Width and Height for the others.

Every maze the window makes goes through verified generation: if a maze misses what you asked for, the generator tries the next seed, and if none of its tries succeed it gives you the closest one with a note saying why. Generation runs on a background thread with a progress bar and a Cancel button, and your settings and the unsaved mazes survive a recompile.

Each table below gives the label in the window, the matching field on MazeSettings for code, and the range it accepts. Values outside the range are clamped, so code can pass anything.

Board

In code, TopologySpec.Grid(shape, width, height) and TopologySpec.Circle(rings) build the board, and you set Floors on the result.

Carving

Shape

Players and movement

How players move

The solver, the generator and the play rules your game uses all follow the same rules, so a move your game allows is exactly a move the solver counted.

Step. A player moves one cell through an open side. A door needs its key, a shut gate blocks, a one-way side only lets you out its own way, a tunnel side leads under the corridor to the cell beyond, and stairs lead up or down a floor. A trap is never a legal step. Stepping into a portal puts you on its twin. Keys and gems are picked up where you land, and landing on a switch flips every gate of its colour. You are home when you land on your goal holding every gem. With several players, each one moves on its own and keeps its own keys, gems and switch flips, and players can pass through each other.

Roll. Every player rolls the chosen way at once, front-most first, until a wall, a locked door, a shut gate, a one-way side, the border or another player stops it. Tunnels are rolled straight through. Rolling onto a trap fails the whole roll, so nothing changes. A player picks up whatever it rolls over, and the players share keys and gems, which makes several rolling players a cooperative puzzle. A player is home the moment it rolls over its goal holding every gem, a portal throws it out of its twin still rolling, and a player that comes to rest on a switch flips its gates once the roll is over.

Gimmicks

Gimmicks are placed one type at a time in a fixed order (portals, keys and doors, switches and gates, gems, one-way sides, then traps), and the maze is solved again after each type. A type that can't be made to work is dropped on its own, with a note, and never drags the others down.

Quality

How the stars work

The rating comes from a score. On Step the score is the longest player's par, plus 5 for every real decision on the way (a fork whose wrong way runs 3 or more cells deep, so you can't see the dead end at a glance), plus 6 per key, 2 per gem or portal pair and 1 per one-way side. On Roll it is the par in rolls, plus 2 per key and 1 per gem.

The bands were measured on a sweep of everyday mazes (576 Step and 288 Roll boards, on every grid, sizes 6 to 24, all six algorithms, with and without braid and holes), so each star covers about a fifth of them. A maze that isn't proven solvable gets 0 stars. Bigger boards usually rate higher, so to hit a target, pick a board size that can reach it.

Auto and presets

Auto fixes settings that fight each other and tells you what it changed. In code it is MazePresets.Tune. It:

• switches Roll to Step on a grid that can't roll (Triangle, Circular or stacked floors);
• raises Braid to 0.6 on a Roll maze below 0.5, or to 0.9 when No soft-locks is on;
• turns Weave off on a board that isn't Square;
• lowers keys and switches to about one per 40 cells;
• raises the State budget to 2,000,000 for several rolling players;
• raises Max attempts to 150 for 4 or 5 star targets, coverage targets or No soft-locks.

Presets replace every setting with a ready-made recipe. In code they are MazePresets.All, and each one's Make() gives a fresh MazeSettings.

Seeds, batches and saving

The same settings and the same seed always give the same maze. In the window, Random uses a fresh seed for every Generate and shows the one it used. Turn Random off to type a seed and keep it. Each maze gets its own seed, the batch's seed followed by a dash and the maze's number in the set (-0, -1 and so on), and every maze stores its own seed, which the analysis pane can copy.

Verified generation tries the seed itself first, then the same seed with #1, #2 and so on added, until a maze meets the request. A maze's stored seed is the one that worked, such as level-7-0#15, so it always reproduces that exact maze.

Batch count makes 1 to 20 mazes per click and adds them to the set. Clear on generate empties the set first, so each click replaces the batch. Save then writes Current as a MazePuzzleAsset, or Pack (all) or Pack (unique only) as a MazePuzzlePack, using the name in Save name as the suggestion.

Limits and notes

The generator never quietly gives you less than you asked for. Whenever it adjusts something, the maze's Notes say what happened, and the Generation report in the analysis pane lists them. Each note starts with the setting it is about, for example "Rooms:", "Players:" or "Target difficulty:". Common ones:

• Not enough room: rooms, loops, crossings, players, portal pairs or doors that wouldn't fit on the board.
• A gimmick dropped: no layout with it could be solved (without a soft-lock, if you asked for that) in 8 tries, so it was left out.
• A setting that doesn't apply: Roll on a board that can't roll, or Weave off Square.
• A shape that's too small for the board, so the whole board was used.
• A missed target: no maze in the attempts rated the stars you asked for, and you got the closest.
• Not verified: the solver's state budget ran out before every player got home.

Use MazeAudit.MeetsRequest(maze) to check whether a maze got everything its settings asked for. A pack's inspector can re-roll every maze in the pack that didn't (Re-roll > Fallbacks).

Generating from code

Everything the window does is available from code through MazeGenerator. Your settings object is copied and clamped first, so it is never changed.

using SimpleMaze;

var s = new MazeSettings
{
    Grid = TopologySpec.Grid(GridShape.Hex, 13, 13),
    Players = 2,
    SharedGoal = true,
    Keys = 1,
    Gems = 2,
    TargetDifficulty = 4,
    Seed = "level-7",                 // empty = a fresh random seed
};

MazeData one = MazeGenerator.Generate(s);          // one maze from this exact seed, solved and rated
MazeData good = MazeGenerator.GenerateVerified(s); // tries seeds until the maze meets the request
List<MazeData> pack = MazeGenerator.GenerateBatch(s, 10);   // seeds level-7-0 to level-7-9, each verified

Each one has an Async version that runs on a background thread and takes a CancellationToken. In Unity, await carries on on the main thread afterwards. GenerateBatchAsync also reports progress:

var progress = new Progress<int>(n => Debug.Log($"{n} of 10 done"));
List<MazeData> mazes = await MazeGenerator.GenerateBatchAsync(s, 10, progress, cancel.Token);

A custom shape comes from ShapeMask.FromRows, ShapeMask.FromText or ShapeMask.FromPixels, which reads raw RGBA bytes, so set Shape = ShapeKind.Custom and ShapeMask on the settings:

s.Shape = ShapeKind.Custom;
s.ShapeMask = ShapeMask.FromRows(
    "..##...##..",
    ".####.####.",
    "###########",
    ".#########.",
    "..#######..",
    "....###....");

See the API Reference for everything on MazeData.

Assemblies

Everything below is in the SimpleMaze namespace unless it says SimpleMaze.Demo.

MazeGenerator

The entry point. Every method copies and clamps the settings first, so your object is never changed, and the same settings with the same seed always give the same maze. A null settings object means the defaults, and an empty seed means a fresh random one.

MazeSettings and enums

MazeSettings holds every input to the generator. Each field, its range and what it does is on the Generating page. It also has:

TopologySpec describes the board: Shape, Width, Height, Rings, FirstRing and Floors. Build one with TopologySpec.Grid(shape, width, height) or TopologySpec.Circle(rings, firstRing = 0), and Clamp() returns a copy with every field in range.

MazeData

A finished maze: the board, the passages, the players and gimmicks, and the solver's verdict stamped on it. It is serializable, so it stores inside a ScriptableObject, and plain C#, so it works outside Unity too. Cells are numbered as described in Cells and slots.

Cells and slots

A cell is an index from 0 to CellCount - 1, and each side of a cell is a slot. Use Topology.Neighbor(cell, slot) to find the cell across a side and SlotTo(cell, other) for the side between two neighbours.

Roll directions use the same numbers as the slots on Square and Hex.

Playing: MazeRules

Your game keeps a MazePlay and asks MazeRules what each move does. These are the same rules the solver counted with, so the game and the par always agree.

Solving and rating

Presets and Auto

Pictures

MazeExport draws a maze in plain C#, so it works in a build, in the editor or on a server.

MazeSketch is the drawing model behind the pictures. MazeSketch.Build(maze, play, focus, trails) sketches a position, MazeSketch.Frames(maze) steps through the stored solution move by move, and MazeSketch.Describe(maze, cell, play) says what is in a cell in plain words.

Shapes

A ShapeMask is a black and white bitmap (Width, Height, Pixels, row 0 at the top). Set it on MazeSettings.ShapeMask with Shape = ShapeKind.Custom.

Topology

A Topology is a grid as a graph of cells and slots. Get one from MazeData.Topology or Topology.Create(spec).

A board with floors is a LayeredTopology, which adds Base, Floors, FloorOf(cell), BaseCell(cell), At(floor, baseCell), UpSlot(cell), DownSlot(cell) and IsStairSlot(cell, slot).

ScriptableObjects

Both are created by the Maze Generator's Save menu, not by an empty right-click Create.

Demo components

These are in SimpleMaze.Demo. The Demos page explains how they fit together.

Building blocks

The pieces the generator is made of are public too, for anyone who wants to build their own pipeline. Most projects never need them.

The demo scene

Open Assets/SimpleMaze/Scenes/SimpleMazeDemo.unity and press Play. The scene holds a camera, a sun, and one object called Simple Maze Demo with the MazeDemo component and the five level packs assigned. Everything else, from the maze to the menus, is built in code when the scene starts, so there are no prefabs, models, textures or audio files to look after.

One component: MazeDemo

Add MazeDemo to any object in a scene with a camera and press Play. When it starts, it builds:

• a Maze child with MazeView3D, which draws the maze, and MazeGame, which plays it;
• the HUD (MazeHud) and the hub (MazeHub), both in uGUI with Unity's built-in font;
• MazeBeeper for the sounds and MazeEffects for the effects.

It also sets the camera up for the maze, giving it a plain background colour and a 40 degree field of view, and adds a sun if the scene has no light.

The flow

The five modes

On a circular board, Endless mazes run from the rim to the centre. The recipes are in MazeModes.Endless, and each one goes through MazePresets.Tune and verified generation, so the maze you get rates the stars you picked whenever the board can reach them.

The level packs

The demo ships with 50 levels in five packs in Assets/SimpleMaze/Generated. Each was made by the generator from a fixed seed, and each was played through to par to check it. They are ordinary MazePuzzlePack assets, so you can open them in the inspector, read their analysis, or export them as printable pictures.

Your own packs: make mazes in the Maze Generator, choose Save > Pack (all), and drag the pack into a slot on the MazeDemo component.

Progress: each level's best number of moves is saved in PlayerPrefs under SimpleMaze.Demo.Best.<pack name>.<level>, so it stays on that device. Races are not recorded, and neither is a level the auto-solver helped with. The win panel says "Level complete!", "New best" or "Your best is" accordingly.

Playing

The keys are listed at the bottom of the screen while you play, and in the Quick Start. A few details:

• Moving: a key moves you toward the side whose direction on screen is closest to it, so the controls feel right from any camera angle and on any grid. Holding a key keeps walking, and a key pressed during a move is kept for the next one.
• Moves count steps, or rolls that moved someone. Bumping a wall, a roll that goes nowhere and a roll onto a trap don't count.
• Undo takes back one move at a time and Restart puts the whole maze back to the start.
• Hint lays a gold arrow toward the next move of a best way on, worked out from where you are.
• Solve (or F) lets the solver play the rest from where you are. Press it again, or F or R, to stop.
• Several players: in a race the turn passes after every step, and the board shows the maze as the player whose turn it is sees it (their keys, doors and gates). When each player has its own goal, Tab or 1 to 4 switches player. On Roll every roll moves everyone.
• The view: the camera frames the board in the space the HUD leaves free. You can turn it, tilt it and zoom, and when zoomed in it follows the player. On a maze with floors it follows the player's floor and hides the floors above.
• The rating on the win panel is 3 pips on par, 2 a little over (up to 2 moves, or a quarter of the par on bigger mazes) and 1 beyond that. Races show who won instead.

Sounds and effects

MazeBeeper makes every sound in code when the demo starts: steps (three variants, so walking doesn't sound robotic), a bump, a roll, the stairs, a key, a gem, the goal opening, a door, a switch with its gates, a portal, spikes, a "no way" buzz, a hint, undo and restart, the win, and a button blip. M mutes it.

MazeEffects adds small effects made of a pool of tiny shapes: sparkles for a key or a gem in its colour, a gold ring when the goal opens, dust at a bump, a purple swirl at both ends of a portal, sparks off spikes, and confetti for the win. Nothing is created or destroyed while you play, and because the effects use the demo's ordinary materials, they look the same in every render pipeline.

Render pipelines

The demo works in URP (recommended), HDRP and the Built-in pipeline without any changes. Its materials use the active pipeline's default lit shader.

HDRP lights in physical units, sets the exposure on its own and takes its ambient light from a sky, so the demo would come out dark and tinted. With HdrpLook on, DemoHdrp adds a global volume with a fixed exposure, no tone mapping or bloom, and a gradient sky in the demo's colours, clears the camera to the demo's background colour, and sets the sun in lux. That code only compiles when the HDRP package is installed.

Using the pieces yourself

The demo components work on their own too. The smallest setup is one MazeGame, which adds its MazeView3D automatically:

using SimpleMaze;
using SimpleMaze.Demo;

var game = new GameObject("Maze").AddComponent<MazeGame>();
game.Begin(maze);                                   // build it and start a game
game.View.FrameCamera(Camera.main, -1);             // -1 frames every floor
game.Won += g => Debug.Log($"Solved in {g.Moves}, par {g.Par}");

• Input: MazeGame reads the keyboard itself. For touch or a gamepad, call Push(Vector2 screen) with the direction on screen, and Undo(), Restart(), ShowHint(), StartAutoSolve() and TakeStairs(way) for the rest.
• The camera is yours unless you turn on CameraControls. Only FollowFloor moves it, on mazes with floors.
• Events: Won fires once when the game is won, Cue for every moment worth a sound, Moment for the same moments with a position and colour for effects, and Message for short notes such as "No stairs here".
• A HUD: add a MazeHud and set its Game, or read Moves, Par, Solved and Player into your own UI.
• The look: the colours, materials and shapes are in DemoLook.cs, and the timing is on MazeGame (StepTime, RollTime, PortalTime, Hop and SolvePause).
• Without the 3D view: keep a MazePlay and use MazeRules directly, as in the Quick Start.

Reading the notes

Whenever the generator adjusts something, it writes a note on the maze instead of quietly giving you less. The notes are listed under Generation report in the analysis pane, and in MazeData.Notes from code. Each one starts with what it is about, such as "Keys:", "Players:" or "Target difficulty:", and the sections below explain the common ones. MazeAudit.MeetsRequest(maze) tells you whether a maze got everything its settings asked for, and a pack's Re-roll > Fallbacks replaces every maze that didn't.

"Target difficulty: 4 stars not found in 60 tries; closest was 3."

The stars come mostly from the par, so the board size sets what a maze can rate. A small board can't reach 5 stars and a huge one rarely rates 1. To hit a target:

• make the board bigger for more stars, or smaller for fewer;
• try another algorithm: long corridors make long routes, so on a 15 by 15 square board Recursive Backtracker mazes average 4.5 stars, Hunt and Kill 4.0, and Prim 2.9;
• raise Max attempts under Advanced, or press Auto, which raises it to 150 for 4 and 5 star targets.

The rules behind the stars are on the Generating page.

Fewer gimmicks than I asked for

Gimmicks are only placed where they do their job, and the generator says when it couldn't fit them all:

• "Keys: the maze's loops (or portals) leave room for 1 of 3 doors that can't be walked around." A door only counts when it's truly in the way, and loops give the player ways round it. Lower Braid and Extra loops, or turn on Shortcut doors to allow doors that can be walked around. The same goes for switches and their gates.
• "Keys: the way to the goal is too short for 4 doors." Use a bigger board, or Farthest endpoints for a longer way.
• "Portals: room for 1 of 3 pairs the solution would actually use." Each portal must shorten the way, so it needs a long way with loops. A bigger board or more loops allows more.
• "Gems: room for 2 of 5." Gems go off the way, in dead ends first, and each one must be collectable together with the others. A small board has few such spots, and on a rolling board a gem also has to be reachable without getting stuck. Use a bigger board.
• "Gimmicks: no layout with traps was solvable in 8 tries; dropped the traps." That type couldn't be made to work with everything else on this board, so it was left out and the rest kept.

"Can get stuck"

The analysis pane warns when a player can reach a position it can no longer finish from. One-way sides, switches and rolling can all cause it. Rolling mazes have it very often, just like ice puzzles, so it is reported rather than forbidden by default. You can:

• turn on No soft-locks so only mazes without it are accepted (on Roll, raise Braid close to 1 as well, or press Auto);
• or keep the maze and give players a Restart and Undo, as the demo does.

"Not verified" or "the state budget ran out"

The solver explores every position the players can reach, counting keys, gems and switch flips. Several rolling players, many keys and gems, or a very large board can need more positions than the budget allows, and then the maze is marked not verified instead of guessed. Raise State budget under Advanced (up to 5,000,000), or use a smaller board, fewer players or fewer gimmicks. Several rolling players need the most, and Auto raises the budget to 2,000,000 for them.

The race isn't fair

"Players: the gimmicks leave no other start exactly as far from the goal as player 1's (pars 36, 32), so the race isn't fair." On Step, every player in a race needs the same par, and with gimmicks the other players' starts are picked after the gimmicks are placed, using each cell's real par. On some boards no such cells exist. Verified generation, which the window always uses, skips these mazes and tries the next seed, so you only see this note from MazeGenerator.Generate or after every attempt missed. A bigger board or fewer gimmicks helps.

Roll or weave was ignored

• "Movement: Roll needs a Square or Hex board" or "Roll keeps to one floor": rolling needs straight lines, which Triangle and Circular boards and stacked floors don't have, so those mazes use Step.
• "Movement: no start could roll into the goal on this maze": rolling needs loops. Raise Braid (Auto sets at least 0.6).
• "Weave: crossings need a Square board": weave crossings only exist on Square boards.

My shape looks wrong

• "Shape: Heart leaves only 20 cells on this board, which is too few, so the whole board was used." Use a bigger board or a higher Fill.
• "Shape: 4 separate pieces; joined them with 3 bridges." The shape fell apart, for example into the letters of a word, and was joined up. Turn off Connect pieces to keep only the largest piece instead.
• Text: give it a wide board, about 6 cells across per letter and at least 9 rows. On a Square board the font's diagonal strokes only touch at their corners, so a letter like M can lose its diagonals and read as H. Check the preview, and try another word or grid if it matters.
• "Nothing in this image counts as inside." Switch Inside is between Dark, Light and Opaque, or move the threshold slider.

Generation feels slow

Plain mazes are fast at any size. Measured on a desktop PC outside Unity (your machine and Unity's runtime will differ):

The costly part is solving, which grows with every key, gem and switch (each one multiplies the positions to search) and most of all with several rolling players, who are solved together. Every gimmick type is solved again after it is placed, up to 8 times. Generation runs on a background thread in the window and with the Async methods, so it never freezes the editor or your game, and it can be cancelled.

The demo ignores the keyboard or the mouse

The demo uses the Input System package. Set Project Settings > Player > Active Input Handling to Input System Package or Both. The hub and the HUD make an EventSystem with the Input System's UI module when the scene has none. If your scene already has an EventSystem, its input module has to match your input handling.

HDRP looks dark, or ignores my volumes

Out of the box HDRP uses physical light units, automatic exposure and sky lighting, which would make the demo dark and tinted. MazeDemo.HdrpLook (on by default) adds a global volume at priority 10 with a fixed exposure and a gradient sky, and sets the sun in lux, so the demo looks the same as on the other pipelines. If you want your own volumes and lights to take over, turn HdrpLook off.

Resetting the demo's progress

The demo saves each pack level's best moves in PlayerPrefs, under SimpleMaze.Demo.Best.<pack name>.<level>. Call MazeProgress.Clear(packName, levelCount) to forget a pack, or delete those keys. A pack's progress is filed under its pack name, so renaming a pack starts it fresh.

Seeds and versions

The same settings and seed always give the same maze within a version of Simple Maze. A future version that improves the generator may change what a seed produces. Saved assets store the maze itself, not just its seed, so your saved mazes and packs never change. Verified generation stores the seed that actually worked, such as level-7#3, so copying a maze's own seed always rebuilds that exact maze.

Console messages

• "[Simple Maze] Documentation page not found": the documentation menu looks for these pages in a folder whose path contains SimpleMaze and Documentation. Keep the Documentation folder inside the Simple Maze folder.
• "[Simple Maze] Generation failed": something went wrong on the generation thread. Please send the message with your settings and seed.

Still stuck

Email livingfailuregames@gmail.com with your Unity version and, for a maze-specific question, its seed and settings. Copy seed and Copy solution in the analysis pane make that easy, and a seed rebuilds the maze exactly.

About Simple Maze

Simple Maze is a maze generator for Unity, made by Living Failure. It builds mazes on square, hex, triangle and circular grids, with keys and doors, switches and gates, gems, traps, one-way sides, portals, rolling players and up to 8 floors. Then it solves each maze exactly, stamps it with its proven par and a 1 to 5 star rating, and stores it as a ScriptableObject or exports it as a picture. A complete 3D demo, built entirely in code, is included.

Version 1.0, made and tested with Unity 6000.6.

What's in the package

Design principles

• Solve exactly. The par and the number of best solutions come from searching every position the players can reach, not from an estimate.
• Prove the gimmicks together. Keys, gates, gems, portals and the rest are solved with the maze, so a door that looks necessary really is.
• Be fair. Race starts are picked so every player's par is the same, gimmicks included.
• Be honest. When a request can't be met, the maze's notes say so. Nothing is quietly downgraded, and the store page claims nothing the solver can't back up.
• One set of rules. The generator, the solver and the play rules your game uses all move players the same way, so your game and the par always agree.
• No bloat. The core has no package dependencies, and the demo and the editor tools live in their own assemblies. The demo needs no prefabs, models, textures or audio files.

More from Living Failure

Simple Klotski: sliding-block puzzles in five modes (Gridlock, Klotski, Clear, Clear 3D and Clear Snakes), each board solved exactly and stamped with its proven par.

Simple States: switch-and-state logic puzzles in four modes: Classic combinations, Ordered chains with traps, Lights Out with paintable pattern goals, and the three-state Trilight grid.

Simple Connect: a connection-puzzle toolkit where you draw the pairs (square and hex), rotate the pipes, or rotate a whole network back together.

Simple Hamiltonian: a cover-all, single-path puzzle generator (square and hex), where the solution is one unbroken line that visits every tile once.

All on the Unity Asset Store.

Support

Questions, bugs and ideas are welcome at livingfailuregames@gmail.com. Please include your Unity version and, for anything about a particular maze, its seed and settings, since a seed rebuilds the maze exactly. Corrections to these pages are welcome too.

License

Distributed under the Unity Asset Store End User License Agreement. Use it in your games and tools, but don't resell or redistribute the source as an asset.