spawnpoint-studio 0.1.0__py3-none-any.whl

tests/test_manifest.py

@@ -0,0 +1,54 @@
+import json
+
+import pytest
+
+from spawnpoint import godot, manifest as manifest_mod
+from spawnpoint.manifest import parse_docs
+
+SOURCE = '''class_name FooComponent
+extends Node
+## Does foo.
+## Second line.
+
+const SP_NAME := "Foo"
+
+## Fired on foo.
+signal fooed(amount: int)
+
+## How much foo.
+@export_range(0, 10) var amount: int = 3
+var _private := 1
+
+
+## Foos now.
+func foo() -> void:
+	pass
+'''
+
+
+def test_parse_docs():
+    docs = parse_docs(SOURCE)
+    assert docs["@class"] == "Does foo. Second line."
+    assert docs["fooed"] == "Fired on foo."
+    assert docs["amount"] == "How much foo."
+    assert docs["foo"] == "Foos now."
+    assert "_private" not in docs
+
+
+def test_manifest_contents(manifest):
+    pm = manifest.get("PlatformerMovement")
+    assert pm.hosts == ["CharacterBody2D"]
+    assert pm.params["coyote_time"].max == 0.5
+    assert "step_velocity" not in pm.methods  # internal
+    assert pm.signals["landed"].args[0].name == "impact_speed"
+    assert manifest.get("Aim").params["mode"].choices == ("mouse", "nearest_enemy", "movement")
+    assert manifest.get("Health").state["current"] == "int"
+    assert all(c.doc for c in manifest.components.values())
+    assert all(p.doc for c in manifest.components.values() for p in c.params.values())
+
+
+@pytest.mark.skipif(not godot.available(), reason="Godot not installed")
+def test_manifest_is_up_to_date(tmp_path):
+    fresh = manifest_mod.generate(out=tmp_path / "manifest.json")
+    committed = json.loads(manifest_mod.MANIFEST_PATH.read_text())
+    assert fresh == committed, "manifest.json is stale: run `spawnpoint manifest`"

tests/test_playtest.py

