Claustrowordia

Port of Antti Haavikko’s LD50 jam winner, with procedural audio and word scoring.

▶ Run in browser

Upstream: https://github.com/anttihaavikko/claustrowordia

Licence: this port's own code is offered under MIT, not the SimVX Examples Licence the rest of the gallery carries. See ATTRIBUTION.md for the upstream it re-implements, the terms of anything it bundles, and the credit each one requires.

Ports live in the repository only, not in the simvx-examples distribution, because each is a derivative work licensed individually against the game it re-implements. Read it with git clone https://git.simvx.com/simvx/simvx.

Tags: port tier-1

Claustrowordia (SimVX port)

SimVX port of anttihaavikko/claustrowordia LD50 jam winner. Crossword-on-a-grid puzzle: place letter tiles on a 7×7 board and score every valid English word they spell along a row or column, read either way.

Licensing: clean re-implementation under MIT; the bundled dictionary is the public-domain ENABLE word list (3-7 letters, profanity-filtered), not the upstream’s. See ATTRIBUTION.md and LICENSE.

Run

# the export runs in a copy made by `simvx examples copy ports_claustrowordia`
simvx examples run ports_claustrowordia            # interactive
simvx examples run ports_claustrowordia --test     # headless capture (3 frames)
simvx export web main.py \
    -o claustrowordia.html

Controls

• Click (or tap) the title screen to start.

• Click a letter in the hand picks up the tile (it follows the cursor).

• Click on an empty grid cell drops the tile there. Words formed in rows / columns (forward and reversed) are scored.

• Right-click while holding a tile cancels and returns it to the hand.

• R, or a click, restarts after game-over.

• Escape quits.

What this port demonstrates

• Procedural textures. Every tile face, grid cell, and drop preview is an anti-aliased rounded rectangle built as a numpy RGBA array and handed straight to Sprite2D.texture: no image files ship with the port (nodes/textures.py).

• Procedural audio. The place pop, the per-letter ascending notes and the word chime are baked from AudioSynth (oscillator + ADSR) into AudioClips at load time. The pickup chirp and the game-over drop are hand-written numpy instead, because one needs a falling pitch sweep and the other concatenates notes, and AudioSynth models neither (nodes/audio.py).

• Coroutines for sequencing. Scoring is a generator: it walks the matched tiles, pulses each one, plays its note, and waits between them with yield from wait(...), so the animation reads as straight-line code (Game._check_words / _announce_word).

• Tween state on a node. Tiles spring toward their target slot and layer a damped-sine punch, a decaying shake, and a scale pulse on top (nodes/tile.py).

• Signals. Game emits score_changed and game_over_changed, so a HUD, an achievement tracker, or a test can follow the run without polling the node.

• MSDF text. Letters and HUD are Text2D nodes ordered by z_index, so the same scene renders identically on desktop Vulkan and in the browser.

• Input actions. The root declares input_context, so the same bindings apply on desktop and on web, where touch arrives as Mouse.LEFT.

Source files

File	Summary	Lines
main.py	Claustrowordia: Port of Antti Haavikko’s LD50 jam winner, with procedural audio and word scoring.	86
harness.py	Scripted-input harness: exercises the title screen, pickup, drop, and scoring.	181
nodes/__init__.py	Claustrowordia port: node modules.	1
nodes/audio.py	Procedural audio: built on the engine’s AudioSynth API.	137
nodes/dictionary.py	Word list + letter pool.	101
nodes/game.py	Game: the top-level scene wiring grid, hand, scoring, and audio.	502
nodes/grid.py	Grid: the 7×7 board.	117
nodes/hand.py	Hand: the bottom row of letter tiles waiting to be placed.	69
nodes/textures.py	Procedural tile textures.	129
nodes/tile.py	Tile node: a single letter tile.	179

Source

# /// simvx
# tags = ["port", "tier-1"]
# upstream = "https://github.com/anttihaavikko/claustrowordia"
# web = { width = 1280, height = 800, responsive = true }
# ///
"""Claustrowordia: Port of Antti Haavikko's LD50 jam winner, with procedural audio and word scoring.

Run:
    simvx examples run ports_claustrowordia
    simvx examples run ports_claustrowordia --test    # headless capture
"""

# /// script
# requires-python = ">=3.14"
# dependencies = ["numpy"]
# ///

from __future__ import annotations

import sys
from pathlib import Path

_PORT_DIR = Path(__file__).parent

from nodes.game import Game  # noqa: E402

from simvx.core import Node2D  # noqa: E402
from simvx.core.input.controls import Key, Mouse
from simvx.core.math.types import Vec2  # noqa: E402
from simvx.graphics import App  # noqa: E402

WIDTH = 1280
HEIGHT = 800


class ClaustrowordiaRoot(Node2D):
    """Root scene wrapper: declares the input actions and adds the Game node."""

    # Declared on the root, so they are in force for the whole tree while this
    # scene is mounted, on the desktop and the web alike.
    # Touch surfaces as Mouse.LEFT, so "primary" covers mouse and finger.
    input_context = {
        "primary": [Mouse.LEFT],
        "secondary": [Mouse.RIGHT],
        "start": [Key.ENTER, Key.SPACE],
        "restart": [Key.R],
        "quit": [Key.ESCAPE],
    }

    def on_ready(self) -> None:
        self.game = self.add_child(Game(viewport_size=Vec2(WIDTH, HEIGHT)))


def main() -> None:
    headless = "--test" in sys.argv
    if headless:
        from simvx.core.testing import InputSimulator
        from simvx.graphics import save_png

        # The game opens on its title screen; dismiss it so the captures show
        # the board rather than three copies of the menu.
        root = ClaustrowordiaRoot()
        sim = InputSimulator(root)

        def on_frame(idx: int, _t: float) -> None:
            if idx == 5:
                sim.press_mouse(Mouse.LEFT, (WIDTH / 2, HEIGHT / 2))
            elif idx == 10:
                sim.release_mouse(Mouse.LEFT)

        capture_at = [30, 60, 120]
        app = App(width=WIDTH, height=HEIGHT, title="Claustrowordia (SimVX)", visible=False)
        frames = app.run_headless(root, frames=130, on_frame=on_frame, capture_frames=capture_at)
        out_dir = _PORT_DIR / "screenshots"
        out_dir.mkdir(exist_ok=True)
        for idx, img in zip(capture_at, frames, strict=False):
            out_path = out_dir / f"frame_{idx}.png"
            save_png(img, out_path)
            print(f"saved {out_path}")
    else:
        app = App(width=WIDTH, height=HEIGHT, title="Claustrowordia (SimVX)")
        app.run(ClaustrowordiaRoot())


if __name__ == "__main__":
    main()