spawnpoint-studio 0.1.0__py3-none-any.whl

tests/test_ai_sprites.py

@@ -0,0 +1,122 @@
+"""AI sprite providers against fake A1111 / OpenAI-images servers."""
+
+import base64
+import io
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+import numpy as np
+import pytest
+from PIL import Image, ImageDraw
+
+from spawnpoint.analyze import analyze
+from spawnpoint.sprites import ai
+from spawnpoint.sprites.generate import KINDS
+from spawnpoint.studio.assemble import assemble
+from spawnpoint.studio.brief import GameBrief, normalize
+
+from conftest import codes, minimal
+
+
+def fake_art() -> bytes:
+    img = Image.new("RGB", (512, 512), (255, 0, 255))
+    d = ImageDraw.Draw(img)
+    d.rectangle((180, 220, 330, 470), fill=(41, 120, 220))      # body
+    d.ellipse((170, 60, 340, 230), fill=(240, 190, 140))        # head
+    d.ellipse((280, 120, 310, 150), fill=(255, 255, 255))       # eye (white, inside the head)
+    buf = io.BytesIO()
+    img.save(buf, "PNG")
+    return buf.getvalue()
+
+
+@pytest.fixture
+def server():
+    calls = {"n": 0}
+    png = base64.b64encode(fake_art()).decode()
+
+    class H(BaseHTTPRequestHandler):
+        def log_message(self, *a):
+            pass
+
+        def do_POST(self):
+            calls["n"] += 1
+            self.rfile.read(int(self.headers["Content-Length"]))
+            body = {"images": [png]} if self.path.startswith("/sdapi") else {"data": [{"b64_json": png}]}
+            data = json.dumps(body).encode()
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(data)))
+            self.end_headers()
+            self.wfile.write(data)
+
+    httpd = ThreadingHTTPServer(("127.0.0.1", 0), H)
+    threading.Thread(target=httpd.serve_forever, daemon=True).start()
+    yield f"http://127.0.0.1:{httpd.server_port}", calls
+    httpd.shutdown()
+
+
+@pytest.fixture(autouse=True)
+def cache(tmp_path, monkeypatch):
+    monkeypatch.setattr(ai, "CACHE", tmp_path / "cache")
+    for k in ("SPAWNPOINT_IMAGE_PROVIDER", "SPAWNPOINT_IMAGE_URL"):
+        monkeypatch.delenv(k, raising=False)
+
+
+def test_background_removal_keeps_inner_white():
+    rgba = ai.remove_background(Image.open(io.BytesIO(fake_art())))
+    assert rgba[0, 0, 3] == 0 and rgba[300, 250, 3] == 255
+    assert rgba[135, 295, 3] == 255  # the white eye is enclosed by the head, so it stays opaque
+
+
+@pytest.mark.parametrize("provider_cls", ["a1111", "openai"])
+def test_ai_sprite_from_provider_and_cache(server, provider_cls):
+    url, calls = server
+    provider = ai.A1111Provider(url) if provider_cls == "a1111" else ai.OpenAIImagesProvider(url + "/v1", "k", "m")
+    s = ai.ai_sprite("Hero", "hero", "a tiny knight", provider, seed=1)
+    assert s.frame_size == KINDS["hero"].size
+    assert set(s.animations) == {"idle", "run", "jump", "fall", "hurt"}
+    assert len(s.polygon) >= 3
+    idle = s.frame(0, 0)
+    assert idle[0, 0, 3] == 0 and (idle[..., 3] > 0).sum() > 60
+    assert len({tuple(p) for p in idle[idle[..., 3] > 0][:, :3].tolist()}) <= 16  # small palette
+    ai.ai_sprite("Hero", "hero", "a tiny knight", provider, seed=1)
+    assert calls["n"] == 1  # second call came from the cache
+
+
+def test_graph_ai_sprite_uses_provider(server, monkeypatch, manifest):
+    url, calls = server
+    monkeypatch.setenv("SPAWNPOINT_IMAGE_PROVIDER", "a1111")
+    monkeypatch.setenv("SPAWNPOINT_IMAGE_URL", url)
+    g = minimal()
+    g["entities"]["Player"]["sprite"] = {"ai": {"prompt": "a tiny knight", "kind": "hero"}}
+    a = analyze(g, manifest)
+    assert a.ok and "W_AI_SPRITE" not in codes(a.diagnostics), [str(d) for d in a.diagnostics]
+    assert calls["n"] == 1 and "Player" in a.sprites
+
+
+@pytest.mark.parametrize("env", [{}, {"SPAWNPOINT_IMAGE_PROVIDER": "a1111", "SPAWNPOINT_IMAGE_URL": "http://127.0.0.1:9"}])
+def test_falls_back_to_generated_sprite(env, monkeypatch, manifest):
+    for k, v in env.items():
+        monkeypatch.setenv(k, v)
+    g = minimal()
+    g["entities"]["Player"]["sprite"] = {"ai": {"prompt": "a tiny knight", "kind": "hero"}}
+    a = analyze(g, manifest)
+    assert a.ok and "W_AI_SPRITE" in codes(a.diagnostics, "warning")
+    assert a.sprites["Player"].frame_size == KINDS["hero"].size
+
+
+def test_sprite_ref_needs_exactly_one_form(manifest):
+    g = minimal()
+    g["entities"]["Player"]["sprite"] = {"ai": {"prompt": "x", "kind": "hero"}, "generate": {"kind": "hero"}}
+    assert "E_SCHEMA" in codes(analyze(g, manifest).diagnostics)
+
+
+def test_studio_ai_art_flag():
+    b, _ = normalize(GameBrief.model_validate({"title": "Knight Run", "genre": "platformer",
+                                               "player": {"character": "Knight"},
+                                               "enemies": [{"name": "Slime", "archetype": "walker"}]}))
+    g = assemble(b, 2, 1, ai_art=True)
+    assert g["entities"]["Player"]["sprite"]["ai"]["prompt"].startswith("knight")
+    assert g["entities"]["Slime"]["sprite"]["ai"]["kind"] == "slime"
+    assert "generate" in assemble(b, 2, 1)["entities"]["Player"]["sprite"]