@@ -0,0 +1,129 @@
+import json
+
+import pytest
+from PIL import Image
+
+from spawnpoint import godot
+from spawnpoint.build import build
+from spawnpoint.playtest import goal_entities, merge_tuning, playtest
+from spawnpoint.playtest.report import aggregate, heatmap, markdown
+from spawnpoint.playtest.runner import time_limit
+from spawnpoint.playtest.tuner import Change, propose, score, targets
+
+from conftest import load_example
+
+
+def run(profile, outcome="won", deaths=(), missed=0, intended=10, collected=5, total=5, unreachable=()):
+    return {"profile": profile, "run": 0, "outcome": outcome, "time": 20.0, "score": 0, "lives_left": 1,
+            "deaths": [{"x": x, "y": 5, "cause": c, "t": 1.0, "after_jump": aj} for c, x, aj in deaths],
+            "damage": [], "stuck": [], "unreachable": list(unreachable),
+            "jumps": {"intended": intended, "performed": intended - missed, "missed": [{"x": 0, "y": 0}] * missed},
+            "pickups": {"total": total, "collected": collected}}
+
+
+def graph():
+    g = load_example("pixel_hopper.json")
+    return json.loads(json.dumps(g))
+
+
+def test_aggregate_and_markdown():
+    rep = aggregate([run("novice", "lost", [("Spikes", 3, False), ("Spikes", 4, False), ("fall", 9, True)], missed=4),
+                     run("novice"), run("expert")])
+    n = rep.get("novice")
+    assert n.win_rate == 0.5 and n.deaths == 3 and n.causes == {"Spikes": 2, "fall": 1}
+    assert n.falls_after_jump == 1 and n.missed_rate == 0.2
+    md = markdown(rep, "Test", ["Player.Health.max_health = 4 — reason"])
+    assert "| novice | 1/2 |" in md and "Tuning applied" in md
+
+
+def test_level_issues_only_for_goal_entities():
+    u = [{"entity": "Coin", "x": 3, "y": 2, "reason": "no_path"}, {"entity": "Slime", "x": 9, "y": 2, "reason": "no_path"}]
+    rep = aggregate([run("expert", "timeout", unreachable=u)], {"Coin"})
+    assert rep.level_issues == ["Coin at (3,2) has no path from the player",
+                                "even the expert bot never won — the goal may be impossible or the time too short"]
+
+
+def test_targets_and_score():
+    assert targets(1)["novice"] == 0.8 and targets(5)["novice"] == 0.3
+    good = aggregate([run("novice"), run("average"), run("expert")])
+    bad = aggregate([run("novice", "lost"), run("average", "lost"), run("expert")])
+    assert score(good, 2) == 0 and score(bad, 2) > 1
+
+
+def test_rule_missed_jumps_raise_coyote_and_buffer(manifest):
+    g = graph()
+    rep = aggregate([run("novice", missed=5, intended=10), run("average")])
+    changes = {(c.entity, c.param): c.value for c in propose(rep, g, g, manifest)}
+    assert changes[("Player", "coyote_time")] == pytest.approx(0.14)
+    assert changes[("Player", "jump_buffer")] == pytest.approx(0.16)
+
+
+def test_rule_dominant_enemy_slows_down(manifest):
+    g = graph()
+    rep = aggregate([run("novice", "lost", [("Slime", 3, False)] * 3), run("average", "lost", [("Slime", 4, False)])])
+    changes = {(c.entity, c.component, c.param): c.value for c in propose(rep, g, g, manifest)}
+    assert changes[("Slime", "PlatformerMovement", "max_speed")] == pytest.approx(51.0)
+    assert changes[("Player", "Health", "max_health")] == 4
+
+
+def test_rule_spikes_shrink_hurtbox_and_bounds(manifest):
+    g = graph()
+    g["entities"]["Player"]["components"]["Hurtbox"] = {"size_scale": 0.6}
+    rep = aggregate([run("novice", "lost", [("Spikes", 3, False)] * 3), run("average", "lost", [("Spikes", 3, False)])])
+    keys = {(c.entity, c.component, c.param) for c in propose(rep, g, g, manifest)}
+    assert ("Player", "Hurtbox", "size_scale") not in keys  # already at the floor
+
+
+def test_rule_bullets_lower_fire_rate(manifest):
+    g = load_example("pixel_arena.json")
+    rep = aggregate([run("novice", "lost", [("EnemyBullet", 3, False)] * 3), run("average", "lost", [("EnemyBullet", 3, False)])])
+    changes = {(c.entity, c.param): c.value for c in propose(rep, g, g, manifest)}
+    assert changes[("Shooter", "fire_rate")] == pytest.approx(1.3 * 0.85, abs=0.01)
+
+
+def test_rule_too_easy_only_on_hard_games(manifest):
+    g = graph()
+    rep = aggregate([run("novice"), run("novice"), run("average"), run("expert")])
+    assert propose(rep, g, g, manifest, difficulty=2) == []
+    hard = {(c.entity, c.param) for c in propose(rep, g, g, manifest, difficulty=4)}
+    assert ("Slime", "max_speed") in hard and ("Frog", "max_speed") in hard
+
+
+def test_bounds_are_relative_to_the_original(manifest):
+    original = graph()
+    tuned = graph()
+    tuned["entities"]["Slime"]["components"]["PlatformerMovement"]["max_speed"] = 31
+    rep = aggregate([run("novice", "lost", [("Slime", 3, False)] * 3), run("average", "lost", [("Slime", 3, False)])])
+    c = next(c for c in propose(rep, tuned, original, manifest) if c.entity == "Slime")
+    assert c.value == 30  # floor: 50% of the original 60
+
+
+def test_merge_tuning_latest_wins():
+    old = [{"entity": "Player", "component": "Health", "param": "max_health", "value": 4}]
+    new = merge_tuning(old, [Change("Player", "Health", "max_health", 5, "r"), Change("Slime", "PatrolAI", "speed_scale", 0.8, "r")])
+    assert {(t["entity"], t["value"]) for t in new} == {("Player", 5), ("Slime", 0.8)}
+
+
+def test_time_limit_and_goal_entities():
+    g = graph()
+    assert 45 <= time_limit(g) <= 240
+    assert time_limit(load_example("pixel_arena.json"), {"goal": "survive", "survive_seconds": 120}) == 135
+    assert goal_entities(g) == {"Coin", "Heart", "Exit"}
+
+
+def test_heatmap_renders(tmp_path, manifest):
+    from spawnpoint.analyze import analyze
+    plan = analyze(graph(), manifest).plan
+    out = heatmap(plan, [run("novice", "lost", [("Spikes", 3, False), ("fall", 20, True)])], tmp_path / "h.png")
+    img = Image.open(out)
+    assert img.width == plan["map"]["width"] * 12
+
+
+@pytest.mark.skipif(not godot.available(), reason="Godot not installed")
+def test_playtest_end_to_end(tmp_path):
+    out = tmp_path / "game"
+    assert build(load_example("pixel_hopper.json"), out).ok
+    res = playtest(out, runs=1, profiles=("expert",))
+    exp = res.final.get("expert")
+    assert exp.runs == 1 and exp.wins == 1, res.final.to_dict()["profiles"]
+    assert (out / "playtest" / "heatmap.png").exists() and (out / "playtest" / "report.md").exists()

