How we made 300 block puzzle levels provably solvable

Milaan Games — Sun, 15 Nov 2026 01:38:40 +0000

Our block puzzle Blokito has an Adventure mode with 300 designed levels: 10 chapters of 30. A puzzle level that can't be won is the worst bug you can ship. The player blames themselves, retries, and quits. With 300 levels, nobody on a small team can replay every one after each rules change. So every level ships with a recorded solution, and our test suite replays that solution through the real game engine.

What a level is

Each level is a data file with:

an immutable ID and version, its chapter and index, and a difficulty tag
the starting 8×8 board (some cells pre-filled, never a full row or column) plus item markers on cells
one objective: either collect item quotas (stars, diamonds, rubies, emeralds) or clear every pre-placed block of one color
a move limit, the piece batches and an RNG seed
a witness: the winning sequence, recorded as batch slot plus anchor cell for every move
a content hash, so edited content can be told apart from the version that was tested

The witness is the key part. It is a concrete solution, not a claim that one exists.

The validator

The validator loads each level, feeds the witness moves into the same pure-domain engine the game uses (placement, simultaneous line clears, scoring and combo, item collection, move countdown, win check), and asserts that:

every witness move is legal at that moment
the objective completes within the move limit
no ad, revive or other help is needed

Because it runs the real rules code, not a copy, a rules change that breaks a level fails the tests right away. The engine has no scene, file or tween dependencies, so the tests run headless.

What it does not prove

A witness proves that at least one winning path exists. It does not prove that the level is fun, that the difficulty is right, or that a reasonable player will find the path. We still playtest and balance by hand. The validator removes one class of bug (impossible levels) so playtesting time goes to feel instead.

Pacing 300 levels

Levels 1–10 teach one idea at a time.
After that, easy, medium and hard levels alternate, so a hard level is always followed by a breather.
Level 30 of each chapter is a challenge level.
Every first win reveals one of 30 pieces of the chapter's picture. Replays don't give extra rewards.
Progress is stored as the set of completed level IDs. Unlocks and revealed pieces are derived from that set, never kept as separate counters that could drift apart. Adding level 301 later doesn't renumber anything.

Takeaways for your own puzzle game

Store a solution next to every handmade level, and replay it in your tests with your real engine.
Keep the rules engine free of scene and UI code so it can run headless.
Version levels immutably and hash their content.
Derive progress from one source of truth.

If you want to see how it plays, Blokito and our other games are at https://lamian.dev.

Frame-perfect gameplay videos from Godot 4 without a screen recorder

Milaan Games — Fri, 13 Nov 2026 03:21:07 +0000

We make small mobile puzzle games in Godot, and we need a steady supply of vertical gameplay clips for YouTube Shorts and TikTok. Screen recorders gave us dropped frames, desktop notifications in the shot and a different result on every take. So we moved the camera inside the engine. The game renders into an offscreen viewport, and every frame is saved to disk. Then ffmpeg turns the frames into a video.

The idea

Run Godot with a fixed timestep: --fixed-fps 30 --disable-vsync. The game advances exactly 1/30 s per frame no matter how slow the capture is, so animations never stutter.
Start the game from a SceneTree script (--script res://tools/capture.gd) instead of the main scene. The script builds the scene, drives it and quits when done.
Put the real game scene inside a SubViewport at the output size (for example 1080×1920), with render_target_update_mode = SubViewport.UPDATE_ALWAYS.
On each frame, call RenderingServer.force_draw() and save viewport.get_texture().get_image().

Minimal capture script

extends SceneTree

const OUT := "user://capture"
const FRAMES := 300  # 10 s at 30 fps
var viewport: SubViewport

func _initialize() -> void:
    DirAccess.make_dir_recursive_absolute(OUT)
    viewport = SubViewport.new()
    viewport.size = Vector2i(1080, 1920)
    viewport.render_target_update_mode = SubViewport.UPDATE_ALWAYS
    root.add_child(viewport)
    viewport.add_child(load("res://scenes/main.tscn").instantiate())
    record.call_deferred()

func record() -> void:
    for i in FRAMES:
        await process_frame
        RenderingServer.force_draw()
        var img := viewport.get_texture().get_image()
        img.save_jpg("%s/f_%05d.jpg" % [OUT, i], 0.92)
    quit(0)

Run it:

godot --path . --fixed-fps 30 --disable-vsync --audio-driver Dummy --script res://tools/capture.gd
ffmpeg -framerate 30 -i f_%05d.jpg -c:v libx264 -pix_fmt yuv420p -movflags +faststart out.mp4

Driving real input

A recording of an idle menu is boring. Our capture script calls the same functions the drag-and-drop UI uses (begin drag, move, drop) with eased positions, so the clip shows real input, real line clears and the real animations. Every placement and clear is logged to a JSON file with its frame number. A small Python script then adds captions and overlays and lines up sound effects with the logged frames.

Things that bit us

Saves. The capture plays the game for real, so it would write to the player's save file. We run it on a throwaway copy of the project with private save paths, and the script checks that real saves are never touched.
Splash screens and first-run tutorials. Skip them in code before you start recording. Otherwise the first seconds of every clip show the same intro.
Determinism. Seed the piece generator so a "good" run can be re-recorded exactly when you change a caption or the music.
Disk. 30 fps at 1080×1920 is a lot of JPGs. Delete the frames after encoding.

Result

Every run produces the same stutter-free footage, so re-editing never needs a new recording. We use the same script for Play Store screenshots in several languages and screen sizes.

The clips end up in our Shorts for Blokito, a block puzzle with 300 Adventure levels. If you want to see the output, our games and free browser games are at https://lamian.dev. Questions about the script are welcome in the comments.

DEV Community: Milaan Games