tests/test_analyze.py

@@ -0,0 +1,116 @@
+import pytest
+
+from spawnpoint.analyze import analyze
+
+from conftest import codes, minimal
+
+
+def test_examples_are_clean(manifest, platformer, topdown):
+    for g in (platformer, topdown):
+        a = analyze(g, manifest)
+        assert a.ok, [str(d) for d in a.diagnostics]
+        assert not a.diagnostics.warnings, [str(d) for d in a.diagnostics]
+
+
+def test_plan_shape(manifest):
+    a = analyze(minimal(), manifest)
+    assert a.ok, [str(d) for d in a.diagnostics]
+    plan = a.plan
+    player = next(e for e in plan["entities"] if e["name"] == "Player")
+    assert player["is_player"] and player["team"] == "player"
+    assert player["layer"] == 2 and player["mask"] == 1
+    assert player["pivot"] == "bottom"
+    names = [c["name"] for c in player["components"]]
+    assert names[-1] == "Juice"
+    hurtbox = next(c for c in player["components"] if c["name"] == "Hurtbox")
+    assert hurtbox["area_scale"] == pytest.approx(0.85)
+    # Player feet rest on the floor row (row 2 -> y = 64).
+    p = next(p for p in plan["placements"] if p["entity"] == "Player")
+    assert p["y"] + 14 == pytest.approx(64)  # default shape is 28 px tall
+    # Collectibles float at the cell center.
+    c = next(p for p in plan["placements"] if p["entity"] == "Coin")
+    assert c["y"] == pytest.approx(48)
+    assert plan["map"]["cells"][0] == [0, 2, "solid"]
+
+
+def test_juice_none_and_overrides(manifest):
+    g = minimal()
+    g["entities"]["Coin"]["juice"] = "none"
+    g["entities"]["Player"]["juice"] = {"shake_on_hurt": 0.9}
+    plan = analyze(g, manifest).plan
+    coin = next(e for e in plan["entities"] if e["name"] == "Coin")
+    assert "Juice" not in [c["name"] for c in coin["components"]]
+    player = next(e for e in plan["entities"] if e["name"] == "Player")
+    assert player["components"][-1]["params"] == {"shake_on_hurt": 0.9}
+    g["settings"] = {"juice": "none"}
+    plan = analyze(g, manifest).plan
+    assert all(c["name"] != "Juice" for e in plan["entities"] for c in e["components"])
+
+
+def _with(mutate):
+    g = minimal()
+    mutate(g)
+    return g
+
+
+def _player(g):
+    return g["entities"]["Player"]["components"]
+
+
+@pytest.mark.parametrize("mutate, code, hint", [
+    (lambda g: _player(g).update({"Helth": {}}), "E_UNKNOWN_COMPONENT", "Did you mean 'Health'?"),
+    (lambda g: _player(g)["Health"].update({"max_hp": 3}), "E_UNKNOWN_PARAM", "Did you mean 'max_health'?"),
+    (lambda g: _player(g)["Health"].update({"max_health": 0}), "E_PARAM_RANGE", None),
+    (lambda g: _player(g)["Health"].update({"max_health": 2.5}), "E_PARAM_TYPE", None),
+    (lambda g: _player(g)["PlatformerMovement"].update({"max_speed": "fast"}), "E_PARAM_TYPE", None),
+    (lambda g: g["entities"]["Coin"]["components"].update({"Gate": {}}), "E_HOST", None),
+    (lambda g: _player(g).pop("Health"), "E_REQUIRES", None),
+    (lambda g: _player(g).update({"Weapon": {"projectile": "Coin"}}), "E_NOT_PROJECTILE", None),
+    (lambda g: _player(g).update({"Weapon": {"projectile": "Bulet"}}), "E_ENTITY_REF", None),
+    (lambda g: _player(g).update({"Weapon": {}}), "E_ENTITY_REF", None),
+    (lambda g: _player(g).update({"TopDownMovement": {}}), "E_MOVEMENT", None),
+    (lambda g: _player(g).pop("PlayerInput"), "E_NO_PLAYER", None),
+    (lambda g: g["level"].update(map=["PP........", "##########"]), "E_PLAYER_PLACEMENT", None),
+    (lambda g: g["entities"].update({"slime": {}}), "E_ENTITY_NAME", None),
+    (lambda g: g["entities"].update({"Health": {}}), "E_ENTITY_NAME", None),
+    (lambda g: g["entities"]["Player"].update({"juice": {"shake": 1}}), "E_UNKNOWN_PARAM", None),
+    (lambda g: g["entities"]["Coin"].update({"shape": {"type": "none"}}) or g["entities"]["Coin"]["components"].update({"Hitbox": {}}), "E_SHAPE", None),
+])
+def test_entity_errors(manifest, mutate, code, hint):
+    a = analyze(_with(mutate), manifest)
+    assert not a.ok
+    assert code in codes(a.diagnostics, "error"), [str(d) for d in a.diagnostics]
+    if hint:
+        assert any(d.hint == hint for d in a.diagnostics.errors)
+
+
+def test_aim_mode_choice(manifest):
+    g = minimal()
+    _player(g).update({"Aim": {"mode": "mose"}})
+    _player(g).update({"Weapon": {"projectile": "Coin"}})
+    a = analyze(g, manifest)
+    err = next(d for d in a.diagnostics.errors if d.code == "E_PARAM_CHOICE")
+    assert err.hint == "Did you mean 'mouse'?"
+
+
+def test_warnings(manifest):
+    g = minimal(rules=[])
+    g["level"]["map"] = [".P........", ".........."]
+    a = analyze(g, manifest)
+    assert a.ok
+    assert set(codes(a.diagnostics, "warning")) >= {"W_NO_WIN", "W_NO_GROUND"}
+
+
+def test_genre_mismatch_warning(manifest):
+    g = minimal(genre="topdown")
+    a = analyze(g, manifest)
+    assert "W_GENRE" in codes(a.diagnostics, "warning")
+
+
+def test_topdown_plan(manifest, topdown):
+    plan = analyze(topdown, manifest).plan
+    assert plan["gravity"] == 0
+    assert plan["walls"] == ["left", "right", "top", "bottom"]
+    bullet = next(e for e in plan["entities"] if e["name"] == "Bullet")
+    assert bullet["layer"] == 0 and bullet["mask"] == 1
+    assert all(e["pivot"] == "center" for e in plan["entities"])