tests/test_rules.py

@@ -0,0 +1,85 @@
+import pytest
+
+from spawnpoint.diagnostics import Diagnostics
+from spawnpoint.expr import ExprError
+from spawnpoint.graph import Rule
+from spawnpoint.rules import compile_rules, resolve_event
+
+ENTITIES = {
+    "Player": ["PlatformerMovement", "PlayerInput", "Health", "Hurtbox", "Stomp"],
+    "Slime": ["PlatformerMovement", "PatrolAI", "Health", "Hurtbox", "Hitbox"],
+    "Coin": ["Collectible"],
+    "Door": ["Gate"],
+    "Exit": ["TriggerZone"],
+}
+
+
+def run(manifest, *rules):
+    d = Diagnostics()
+    res = compile_rules([Rule.model_validate(r) for r in rules], ENTITIES, manifest, d)
+    return res, d
+
+
+def test_short_event_resolves_unique_component(manifest):
+    ev = resolve_event("Coin.collected", ENTITIES, manifest)
+    assert (ev.component, ev.signal, ev.args) == ("Collectible", "collected", ["by"])
+
+
+def test_ambiguous_event(manifest):
+    with pytest.raises(ExprError) as e:
+        resolve_event("Slime.dashed", {"Slime": ["PlatformerMovement", "TopDownMovement"]}, manifest)
+    assert "ambiguous" in str(e.value)
+    assert "Slime.PlatformerMovement.dashed" in e.value.hint
+
+
+def test_unknown_signal_lists_available(manifest):
+    with pytest.raises(ExprError) as e:
+        resolve_event("Door.open", ENTITIES, manifest)
+    assert "Door.opened" in e.value.hint
+
+
+def test_codegen(manifest):
+    res, d = run(manifest,
+                 {"on": "Coin.collected", "if": "count('Coin') == 0", "do": ["Door.open()", "message('Open!')"]},
+                 {"on": "Slime.died", "do": ["add_score(5)", "spawn('Coin')"]},
+                 {"on": "Game.ready", "do": "message('Go')"},
+                 {"on": "GameState.score_changed", "if": "event.score >= 3", "do": ["win()"]},
+                 {"on": "Coin.collected", "do": ["event.by.Health.heal(1)"]})
+    assert d.ok, [str(x) for x in d]
+    src = res.source
+    assert res.calls_win
+    assert 'World.bind_signal(&"Coin", &"Collectible", &"collected", _rule_0)' in src
+    assert "func _rule_0(_a_by, _source) -> void:" in src
+    assert 'World.call_all(&"Door", &"Gate", &"open", [])' in src
+    assert 'World.spawn.call_deferred("Coin", source.global_position)' in src
+    assert "func _rule_1(source) -> void:" in src
+    assert "GameState.score_changed.connect(_rule_3)" in src
+    assert "func _rule_3(a_score) -> void:" in src
+    assert "_on_game_ready.call_deferred()" in src
+    assert 'World.call_on(a_by, &"Health", &"heal", [1])' in src
+
+
+@pytest.mark.parametrize("rule, code, fragment", [
+    ({"on": "Coin.colected", "do": ["win()"]}, "E_RULE_EVENT", "Did you mean"),
+    ({"on": "Ghost.died", "do": ["win()"]}, "E_RULE_EVENT", "unknown entity"),
+    ({"on": "Exit.triggered", "do": ["wn()"]}, "E_RULE_DO", "unknown action"),
+    ({"on": "Exit.triggered", "do": ["Door.opne()"]}, "E_RULE_DO", "no method"),
+    ({"on": "Exit.triggered", "do": ["Door.Gate.open(1)"]}, "E_RULE_DO", "argument"),
+    ({"on": "Exit.triggered", "do": ["Coin.Gate.open()"]}, "E_RULE_DO", "no component"),
+    ({"on": "Game.ready", "do": ["spawn('Coin')"]}, "E_RULE_DO", "has none"),
+    ({"on": "Game.ready", "do": ["destroy(self)"]}, "E_RULE_DO", "not available"),
+    ({"on": "Exit.triggered", "if": "scor > 1", "do": ["win()"]}, "E_RULE_IF", "unknown name"),
+    ({"on": "Exit.triggered", "do": ["set_var(x, 1)"]}, "E_RULE_DO", "quotes"),
+    ({"on": "Exit.triggered", "do": ["win"]}, "E_RULE_DO", "must be a call"),
+])
+def test_rule_errors(manifest, rule, code, fragment):
+    _, d = run(manifest, rule)
+    assert not d.ok
+    err = d.errors[0]
+    assert err.code == code
+    assert fragment in (err.message + " " + (err.hint or ""))
+
+
+def test_error_paths_point_at_action(manifest):
+    _, d = run(manifest, {"on": "Exit.triggered", "do": ["win()", "nope()"]})
+    assert d.errors[0].path == "rules[0].do[1]"