tests/test_cockpit.py

@@ -0,0 +1,148 @@
+"""Cockpit API against a live server (stdlib HTTP + SSE), with a scripted LLM."""
+
+import json
+import threading
+import urllib.error
+import urllib.request
+
+import pytest
+
+from spawnpoint import godot
+from spawnpoint.build import build
+from spawnpoint.cockpit.server import Cockpit, CockpitServer
+from spawnpoint.studio.llm import ScriptedModel
+from spawnpoint.studio import webcheck
+
+from conftest import load_example
+
+pytestmark = pytest.mark.skipif(not godot.available(), reason="Godot not installed")
+
+
+@pytest.fixture(scope="module")
+def workspace(tmp_path_factory):
+    ws = tmp_path_factory.mktemp("ws")
+    assert build(load_example("pixel_hopper.json"), ws / "pixel-hopper").ok
+    return ws
+
+
+@pytest.fixture
+def cockpit(workspace):
+    llm = {"model": None}
+    app = Cockpit(workspace, llm_factory=lambda: llm["model"], web_export=False)
+    srv = CockpitServer(app, 8095).start()
+    yield srv, app, llm
+    srv.stop()
+
+
+def get(srv, path):
+    with urllib.request.urlopen(srv.url.rstrip("/") + path, timeout=10) as r:
+        return r.status, r.read()
+
+
+def post(srv, path, body):
+    req = urllib.request.Request(srv.url.rstrip("/") + path, json.dumps(body).encode(),
+                                 {"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=10) as r:
+            return r.status, json.loads(r.read())
+    except urllib.error.HTTPError as e:
+        return e.code, json.loads(e.read())
+
+
+def test_static_and_projects(cockpit):
+    srv, _, _ = cockpit
+    code, html = get(srv, "/")
+    assert code == 200 and b"Spawn Point" in html
+    _, data = get(srv, "/api/projects")
+    (p,) = json.loads(data)
+    assert p["name"] == "pixel-hopper" and p["genre"] == "platformer" and not p["studio"]
+    _, data = get(srv, "/api/projects/pixel-hopper")
+    d = json.loads(data)
+    health = d["entities"]["Player"]["components"]["Health"]
+    mh = next(x for x in health["params"] if x["name"] == "max_health")
+    assert mh["value"] == 3 and mh["set"] and mh["min"] == 1
+    assert d["entities"]["Slime"]["sprite"] is True
+
+
+@pytest.mark.parametrize("path", ["/game/../../etc/passwd", "/api/projects/..", "/files/pixel-hopper/../spawnpoint.json",
+                                  "/files/pixel-hopper/rules/main_rules.gd", "/static/../server.py"])
+def test_paths_stay_inside(cockpit, path):
+    srv, _, _ = cockpit
+    with pytest.raises(urllib.error.HTTPError) as e:
+        get(srv, path)
+    assert e.value.code in (403, 404)
+
+
+def test_bad_requests(cockpit):
+    srv, _, _ = cockpit
+    assert post(srv, "/api/create", {"prompt": " "})[0] == 400
+    assert post(srv, "/api/projects/nope/tweak", {"request": "x"})[0] == 404
+    assert post(srv, "/api/projects/pixel-hopper/params", {"entity": "Player"})[0] == 400
+
+
+def test_param_edit_job_and_events(cockpit, workspace):
+    srv, app, _ = cockpit
+    events = []
+    ready = threading.Event()
+
+    def listen():
+        with urllib.request.urlopen(srv.url + "api/events", timeout=60) as r:
+            ready.set()
+            for raw in r:
+                line = raw.decode().strip()
+                if line.startswith("data: "):
+                    ev = json.loads(line[6:])
+                    events.append(ev)
+                    if ev["type"] in ("done", "error"):
+                        return
+
+    t = threading.Thread(target=listen, daemon=True)
+    t.start()
+    ready.wait(5)
+    code, job = post(srv, "/api/projects/pixel-hopper/params",
+                     {"entity": "Player", "component": "Health", "param": "max_health", "value": 5})
+    assert code == 202
+    done = app.jobs.wait(job["id"])
+    assert done.status == "done", done.error
+    t.join(10)
+    assert [e["type"] for e in events][-1] == "done"
+    graph = json.loads((workspace / "pixel-hopper" / "spawnpoint.json").read_text())
+    assert graph["entities"]["Player"]["components"]["Health"]["max_health"] == 5
+
+
+def test_invalid_param_is_rejected_before_building(cockpit):
+    srv, app, _ = cockpit
+    _, job = post(srv, "/api/projects/pixel-hopper/params",
+                  {"entity": "Player", "component": "Health", "param": "max_health", "value": 0})
+    done = app.jobs.wait(job["id"])
+    assert done.status == "error" and "outside" in done.error
+
+
+def test_entity_edit_repairs_and_creates_projectile(cockpit, workspace):
+    srv, app, llm = cockpit
+    bad = {"set_params": [{"component": "Health", "param": "max_hp", "value": 2}], "add_components": [], "add_rules": []}
+    good = {"set_params": [{"component": "Health", "param": "max_health", "value": 2}],
+            "add_components": [{"component": "Weapon", "params": [{"param": "projectile", "value": "Fireball"},
+                                                                  {"param": "auto_fire", "value": True}]}],
+            "add_rules": []}
+    llm["model"] = ScriptedModel([bad, good])
+    _, job = post(srv, "/api/projects/pixel-hopper/entity", {"entity": "Slime", "request": "tougher, shoots fire"})
+    done = app.jobs.wait(job["id"])
+    assert done.status == "done", done.error
+    assert done.result["rounds"] == 2
+    graph = json.loads((workspace / "pixel-hopper" / "spawnpoint.json").read_text())
+    slime = graph["entities"]["Slime"]["components"]
+    assert slime["Health"]["max_health"] == 2 and slime["Weapon"]["projectile"] == "Fireball"
+    assert "Bullet" not in graph["entities"]  # only entities that have a Weapon get projectiles
+    fireball = graph["entities"]["Fireball"]
+    assert "Projectile" in fireball["components"] and fireball["team"] == "enemy"
+
+
+def test_cockpit_page_in_browser(cockpit):
+    if webcheck.find_chrome() is None:
+        pytest.skip("Chrome not installed")
+    srv, _, _ = cockpit
+    res = webcheck.check(srv.url, seconds=4, size=(1400, 900),
+                         expression="[...document.querySelectorAll('#project-list li')].map(li => li.textContent)")
+    assert not res.errors, res.errors
+    assert res.value and "Pixel Hopper" in res.value[0]

tests/test_e2e.py

@@ -0,0 +1,33 @@
+"""End-to-end: build the examples with real Godot and smoke-run them."""
+
+import pytest
+
+from spawnpoint import godot
+from spawnpoint.build import build
+
+from conftest import load_example, minimal
+
+pytestmark = pytest.mark.skipif(not godot.available(), reason="Godot not installed")
+
+
+@pytest.mark.parametrize("example", ["coin_hopper.json", "neon_arena.json", "pixel_hopper.json"])
+def test_examples_build_and_run(tmp_path, example):
+    result = build(load_example(example), tmp_path / "game")
+    assert result.ok, "\n".join(str(d) for d in result.diagnostics) + "\n" + result.log[-2000:]
+    assert not result.diagnostics.warnings, [str(d) for d in result.diagnostics]
+    out = tmp_path / "game"
+    for f in ("project.godot", "levels/main.tscn", "levels/tiles.tres", "rules/main_rules.gd", "sfx/jump.wav"):
+        assert (out / f).exists(), f
+    smoke = result.smoke
+    assert smoke["player_found"] and smoke["player_alive"]
+    assert smoke["moved_px"] > 50
+    assert result.timings["total"] < 30
+
+
+def test_invalid_graph_never_reaches_godot(tmp_path):
+    g = minimal()
+    g["entities"]["Player"]["components"]["Helth"] = {}
+    result = build(g, tmp_path / "game")
+    assert not result.ok
+    assert not (tmp_path / "game").exists()
+    assert "godot_import" not in result.timings

tests/test_expr.py

@@ -0,0 +1,59 @@
+import pytest
+
+from spawnpoint.expr import ExprError, Scope, translate
+
+
+@pytest.fixture
+def scope(manifest):
+    return Scope(manifest, {"Player": ["Health", "PlatformerMovement"], "Coin": ["Collectible"]},
+                 {"by": "a_by"}, self_entity="Player")
+
+
+@pytest.mark.parametrize("src, expected", [
+    ("score >= 10", "(GameState.score >= 10)"),
+    ("0 < lives <= 3", "(0 < GameState.lives and GameState.lives <= 3)"),
+    ("vars.keys == 2 and not false", '((GameState.get_var("keys") == 2) and (not false))'),
+    ("count('Coin') == 0", '(World.count(&"Coin") == 0)'),
+    ("count(Coin) == 0", '(World.count(&"Coin") == 0)'),
+    ("score / 2 > 1.5", "((float(GameState.score) / 2) > 1.5)"),
+    ("score % 3 == 0", "(fposmod(GameState.score, 3) == 0)"),
+    ("self.Health.current < 2", '(SP.component(source, &"Health").current < 2)'),
+    ("score > 1 && lives > 0 || !true", "(((GameState.score > 1) and (GameState.lives > 0)) or (not true))"),
+    ("event.by != null", "(a_by != null)"),
+])
+def test_translations(scope, src, expected):
+    assert translate(src, scope) == expected
+
+
+def test_exclamation_inside_strings_is_kept(scope):
+    assert translate("str('Win!') == 'Win!'", scope) == '(str("Win!") == "Win!")'
+
+
+@pytest.mark.parametrize("src, fragment", [
+    ("__import__('os')", "not allowed"),
+    ("score.real", "not allowed"),
+    ("Player > 1", "entity type"),
+    ("scroe > 1", "unknown name"),
+    ("event.nope", "no argument"),
+    ("self.Health.hp", "no property"),
+    ("self.Gate.is_open", "no component"),
+    ("count('Nope')", "unknown entity"),
+    ("[1, 2]", "not allowed"),
+    ("score ** 2", "not supported"),
+])
+def test_rejections(scope, src, fragment):
+    with pytest.raises(ExprError) as e:
+        translate(src, scope)
+    assert fragment in str(e.value)
+
+
+def test_typo_hint(scope):
+    with pytest.raises(ExprError) as e:
+        translate("scroe > 1", scope)
+    assert e.value.hint == "Did you mean 'score'?"
+
+
+def test_self_unavailable(manifest):
+    s = Scope(manifest, {}, {}, None)
+    with pytest.raises(ExprError, match="not available"):
+        translate("self.Health.current", s)

tests/test_gif.py

@@ -0,0 +1,19 @@
+from PIL import Image
+
+from spawnpoint.gif import make_gif
+
+
+def test_make_gif_shared_palette_and_size(tmp_path):
+    frames = []
+    for i in range(6):
+        im = Image.new("RGB", (960, 540), (29, 43, 83))
+        im.paste((255, 0, 77), (100 + i * 40, 200, 160 + i * 40, 260))
+        path = tmp_path / f"frame_{i:04d}.png"
+        im.save(path)
+        frames.append(path)
+    out = make_gif(frames, tmp_path / "demo.gif", fps=20, width=480)
+    gif = Image.open(out)
+    assert gif.size == (480, 270)
+    assert gif.n_frames == 6
+    assert gif.info["duration"] == 50
+    assert gif.info["loop"] == 0

tests/test_godot_library.py

@@ -0,0 +1,17 @@
+"""Runs the GDScript component test-suite (godot/tests) so `pytest` covers everything."""
+
+import pytest
+
+from spawnpoint import godot
+from spawnpoint.manifest import LIBRARY_PROJECT
+
+pytestmark = pytest.mark.skipif(not godot.available(), reason="Godot not installed")
+
+
+def test_component_library_suite():
+    godot.import_project(LIBRARY_PROJECT)
+    result = godot.run_scene(LIBRARY_PROJECT, "res://tests/run_tests.tscn", fixed_fps=60, check=False, timeout=300)
+    summary = [ln for ln in result.output.splitlines() if "tests," in ln]
+    assert result.returncode == 0, result.output[-4000:]
+    assert summary and summary[-1].endswith(", 0 failures"), result.output[-4000:]
+    assert not result.script_errors, result.script_errors

tests/test_graph.py

@@ -0,0 +1,44 @@
+from spawnpoint.graph import parse
+
+from conftest import minimal
+
+
+def test_minimal_graph_parses():
+    g, d = parse(minimal())
+    assert g is not None and d.ok
+    assert g.settings.tile_size == 32
+    assert g.entities["Player"].body == "character"
+
+
+def test_unknown_field_gets_typo_hint():
+    data = minimal()
+    data["entities"]["Player"]["compnents"] = {}
+    g, d = parse(data)
+    assert g is None
+    (err,) = d.errors
+    assert err.path == "entities.Player.compnents"
+    assert err.hint == "Did you mean 'components'?"
+
+
+def test_missing_required_field():
+    data = minimal()
+    del data["genre"]
+    _, d = parse(data)
+    assert any(e.message == "missing required field 'genre'" for e in d.errors)
+
+
+def test_bad_color_and_genre():
+    data = minimal(genre="rpg")
+    data["entities"]["Player"]["shape"] = {"color": "blue"}
+    _, d = parse(data)
+    paths = {e.path for e in d.errors}
+    assert "genre" in paths
+    assert any(p.startswith("entities.Player.shape.color") for p in paths)
+
+
+def test_rule_if_alias():
+    data = minimal(rules=[{"on": "Exit.triggered", "if": "score > 1", "do": "win()"}])
+    g, d = parse(data)
+    assert d.ok
+    assert g.rules[0].if_ == "score > 1"
+    assert g.rules[0].actions == ["win()"]

tests/test_level.py

@@ -0,0 +1,64 @@
+from spawnpoint.diagnostics import Diagnostics
+from spawnpoint.graph import Level
+from spawnpoint.level import Placement, jump_model, parse_level, unreachable
+
+
+def parse(rows, legend, entities=("Player", "Coin")):
+    d = Diagnostics()
+    data = parse_level(Level(map=rows, legend=legend), set(entities), d)
+    return data, d
+
+
+def test_tiles_and_placements():
+    data, d = parse(["P.C", "#=#"], {"#": "solid", "=": "oneway", "P": "Player", "C": "Coin"})
+    assert d.ok
+    assert data.tiles == {(0, 1): "solid", (1, 1): "oneway", (2, 1): "solid"}
+    assert [(p.entity, p.x, p.y) for p in data.placements] == [("Player", 0, 0), ("Coin", 2, 0)]
+
+
+def test_ragged_rows_are_padded():
+    data, d = parse(["P", "###"], {"#": "solid", "P": "Player"})
+    assert d.ok and data.width == 3
+
+
+def test_unknown_char_reported_once_with_positions():
+    _, d = parse(["P.X.X", "#####"], {"#": "solid", "P": "Player"})
+    (err,) = d.errors
+    assert err.code == "E_MAP_CHAR" and "(2,0), (4,0)" in err.message
+
+
+def test_bad_legend_value_hint():
+    _, d = parse(["P", "#"], {"#": "solidd", "P": "Player"})
+    assert d.errors[0].hint == "Did you mean 'solid'?"
+
+
+def test_reserved_legend_key():
+    _, d = parse(["P", "#"], {"#": "solid", ".": "Coin", "P": "Player"})
+    assert d.errors[0].code == "E_LEGEND_KEY"
+
+
+def test_reachability():
+    rows = [
+        "..........C",  # far above anything the player can stand on
+        "...........",
+        "...........",
+        "...........",
+        "...........",
+        "......C....",
+        "...........",
+        "....===....",
+        "...........",
+        ".P.........",
+        "###########",
+    ]
+    data, d = parse(rows, {"#": "solid", "=": "oneway", "P": "Player", "C": "Coin"})
+    jm = jump_model(620, 1600, 1.7, 230, 32, 34)
+    coins = [p for p in data.placements if p.entity == "Coin"]
+    missing = unreachable(data, (1, 9), coins, jm)
+    assert missing == [Placement("Coin", 10, 0)]
+
+
+def test_double_jump_extends_reach():
+    single = jump_model(620, 1600, 1.7, 230, 32, 34)
+    double = jump_model(620, 1600, 1.7, 230, 32, 34, air_jumps=1)
+    assert double.up > single.up

tests/test_live_llm.py

@@ -0,0 +1,38 @@
+"""End-to-end with the real LLM server (skipped when it is not running). Slow: ~1 min."""
+
+import json
+import urllib.request
+
+import pytest
+
+from spawnpoint.studio.llm import OpenAICompatible
+from spawnpoint.studio.orchestrator import create, load_session, tweak
+
+
+def _llm_up() -> bool:
+    try:
+        urllib.request.urlopen(OpenAICompatible().base_url.rstrip("/") + "/models", timeout=2)
+        return True
+    except Exception:
+        return False
+
+
+pytestmark = [pytest.mark.llm, pytest.mark.skipif(not _llm_up(), reason="LLM server not running")]
+
+
+def test_create_then_tweak_vietnamese(tmp_path, manifest):
+    out = tmp_path / "game"
+    llm = OpenAICompatible()
+    res = create("game nhảy bục, nhân vật là ninja, ăn sao để qua màn", out, llm, web_export=False,
+                 manifest=manifest)
+    assert res.ok
+    assert res.brief.genre == "platformer"
+    assert res.brief.collectible.count > 0
+    before = load_session(out)["brief"]
+
+    res2 = tweak(out, "nhảy cao hơn 20%", llm, web_export=False, manifest=manifest)
+    assert res2.ok
+    after = load_session(out)["brief"]
+    assert after["player"]["jump_tiles"] > before["player"]["jump_tiles"]
+    unchanged = {k for k in before if before[k] == after[k]}
+    assert {"genre", "enemies", "goal", "length"} <= unchanged, json.dumps(res2.changes)