tests/test_sfx.py

@@ -0,0 +1,30 @@
+import wave
+
+from spawnpoint import sfx
+
+
+def test_presets_are_deterministic():
+    a = sfx.synthesize(sfx.preset("coin", 3), seed=3)
+    b = sfx.synthesize(sfx.preset("coin", 3), seed=3)
+    assert a == b
+    assert sfx.preset("coin", 3) != sfx.preset("coin", 4)
+
+
+def test_all_presets_render_audible_short_sounds(tmp_path):
+    files = sfx.write_all(tmp_path, seed=1)
+    assert {f.stem for f in files} == set(sfx.PRESETS)
+    for f in files:
+        with wave.open(str(f)) as w:
+            assert w.getframerate() == sfx.SAMPLE_RATE and w.getsampwidth() == 2
+            seconds = w.getnframes() / w.getframerate()
+            assert 0.02 < seconds <= 2.0, f.name
+            frames = w.readframes(w.getnframes())
+        peak = max(abs(int.from_bytes(frames[i:i + 2], "little", signed=True)) for i in range(0, len(frames), 2))
+        assert peak > 8000, f"{f.name} is too quiet"
+
+
+def test_write_all_skips_unchanged(tmp_path):
+    sfx.write_all(tmp_path, seed=1, names=["jump"])
+    mtime = (tmp_path / "jump.wav").stat().st_mtime_ns
+    sfx.write_all(tmp_path, seed=1, names=["jump"])
+    assert (tmp_path / "jump.wav").stat().st_mtime_ns == mtime

tests/test_sprites.py

@@ -0,0 +1,261 @@
+import json
+
+import numpy as np
+import pytest
+from PIL import Image
+
+from spawnpoint.analyze import analyze
+from spawnpoint.sprites import contour, importer
+from spawnpoint.sprites.generate import KINDS, features_for, generate
+from spawnpoint.sprites.resolve import convex_hull, plan_entry, safe_polygon
+from spawnpoint.sprites.spriteset import SpriteError, load
+from spawnpoint.studio.assemble import sprite_kind
+from spawnpoint.studio.brief import GameBrief
+
+from conftest import codes, load_example, minimal
+
+
+def rgba(mask: np.ndarray) -> np.ndarray:
+    img = np.zeros((*mask.shape, 4), np.uint8)
+    img[mask] = (255, 0, 0, 255)
+    return img
+
+
+# --- contour ----------------------------------------------------------------------------------
+
+def test_contour_of_rectangle_is_exact():
+    m = np.zeros((8, 8), bool)
+    m[2:6, 1:7] = True
+    assert contour.outline(rgba(m)) == [(1.0, 2.0), (7.0, 2.0), (7.0, 6.0), (1.0, 6.0)]
+    assert contour.bounds(m) == (1, 2, 6, 4)
+
+
+def test_contour_circle_area_and_detached_detail():
+    yy, xx = np.mgrid[:20, :20]
+    m = ((yy - 10) ** 2 + (xx - 10) ** 2) <= 49
+    m[2, 10] = True  # antenna tip one pixel above the head
+    poly = contour.outline(rgba(m))
+    assert abs(abs(contour.polygon_area(poly)) - np.pi * 49) < 15
+    assert min(y for _, y in poly) == 2.0  # merged into the outline
+
+
+def test_contour_empty():
+    assert contour.outline(np.zeros((4, 4, 4), np.uint8)) == []
+
+
+def test_safe_polygon_falls_back_to_hull_for_self_intersections():
+    bowtie = [(0, 0), (4, 4), (4, 0), (0, 4)]
+    assert sorted(safe_polygon(bowtie)) == sorted(convex_hull(bowtie)) == [(0, 0), (0, 4), (4, 0), (4, 4)]
+    square = [(0, 0), (4, 0), (4, 4), (0, 4)]
+    assert safe_polygon(square) == square
+
+
+# --- generator --------------------------------------------------------------------------------
+
+@pytest.mark.parametrize("kind", sorted(KINDS))
+def test_every_kind_renders(kind):
+    s = generate("Thing", kind, "#ff004d")
+    assert "idle" in s.animations
+    w, h = s.frame_size
+    for name, a in s.animations.items():
+        for col, row in a.frames:
+            assert (s.frame(col, row)[..., 3] > 0).any(), f"{kind}.{name} frame empty"
+    bx, by, bw, bh = s.bounds
+    assert 0 <= bx and 0 <= by and bx + bw <= w and by + bh <= h
+    assert len(s.polygon) >= 3
+    assert generate("Thing", kind, "#ff004d").sheet.tobytes() == s.sheet.tobytes()  # deterministic
+
+
+def test_features_from_names():
+    assert features_for("NinjaFox") == ["mask", "ears", "tail"]
+    assert features_for("fire bat") == ["wings"]
+    assert features_for("Player") == []
+
+
+def test_names_change_the_look():
+    a = generate("Goblin", "hero", "#ff004d").sheet.tobytes()
+    b = generate("Ninja", "hero", "#ff004d").sheet.tobytes()
+    assert a != b
+
+
+# --- import -----------------------------------------------------------------------------------
+
+@pytest.fixture
+def art(tmp_path):
+    """An artist-style sheet (4 columns, 2px spacing) and a folder of frames, from a generated knight."""
+    s = generate("Knight", "hero", "#c2c3c7", ["helmet"])
+    cells = [s.frame(*f) for a in ("idle", "run") for f in s.animations[a].frames]  # 2 idle + 4 run
+    sheet = Image.new("RGBA", (4 * 26, 2 * 26))
+    for i, f in enumerate(cells):
+        sheet.paste(Image.fromarray(f), ((i % 4) * 26 + 6, (i // 4) * 26 + 4))
+    sheet.save(tmp_path / "knight.png")
+    frames = tmp_path / "frames"
+    frames.mkdir()
+    for a, fname in (("idle", "idle"), ("run", "walk")):
+        for i, f in enumerate(s.animations[a].frames):
+            Image.fromarray(s.frame(*f)).save(frames / f"knight_{fname}_{i}.png")
+    return tmp_path
+
+
+def test_parse_ranges():
+    assert importer.parse_ranges("0-3, 7,9-10") == [0, 1, 2, 3, 7, 9, 10]
+
+
+def test_import_grid_with_indices(art):
+    s = importer.import_sheet(art / "knight.png", grid=(24, 24), spacing=2, anims={"idle": [0, 1], "run": [2, 3, 4, 5]})
+    assert s.frame_size == (24, 24)
+    assert {k: len(a.frames) for k, a in s.animations.items()} == {"idle": 2, "run": 4}
+    assert s.name == "Knight"
+
+
+def test_import_grid_rejects_empty_frames(art):
+    with pytest.raises(SpriteError, match="empty frame"):
+        importer.import_sheet(art / "knight.png", grid=(24, 24), spacing=2, anims={"run": [4, 5, 6, 7]})
+
+
+def test_import_grid_rejects_out_of_range(art):
+    with pytest.raises(SpriteError, match="has 8 frames"):
+        importer.import_sheet(art / "knight.png", grid=(24, 24), spacing=2, anims={"idle": [0, 99]})
+
+
+def test_import_auto_slices_by_gutters(art):
+    s = importer.import_sheet(art / "knight.png")
+    # Rows become animations in standard order; frames are trimmed and bottom-aligned.
+    assert [len(a.frames) for a in s.animations.values()] == [4, 2]
+    assert list(s.animations) == ["idle", "run"]
+    w, h = s.frame_size
+    assert w < 24 and h <= 24
+
+
+def test_import_folder_groups_and_maps_synonyms(art):
+    s = importer.import_folder(art / "frames")
+    assert {k: len(a.frames) for k, a in s.animations.items()} == {"idle": 2, "run": 4}
+    assert s.animations["run"].fps == 10.0
+
+
+def test_save_load_roundtrip_and_preview(art, tmp_path):
+    s = importer.import_folder(art / "frames", "Knight")
+    path = s.save(tmp_path / "lib")
+    back = load(path)
+    assert back.frame_size == s.frame_size and back.polygon == s.polygon and back.bounds == s.bounds
+    img = importer.preview(back)
+    assert img.width > 100 and img.height > 50
+
+
+def test_load_errors(tmp_path):
+    with pytest.raises(SpriteError, match="cannot read"):
+        load(tmp_path / "nope.sprite.json")
+    Image.new("RGBA", (8, 8), (255, 0, 0, 255)).save(tmp_path / "a.png")
+    (tmp_path / "a.sprite.json").write_text(json.dumps({
+        "image": "a.png", "frame_size": [8, 8], "animations": {"idle": {"frames": [[1, 0]]}}}))
+    with pytest.raises(SpriteError, match="outside"):
+        load(tmp_path / "a.sprite.json")
+
+
+# --- compiler integration ---------------------------------------------------------------------
+
+def test_generated_sprite_derives_collision_and_plan(manifest):
+    g = minimal()
+    g["entities"]["Player"]["sprite"] = {"generate": {"kind": "hero"}}
+    g["entities"]["Coin"]["sprite"] = {"generate": {"kind": "coin"}}
+    a = analyze(g, manifest)
+    assert a.ok, [str(d) for d in a.diagnostics]
+    player = next(e for e in a.plan["entities"] if e["name"] == "Player")
+    s = a.sprites["Player"]
+    assert player["shape"]["type"] == "capsule"
+    assert player["shape"]["size"][1] == s.bounds[3] * s.scale
+    assert player["sprite"]["texture"] == "res://sprites/Player.png"
+    assert "Animator" in [c["name"] for c in player["components"]]
+    assert player["eye"] is False
+    # Feet still rest on the floor row.
+    p = next(p for p in a.plan["placements"] if p["entity"] == "Player")
+    assert p["y"] + player["shape"]["size"][1] / 2 == pytest.approx(64)
+
+
+def test_plan_entry_centers_the_opaque_box():
+    s = generate("Coin", "coin", "#ffec27")
+    e = plan_entry("Coin", s)
+    bx, by, bw, bh = s.bounds
+    xs = [p[0] for p in e["polygon"]]
+    ys = [p[1] for p in e["polygon"]]
+    assert min(xs) == pytest.approx(-bw, abs=bw) and max(xs) <= bw * s.scale / 2 + 0.01
+    assert min(ys) >= -bh * s.scale / 2 - 0.01 and max(ys) <= bh * s.scale / 2 + 0.01
+
+
+def test_explicit_shape_wins(manifest):
+    g = minimal()
+    g["entities"]["Player"]["sprite"] = {"generate": {"kind": "hero"}}
+    g["entities"]["Player"]["shape"] = {"type": "rect", "size": [20, 20]}
+    plan = analyze(g, manifest).plan
+    player = next(e for e in plan["entities"] if e["name"] == "Player")
+    assert player["shape"] == {"type": "rect", "size": [20.0, 20.0], "color": "#29adff"}
+
+
+@pytest.mark.parametrize("sprite, fragment", [
+    ({"generate": {"kind": "dragon"}}, "unknown sprite kind"),
+    ("art/hero.sprite.json", "needs the graph's folder"),
+])
+def test_sprite_errors(manifest, sprite, fragment):
+    g = minimal()
+    g["entities"]["Player"]["sprite"] = sprite
+    a = analyze(g, manifest)
+    err = next(d for d in a.diagnostics.errors if d.code == "E_SPRITE")
+    assert fragment in err.message and err.path == "entities.Player.sprite"
+
+
+def test_sprite_path_relative_to_graph(manifest, tmp_path):
+    generate("Hero", "hero", "#29adff").save(tmp_path / "art", "hero")
+    g = minimal()
+    g["entities"]["Player"]["sprite"] = "art/hero.sprite.json"
+    assert analyze(g, manifest, base_dir=tmp_path).ok
+    g["entities"]["Player"]["sprite"] = "art/missing.sprite.json"
+    assert "E_SPRITE" in codes(analyze(g, manifest, base_dir=tmp_path).diagnostics)
+
+
+def test_pixel_example_is_clean(manifest):
+    a = analyze(load_example("pixel_hopper.json"), manifest)
+    assert a.ok and not a.diagnostics.warnings, [str(d) for d in a.diagnostics]
+    assert len(a.sprites) == 8
+
+
+# --- studio kind mapping ----------------------------------------------------------------------
+
+@pytest.mark.parametrize("name, comps, archetype, platformer, kind", [
+    ("Player", {}, None, True, "hero"),
+    ("Goblin", {}, "walker", True, "hero"),
+    ("Slime", {}, "walker", True, "slime"),
+    ("FireBat", {}, "chaser", True, "flyer"),
+    ("LaserBot", {}, "shooter", False, "robot"),
+    ("Beetle", {}, "chaser", False, "bug"),
+    ("Thing", {}, "turret", False, "turret"),
+    ("Star", {"Collectible": {}}, None, True, "star"),
+    ("Acorn", {"Collectible": {}}, None, True, "orb"),
+    ("Crystal", {"Collectible": {}}, None, True, "gem"),
+    ("Exit", {}, None, False, "portal"),
+])
+def test_sprite_kind(name, comps, archetype, platformer, kind):
+    b = GameBrief(title="t", genre="platformer" if platformer else "topdown")
+    assert sprite_kind(name, {"components": comps}, archetype, b, platformer) == kind
+
+
+# --- tiles & zoom -----------------------------------------------------------------------------
+
+@pytest.mark.parametrize("genre", ["platformer", "topdown"])
+def test_pixel_tileset(genre):
+    from spawnpoint.sprites.tiles import tileset
+    img = tileset(genre, "#5f574f", "#00e436", "#ab5236", 32, seed=3)
+    assert img.size == (96, 32)
+    px = np.asarray(img)
+    assert (px[:, :64, 3] == 255).all()  # solid tiles are fully opaque
+    assert (px[20:, 64:, 3] == 0).all()  # the one-way plank leaves the lower part open
+    assert tileset(genre, "#5f574f", "#00e436", "#ab5236", 32, seed=3).tobytes() == img.tobytes()
+
+
+def test_plan_carries_tiles_and_zoom(manifest):
+    g = minimal(settings={"zoom": 1.5})
+    a = analyze(g, manifest)
+    assert a.plan["zoom"] == 1.5 and a.plan["tiles"]["texture"] == "res://sprites/tiles.png"
+    assert a.tiles_image is not None
+    flat = analyze(minimal(settings={"tile_style": "flat"}), manifest)
+    assert "texture" not in flat.plan["tiles"] and flat.tiles_image is None
+    assert "E_SCHEMA" in codes(analyze(minimal(settings={"zoom": 9}), manifest).diagnostics)