spawnpoint-studio 0.1.1__tar.gz → 0.2.0__tar.gz

{spawnpoint_studio-0.1.1/compiler/spawnpoint_studio.egg-info → spawnpoint_studio-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spawnpoint-studio
-Version: 0.1.1
+Version: 0.2.0
 Summary: Turn a sentence into a juicy, playable Godot 4 game — locally, on a consumer GPU.
 Author: smoky1496
 License: MIT
@@ -29,6 +29,7 @@ Dynamic: license-file
 [![CI](https://github.com/leluong141996-dev/Spawn-Point/actions/workflows/ci.yml/badge.svg)](https://github.com/leluong141996-dev/Spawn-Point/actions/workflows/ci.yml)
 [![PyPI](https://img.shields.io/pypi/v/spawnpoint-studio)](https://pypi.org/project/spawnpoint-studio/)
 [![Model](https://img.shields.io/badge/%F0%9F%A4%97%20model-SpawnPoint--Coder--7B-yellow)](https://huggingface.co/smoky1496/SpawnPoint-Coder-7B-AWQ)
+[![Play the demos](https://img.shields.io/badge/%E2%96%B6%20play-demos%20in%20your%20browser-ff004d)](https://leluong141996-dev.github.io/Spawn-Point/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
 
 <p align="center">
@@ -39,6 +40,9 @@ Dynamic: license-file
 <code>examples/pixel_arena.json</code>: generated sprites, collision traced from pixels, juice on by
 default. Recorded with <code>spawnpoint gif</code> (autopilot).</sub></p>
 
+<p align="center"><b><a href="https://leluong141996-dev.github.io/Spawn-Point/">▶ Play the demos in your browser</a></b>: a Mario-style platformer, a ninja
+rescue, a dinosaur-egg bubble shooter, a survivor with level-ups and an arena shooter. No install needed.</p>
+
 Spawn Point is an open-source, autonomous game studio that runs on your own machine. Instead of asking an LLM to type
 hundreds of lines of GDScript (slow, expensive, and easy to break with Godot 3/4 mix-ups), the LLM
 assembles **pre-tested components** like LEGO, places them on an **ASCII map**, and wires gameplay
@@ -62,16 +66,16 @@ graph.json ──► validate (Python) ──► build scenes (Godot headless)
 ## Install
 
 Requirements: Python ≥ 3.10, [Godot 4.6](https://godotengine.org/download) on your `PATH` (`godot4` or
-`godot`, or set `GODOT_BIN`), and for the LLM features either a 12 GB NVIDIA GPU with Docker (local model)
-or any OpenAI-compatible API.
+`godot`, or set `GODOT_BIN`), and for the LLM features one of: a 12 GB NVIDIA GPU with Docker (vLLM, fastest),
+[Ollama](https://ollama.com/download) on any machine (Mac, AMD, or CPU), or any OpenAI-compatible API.
 
 ```bash
 pip install spawnpoint-studio
-spawnpoint llm up                      # serves SpawnPoint-Coder-7B locally (or set SPAWNPOINT_LLM_* for an API)
+spawnpoint llm up                      # SpawnPoint-Coder-7B: vLLM on NVIDIA, otherwise Ollama (or set SPAWNPOINT_LLM_*)
 spawnpoint create "a ninja platformer where you collect stars"
 ```
 
-No GPU? Try the hand-written examples, no LLM needed:
+No GPU? [Play the demos in your browser](https://leluong141996-dev.github.io/Spawn-Point/), or build the hand-written examples locally, no LLM needed:
 
 ```bash
 spawnpoint examples copy pixel_hopper && spawnpoint build pixel_hopper.json --run
@@ -102,7 +106,7 @@ Standard library only on the server, one HTML/JS page on the client, Server-Sent
 ## Make a game from a sentence
 
 ```bash
-scripts/llm-up.sh                     # SpawnPoint-Coder-7B on vLLM (~11 GB VRAM) — or any OpenAI-compatible API
+spawnpoint llm up                     # SpawnPoint-Coder-7B: vLLM (~11 GB VRAM) or Ollama — or any OpenAI-compatible API
 spawnpoint create "a ninja platformer where you collect stars"
 ```
 
@@ -148,10 +152,13 @@ edits as strict JSON, and the compiler turns that into Godot scenes and GDScript
 GPU (AWQ 4-bit). v2 on 30 human-written game ideas (English and Vietnamese): 87% fully right (v1: 73%),
 97% of checks passed; on held-out tasks: briefs 88% exact (v1: 36%), Vietnamese → English 97% (v1: 52%),
 tweaks 98%, entity edits 91%. It is tuned for 2D platformers and 2D top-down games only; other genres
-are no better than a general 7B coder. `scripts/llm-up.sh` downloads and serves it.
+are no better than a general 7B coder. `spawnpoint llm up` downloads and serves it: the AWQ build on vLLM when
+Docker and an NVIDIA GPU are present, otherwise the [GGUF build](https://huggingface.co/smoky1496/SpawnPoint-Coder-7B-GGUF)
+(Q4_K_M, ~4.7 GB) in Ollama. Force one with `--backend vllm|ollama`.
 
-LLM settings: `SPAWNPOINT_LLM_BASE_URL` (default `http://localhost:8000/v1`),
-`SPAWNPOINT_LLM_MODEL` (default: the server's first model), `SPAWNPOINT_LLM_API_KEY`.
+LLM settings: `SPAWNPOINT_LLM_BASE_URL` (default: vLLM at `http://localhost:8000/v1`, or Ollama at
+`http://localhost:11434/v1` when only Ollama answers), `SPAWNPOINT_LLM_MODEL` (default: SpawnPoint-Coder if the
+server has it, else its first model), `SPAWNPOINT_LLM_API_KEY`.
 Web builds need the Godot **web export templates** (Editor → Manage Export Templates, or unpack
 `web_*.zip` from the official `.tpz` into `~/.local/share/godot/export_templates/<version>/`);
 use `--no-web` to skip and play natively with `spawnpoint run`.
@@ -326,7 +333,9 @@ headless smoke test (spawn, scripted input, crash detection) and report `E_RUNTI
 | Movement | `PlatformerMovement` (coyote time, jump buffer, variable jump, apex hang, dash, double jump), `TopDownMovement` (accel/friction, dash) |
 | Controllers | `PlayerInput`, `PatrolAI`, `ChaseAI`, `Aim` |
 | Combat | `Health`, `Hitbox`, `Hurtbox`, `Stomp`, `Weapon`, `Projectile` |
-| World | `Collectible`, `TriggerZone`, `Spawner`, `Gate` |
+| World | `Collectible`, `TriggerZone`, `Spawner` (ramping waves, spawns around the player), `Gate` |
+| Progression | `Experience` (XP and levels), `XpOrb` (gems that fly to the player), `LevelUpMenu` (pause and pick one of three upgrades) |
+| Game modes | `BubbleBoard` (a complete bubble shooter: bank shots, colour pops, falling clusters, a descending ceiling) |
 | Feel | `Juice` — attached to every entity unless `"juice": "none"` |
 
 Runtime autoloads: `GameState` (score, lives, variables, win/lose), `World` (spawning, rule
@@ -361,6 +370,9 @@ spawnpoint manifest         # regenerate manifest.json after changing a componen
 godot4 --headless --path godot --fixed-fps 60 res://tests/run_tests.tscn   # GDScript suite only
 ```
 
+`spawnpoint demo -o site` builds the browser demo site: the showcase graphs in `examples/`, one shared Godot
+engine, each game checked in headless Chrome. The Pages workflow publishes it on every push.
+
 Adding a component: create `godot/addons/spawn_point/components/<name>_component.gd` following the
 contract (typed `@export`s with ranges, `SP_NAME` / `SP_HOSTS` / `SP_REQUIRES` / `SP_CATEGORY`
 constants, `##` docs on everything public), add tests in `godot/tests/`, then run `spawnpoint manifest`.

{spawnpoint_studio-0.1.1 → spawnpoint_studio-0.2.0}/README.md

@@ -5,6 +5,7 @@
 [![CI](https://github.com/leluong141996-dev/Spawn-Point/actions/workflows/ci.yml/badge.svg)](https://github.com/leluong141996-dev/Spawn-Point/actions/workflows/ci.yml)
 [![PyPI](https://img.shields.io/pypi/v/spawnpoint-studio)](https://pypi.org/project/spawnpoint-studio/)
 [![Model](https://img.shields.io/badge/%F0%9F%A4%97%20model-SpawnPoint--Coder--7B-yellow)](https://huggingface.co/smoky1496/SpawnPoint-Coder-7B-AWQ)
+[![Play the demos](https://img.shields.io/badge/%E2%96%B6%20play-demos%20in%20your%20browser-ff004d)](https://leluong141996-dev.github.io/Spawn-Point/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
 
 <p align="center">
@@ -15,6 +16,9 @@
 <code>examples/pixel_arena.json</code>: generated sprites, collision traced from pixels, juice on by
 default. Recorded with <code>spawnpoint gif</code> (autopilot).</sub></p>
 
+<p align="center"><b><a href="https://leluong141996-dev.github.io/Spawn-Point/">▶ Play the demos in your browser</a></b>: a Mario-style platformer, a ninja
+rescue, a dinosaur-egg bubble shooter, a survivor with level-ups and an arena shooter. No install needed.</p>
+
 Spawn Point is an open-source, autonomous game studio that runs on your own machine. Instead of asking an LLM to type
 hundreds of lines of GDScript (slow, expensive, and easy to break with Godot 3/4 mix-ups), the LLM
 assembles **pre-tested components** like LEGO, places them on an **ASCII map**, and wires gameplay
@@ -38,16 +42,16 @@ graph.json ──► validate (Python) ──► build scenes (Godot headless)
 ## Install
 
 Requirements: Python ≥ 3.10, [Godot 4.6](https://godotengine.org/download) on your `PATH` (`godot4` or
-`godot`, or set `GODOT_BIN`), and for the LLM features either a 12 GB NVIDIA GPU with Docker (local model)
-or any OpenAI-compatible API.
+`godot`, or set `GODOT_BIN`), and for the LLM features one of: a 12 GB NVIDIA GPU with Docker (vLLM, fastest),
+[Ollama](https://ollama.com/download) on any machine (Mac, AMD, or CPU), or any OpenAI-compatible API.
 
 ```bash
 pip install spawnpoint-studio
-spawnpoint llm up                      # serves SpawnPoint-Coder-7B locally (or set SPAWNPOINT_LLM_* for an API)
+spawnpoint llm up                      # SpawnPoint-Coder-7B: vLLM on NVIDIA, otherwise Ollama (or set SPAWNPOINT_LLM_*)
 spawnpoint create "a ninja platformer where you collect stars"
 ```
 
-No GPU? Try the hand-written examples, no LLM needed:
+No GPU? [Play the demos in your browser](https://leluong141996-dev.github.io/Spawn-Point/), or build the hand-written examples locally, no LLM needed:
 
 ```bash
 spawnpoint examples copy pixel_hopper && spawnpoint build pixel_hopper.json --run
@@ -78,7 +82,7 @@ Standard library only on the server, one HTML/JS page on the client, Server-Sent
 ## Make a game from a sentence
 
 ```bash
-scripts/llm-up.sh                     # SpawnPoint-Coder-7B on vLLM (~11 GB VRAM) — or any OpenAI-compatible API
+spawnpoint llm up                     # SpawnPoint-Coder-7B: vLLM (~11 GB VRAM) or Ollama — or any OpenAI-compatible API
 spawnpoint create "a ninja platformer where you collect stars"
 ```
 
@@ -124,10 +128,13 @@ edits as strict JSON, and the compiler turns that into Godot scenes and GDScript
 GPU (AWQ 4-bit). v2 on 30 human-written game ideas (English and Vietnamese): 87% fully right (v1: 73%),
 97% of checks passed; on held-out tasks: briefs 88% exact (v1: 36%), Vietnamese → English 97% (v1: 52%),
 tweaks 98%, entity edits 91%. It is tuned for 2D platformers and 2D top-down games only; other genres
-are no better than a general 7B coder. `scripts/llm-up.sh` downloads and serves it.
+are no better than a general 7B coder. `spawnpoint llm up` downloads and serves it: the AWQ build on vLLM when
+Docker and an NVIDIA GPU are present, otherwise the [GGUF build](https://huggingface.co/smoky1496/SpawnPoint-Coder-7B-GGUF)
+(Q4_K_M, ~4.7 GB) in Ollama. Force one with `--backend vllm|ollama`.
 
-LLM settings: `SPAWNPOINT_LLM_BASE_URL` (default `http://localhost:8000/v1`),
-`SPAWNPOINT_LLM_MODEL` (default: the server's first model), `SPAWNPOINT_LLM_API_KEY`.
+LLM settings: `SPAWNPOINT_LLM_BASE_URL` (default: vLLM at `http://localhost:8000/v1`, or Ollama at
+`http://localhost:11434/v1` when only Ollama answers), `SPAWNPOINT_LLM_MODEL` (default: SpawnPoint-Coder if the
+server has it, else its first model), `SPAWNPOINT_LLM_API_KEY`.
 Web builds need the Godot **web export templates** (Editor → Manage Export Templates, or unpack
 `web_*.zip` from the official `.tpz` into `~/.local/share/godot/export_templates/<version>/`);
 use `--no-web` to skip and play natively with `spawnpoint run`.
@@ -302,7 +309,9 @@ headless smoke test (spawn, scripted input, crash detection) and report `E_RUNTI
 | Movement | `PlatformerMovement` (coyote time, jump buffer, variable jump, apex hang, dash, double jump), `TopDownMovement` (accel/friction, dash) |
 | Controllers | `PlayerInput`, `PatrolAI`, `ChaseAI`, `Aim` |
 | Combat | `Health`, `Hitbox`, `Hurtbox`, `Stomp`, `Weapon`, `Projectile` |
-| World | `Collectible`, `TriggerZone`, `Spawner`, `Gate` |
+| World | `Collectible`, `TriggerZone`, `Spawner` (ramping waves, spawns around the player), `Gate` |
+| Progression | `Experience` (XP and levels), `XpOrb` (gems that fly to the player), `LevelUpMenu` (pause and pick one of three upgrades) |
+| Game modes | `BubbleBoard` (a complete bubble shooter: bank shots, colour pops, falling clusters, a descending ceiling) |
 | Feel | `Juice` — attached to every entity unless `"juice": "none"` |
 
 Runtime autoloads: `GameState` (score, lives, variables, win/lose), `World` (spawning, rule
@@ -337,6 +346,9 @@ spawnpoint manifest         # regenerate manifest.json after changing a componen
 godot4 --headless --path godot --fixed-fps 60 res://tests/run_tests.tscn   # GDScript suite only
 ```
 
+`spawnpoint demo -o site` builds the browser demo site: the showcase graphs in `examples/`, one shared Godot
+engine, each game checked in headless Chrome. The Pages workflow publishes it on every push.
+
 Adding a component: create `godot/addons/spawn_point/components/<name>_component.gd` following the
 contract (typed `@export`s with ranges, `SP_NAME` / `SP_HOSTS` / `SP_REQUIRES` / `SP_CATEGORY`
 constants, `##` docs on everything public), add tests in `godot/tests/`, then run `spawnpoint manifest`.

{spawnpoint_studio-0.1.1 → spawnpoint_studio-0.2.0}/compiler/spawnpoint/build.py

@@ -142,5 +142,7 @@ def _judge_smoke(report: dict, plan: dict, diags: Diagnostics) -> None:
         return
     if plan["genre"] == "platformer" and not report.get("on_floor_after_1s"):
         diags.warning("W_SMOKE_FLOOR", "(smoke)", "the player is not standing on a floor after 1 second")
-    if report.get("moved_px", 0) < 4:
+    player = next((e for e in plan["entities"] if any(c["name"] == "PlayerInput" for c in e["components"])), None)
+    moves = player is None or any(c["name"] in ("PlatformerMovement", "TopDownMovement") for c in player["components"])
+    if moves and report.get("moved_px", 0) < 4:  # a bubble-shooter launcher does not walk
         diags.warning("W_SMOKE_STUCK", "(smoke)", "the player did not move under scripted input (stuck?)")

{spawnpoint_studio-0.1.1 → spawnpoint_studio-0.2.0}/compiler/spawnpoint/cli.py

@@ -73,14 +73,20 @@ def main(argv: list[str] | None = None) -> int:
     tw.add_argument("--no-web", action="store_true")
     tw.add_argument("--record", action="store_true", help="save LLM calls as local fine-tuning data")
 
-    lm = sub.add_parser("llm", help="run SpawnPoint-Coder-7B locally (Docker + NVIDIA GPU)")
+    lm = sub.add_parser("llm", help="run SpawnPoint-Coder-7B locally (vLLM on NVIDIA, or Ollama anywhere)")
     lm.add_argument("action", choices=["up", "down", "status"])
     lm.add_argument("--port", type=int, default=8000)
+    lm.add_argument("--backend", choices=["auto", "vllm", "ollama"], default="auto",
+                    help="auto: vLLM with Docker + an NVIDIA GPU, otherwise Ollama")
 
     ex = sub.add_parser("examples", help="list the example graphs, or copy one here")
     ex.add_argument("action", nargs="?", choices=["list", "copy"], default="list")
     ex.add_argument("name", nargs="?")
 
+    dm = sub.add_parser("demo", help="build every example as a web game plus a gallery page (static site)")
+    dm.add_argument("-o", "--out", type=Path, default=Path("site"))
+    dm.add_argument("--no-screenshots", action="store_true", help="skip the headless-Chrome check and thumbnails")
+
     gf = sub.add_parser("gif", help="record a gameplay GIF of a built project (autopilot; needs a display)")
     gf.add_argument("project", type=Path)
     gf.add_argument("-o", "--out", type=Path, help="output file (default: <project>/demo.gif)")
@@ -130,7 +136,8 @@ def main(argv: list[str] | None = None) -> int:
         return {"validate": _validate, "build": _build, "run": _run, "components": _components,
                 "manifest": _manifest, "create": studio_cli.create, "tweak": studio_cli.tweak,
                 "serve": studio_cli.serve, "dataset": studio_cli.dataset, "playtest": studio_cli.playtest, "studio": studio_cli.studio,
-                "sprites": _sprites, "gif": _gif, "llm": _llm, "examples": _examples}[args.cmd](args)
+                "sprites": _sprites, "gif": _gif, "llm": _llm, "examples": _examples,
+                "demo": _demo}[args.cmd](args)
     except godot.GodotError as e:
         print(f"error: {e}", file=sys.stderr)
         if e.output:
@@ -207,8 +214,9 @@ def _llm(args) -> int:
     from . import llm_server
 
     try:
-        return {"up": lambda: llm_server.up(args.port), "down": llm_server.down,
-                "status": lambda: llm_server.status(args.port)}[args.action]()
+        return {"up": lambda: llm_server.up(args.port, backend=args.backend),
+                "down": lambda: llm_server.down(backend=args.backend),
+                "status": lambda: llm_server.status(args.port, backend=args.backend)}[args.action]()
     except (RuntimeError, subprocess.CalledProcessError) as e:
         print(f"error: {e}", file=sys.stderr)
         return 2
@@ -242,6 +250,18 @@ def _gif(args) -> int:
     return 0
 
 
+def _demo(args) -> int:
+    from .demo import build_site
+
+    print(f"Building the demo site in {args.out}/")
+    games = build_site(args.out, screenshots=not args.no_screenshots)
+    failed = [g for g in games if g.errors]
+    for g in failed:
+        print(f"error: {g.slug}: " + "; ".join(g.errors[:3]), file=sys.stderr)
+    print(f"{len(games) - len(failed)}/{len(games)} games ok. Preview: python -m http.server -d {args.out}")
+    return 1 if failed else 0
+
+
 def _sprites(args) -> int:
     from .sprites import generate as gen, importer
     from .sprites.spriteset import SpriteError, load

spawnpoint_studio-0.2.0/compiler/spawnpoint/demo.py

@@ -0,0 +1,247 @@
+"""Static demo site: every example game built for the web, playable from one gallery page.
+
+    spawnpoint demo --out site
+
+The games are the SHOWCASE examples below. Each one is built, exported as a single-threaded web build
+(works on GitHub Pages, no special headers), checked in headless Chrome (no console errors, a real
+screenshot for the card) and linked from index.html.
+"""
+
+from __future__ import annotations
+
+import html
+import io
+import json
+import shutil
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from . import manifest as manifest_mod
+from .build import build, load_graph
+from .studio import web, webcheck
+
+REPO = "https://github.com/leluong141996-dev/Spawn-Point"
+MODEL = "https://huggingface.co/smoky1496/SpawnPoint-Coder-7B-AWQ"
+# (example graph, genre tag, one-line pitch, controls). Controls are ASCII: they travel through Godot's
+# export_presets.cfg into the game page.
+SHOWCASE = [
+    ("pixel_hopper.json", "platformer",
+     "A Mario-style romp: stomp slimes, double-jump, dash, and collect every coin to open the door.",
+     "Move: arrows / WASD | Jump: Space (twice to double-jump) | Dash: Shift | Restart: R"),
+    ("ninja_rescue.json", "platformer",
+     "Mom has been caged! Throw shurikens, dodge the masked throwers, grab the key up high and set her free.",
+     "Move: arrows / WASD | Jump: Space | Shuriken: X / J | Dash: Shift | Restart: R"),
+    ("dino_eggs.json", "bubble shooter",
+     "The classic egg shooter: bank shots off the walls, pop three dinosaur eggs of a colour, drop whole clusters.",
+     "Aim: mouse or Left / Right | Shoot: click / Space / X | Restart: R"),
+    ("night_survivor.json", "survivor",
+     "Survive three minutes of the night: auto-fire, collect gems, level up and pick a new power each time.",
+     "Move: arrows / WASD | Dash: Shift | Pick an upgrade: 1 / 2 / 3 or click | Restart: R"),
+    ("pixel_arena.json", "arena shooter",
+     "A top-down arena: blast through robots and turrets, then reach the portal.",
+     "Move: WASD | Aim: mouse | Shoot: click / X | Dash: Shift | Restart: R"),
+]
+
+
+def game_overlay(controls: str) -> str:
+    """Injected into every game page: a way back to the gallery and the controls (bottom-left, clear of
+    the HUD). Hidden for screenshots (?shot)."""
+    return (
+        "<style>#sp-bar{position:fixed;bottom:30px;left:8px;z-index:10;display:flex;gap:10px;align-items:center;"
+        "font:12px/1.4 ui-monospace,Menlo,monospace;color:#fff;background:rgba(0,0,0,.55);padding:5px 10px;"
+        "border-radius:6px;pointer-events:none}#sp-bar a{color:#ffec27;text-decoration:none;pointer-events:auto}"
+        "@media (max-width:700px){#sp-bar span{display:none}}</style>"
+        "<script>addEventListener('DOMContentLoaded',function(){if(location.search.indexOf('shot')>=0)return;"
+        "var b=document.createElement('div');b.id='sp-bar';"
+        "b.innerHTML='<a href=\\\"../\\\">&lt;- all games</a><span>" + controls + "</span>';"
+        "document.body.appendChild(b);});</script>"
+    )
+
+
+@dataclass
+class Game:
+    slug: str
+    graph: Path
+    title: str = ""
+    tag: str = ""
+    blurb: str = ""
+    controls: str = ""
+    errors: list[str] = field(default_factory=list)
+
+
+def discover(examples: Path | None = None) -> list[Game]:
+    examples = examples or manifest_mod.EXAMPLES_DIR
+    games: list[Game] = []
+    for name, tag, blurb, controls in SHOWCASE:
+        path = examples / name
+        if path.exists():
+            data = load_graph(path)
+            games.append(Game(path.stem.replace("_", "-"), path, data.get("name", path.stem), tag, blurb, controls))
+    return games
+
+
+def build_site(out: Path, games: list[Game] | None = None, screenshots: bool = True, log=print) -> list[Game]:
+    """Builds every game into out/<slug>/ and writes out/index.html. Returns the games (with any errors)."""
+    games = discover() if games is None else games
+    out.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory() as tmp:
+        for g in games:
+            project = Path(tmp) / g.slug
+            result = build(load_graph(g.graph), project, base_dir=g.graph.parent)
+            if not result.ok:
+                g.errors = [str(d) for d in result.diagnostics.errors] or ["build failed"]
+                log(f"  {g.slug}: build failed: {g.errors[0]}")
+                continue
+            seconds = web.export(project, head_include=game_overlay(g.controls))
+            target = out / g.slug
+            shutil.rmtree(target, ignore_errors=True)
+            shutil.copytree(project / web.WEB_DIR, target,
+                            ignore=shutil.ignore_patterns(".gdignore", web.VERSION_FILE))
+            share_engine(out, target)
+            log(f"  {g.slug}: built (web export {seconds:.1f}s)")
+    built = [g for g in games if (out / g.slug / "index.html").exists()]
+    if screenshots:
+        if webcheck.find_chrome() is None:
+            log("Chrome not found: skipping the browser check and screenshots")
+        else:
+            check_in_browser(out, built, log)
+    (out / "index.html").write_text(index_html(built))
+    (out / ".nojekyll").write_text("")  # serve files as they are
+    return games
+
+
+ENGINE_DIR = "engine"
+ENGINE_FILES = ("index.wasm", "index.js", "index.audio.worklet.js", "index.audio.position.worklet.js")
+
+
+def share_engine(out: Path, game: Path) -> None:
+    """Every game ships the same Godot engine (~37 MB of wasm). Keep one copy in out/engine/ and point each
+    game at it, so the site is small and the engine is cached after the first game."""
+    engine = out / ENGINE_DIR
+    engine.mkdir(exist_ok=True)
+    for name in ENGINE_FILES:
+        src = game / name
+        if not src.exists():
+            continue
+        dst = engine / name
+        if not dst.exists():
+            shutil.copy2(src, dst)
+        elif dst.read_bytes() != src.read_bytes():
+            raise RuntimeError(f"{game.name}/{name} differs from the shared engine (mixed Godot versions?)")
+        src.unlink()
+    page = game / "index.html"
+    text = page.read_text()
+    patched = (text.replace('src="index.js"', f'src="../{ENGINE_DIR}/index.js"')
+                   .replace('"executable":"index"', f'"executable":"../{ENGINE_DIR}/index","mainPack":"index.pck"')
+                   .replace('"index.wasm":', f'"../{ENGINE_DIR}/index.wasm":'))
+    if patched.count(f"../{ENGINE_DIR}/") != 3:
+        raise RuntimeError(f"{page}: unexpected Godot web shell, cannot point it at the shared engine")
+    page.write_text(patched)
+
+
+def check_in_browser(out: Path, games: list[Game], log=print) -> None:
+    """Loads every game from the finished site in headless Chrome: no console errors, plus a thumbnail."""
+    import functools
+    import threading
+    from http.server import ThreadingHTTPServer
+
+    port = web.free_port(8150)
+    httpd = ThreadingHTTPServer(("127.0.0.1", port), functools.partial(web._Handler, directory=str(out)))
+    threading.Thread(target=httpd.serve_forever, daemon=True).start()
+    try:
+        for g in games:
+            check = webcheck.check(f"http://localhost:{port}/{g.slug}/?shot", seconds=8)
+            g.errors = list(check.errors)
+            if not any("Godot Engine" in line for line in check.console):
+                g.errors.append("the engine did not start")
+            if check.screenshot:
+                _thumbnail(check.screenshot, out / g.slug / "thumb.png")
+            log(f"  {g.slug}: " + ("plays in Chrome" if not g.errors else "; ".join(g.errors[:2])))
+    finally:
+        httpd.shutdown()
+
+
+def _thumbnail(png: bytes, path: Path, width: int = 480) -> None:
+    from PIL import Image
+
+    img = Image.open(io.BytesIO(png)).convert("RGB")
+    img.thumbnail((width, width))
+    img.save(path, optimize=True)
+
+
+def index_html(games: list[Game]) -> str:
+    cards = "\n".join(_card(g) for g in games)
+    return f"""<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Spawn Point demos</title>
+<meta name="description" content="Five Godot 4 games built with Spawn Point: platformers, a bubble shooter, a survivor. Play in your browser.">
+<meta property="og:title" content="Spawn Point demos: play Godot games in your browser">
+<meta property="og:description" content="A Mario-style platformer, a ninja rescue, a dinosaur-egg shooter, a survivor and an arena, all built from Spawn Point components.">
+<style>
+:root {{ --bg:#14121c; --panel:#1f1c2b; --ink:#f4f1ff; --muted:#a59fbf; --accent:#ffec27; --ai:#29adff; --line:#332f45; }}
+@media (prefers-color-scheme: light) {{
+  :root:not([data-theme="dark"]) {{ --bg:#f6f4fb; --panel:#ffffff; --ink:#1b1828; --muted:#5d5875; --accent:#b8860b; --ai:#0b6fb8; --line:#e3dff0; }}
+}}
+* {{ box-sizing:border-box }}
+body {{ margin:0; background:var(--bg); color:var(--ink); font:16px/1.55 system-ui,-apple-system,Segoe UI,sans-serif }}
+a {{ color:inherit }}
+header, main, footer {{ max-width:1100px; margin:0 auto; padding:0 16px }}
+header {{ padding-top:40px; padding-bottom:8px }}
+h1 {{ font:700 clamp(28px,5vw,44px)/1.1 ui-monospace,Menlo,monospace; margin:0 0 10px; letter-spacing:-.02em }}
+h1 span {{ color:var(--accent) }}
+.lede {{ color:var(--muted); max-width:720px; margin:0 0 18px }}
+.links {{ display:flex; flex-wrap:wrap; gap:10px; margin-bottom:12px }}
+.links a {{ text-decoration:none; border:1px solid var(--line); background:var(--panel); padding:7px 12px; border-radius:8px; font-size:14px }}
+.links a:hover {{ border-color:var(--accent) }}
+code {{ font:13px ui-monospace,Menlo,monospace; background:var(--panel); border:1px solid var(--line); padding:2px 6px; border-radius:5px }}
+.note {{ color:var(--muted); font-size:13px; margin:4px 0 26px }}
+.grid {{ display:grid; grid-template-columns:repeat(auto-fill,minmax(300px,1fr)); gap:18px; padding-bottom:40px }}
+.card {{ background:var(--panel); border:1px solid var(--line); border-radius:12px; overflow:hidden; display:flex; flex-direction:column; text-decoration:none; transition:transform .12s, border-color .12s }}
+.card:hover {{ transform:translateY(-2px); border-color:var(--accent) }}
+.thumb {{ aspect-ratio:16/9; background:#000 center/cover no-repeat; image-rendering:pixelated; position:relative }}
+.play {{ position:absolute; right:10px; bottom:10px; background:var(--accent); color:#000; font:700 13px ui-monospace,monospace; padding:5px 10px; border-radius:6px }}
+.body {{ padding:12px 14px 16px; display:flex; flex-direction:column; gap:6px }}
+.title {{ font-weight:700; font-size:17px }}
+.tags {{ display:flex; gap:6px; flex-wrap:wrap }}
+.tag {{ font:600 11px ui-monospace,monospace; text-transform:uppercase; letter-spacing:.04em; padding:2px 7px; border-radius:4px; border:1px solid var(--line); color:var(--muted) }}
+.tag.ai {{ color:var(--ai); border-color:var(--ai) }}
+.blurb {{ margin:2px 0 0; color:var(--ink) }}
+.controls {{ margin:0; color:var(--muted); font:12px/1.5 ui-monospace,Menlo,monospace }}
+footer {{ color:var(--muted); font-size:13px; padding-bottom:40px }}
+</style>
+</head>
+<body>
+<header>
+  <h1>Spawn<span>Point</span> demos</h1>
+  <p class="lede">Five games, five ways to play, all built by Spawn Point from small JSON game graphs and a
+  library of tested Godot 4 components: game feel, pixel art and collisions come for free. Click a card to play in
+  your browser, no install needed.</p>
+  <div class="links">
+    <a href="{REPO}">⭐ GitHub repo</a>
+    <a href="{MODEL}">🤗 SpawnPoint-Coder-7B</a>
+    <a href="https://pypi.org/project/spawnpoint-studio/">📦 pip install spawnpoint-studio</a>
+  </div>
+  <p class="note">Desktop + keyboard. Make your own from a sentence:
+  <code>spawnpoint create "a ninja platformer where you collect stars"</code></p>
+</header>
+<main class="grid">
+{cards}
+</main>
+<footer>Built by the <a href="{REPO}/blob/main/.github/workflows/pages.yml">pages workflow</a> from the graphs in
+<a href="{REPO}/tree/main/examples">examples/</a>. MIT licensed.</footer>
+</body>
+</html>
+"""
+
+
+def _card(g: Game) -> str:
+    esc = html.escape
+    thumb = f' style="background-image:url({g.slug}/thumb.png)"'
+    tags = f'<span class="tag ai">{esc(g.tag)}</span>' if g.tag else ""
+    return (f'<a class="card" href="{g.slug}/"><div class="thumb"{thumb}><span class="play">▶ PLAY</span></div>'
+            f'<div class="body"><div class="title">{esc(g.title)}</div><div class="tags">{tags}</div>'
+            f'<p class="blurb">{esc(g.blurb)}</p><p class="controls">{esc(g.controls)}</p></div></a>')

{spawnpoint_studio-0.1.1 → spawnpoint_studio-0.2.0}/compiler/spawnpoint/llm_server.py

@@ -1,4 +1,8 @@
-"""`spawnpoint llm up|down|status`: run SpawnPoint-Coder-7B locally in the vLLM Docker image."""
+"""`spawnpoint llm up|down|status`: run SpawnPoint-Coder-7B locally.
+
+Two backends: vLLM in Docker on an NVIDIA GPU (AWQ, fastest), or Ollama anywhere else (GGUF Q4_K_M:
+Apple Silicon, AMD, or plain CPU). `auto` picks vLLM when Docker and an NVIDIA GPU are present.
+"""
 
 from __future__ import annotations
 
@@ -14,6 +18,35 @@ NAME = os.environ.get("SPAWNPOINT_LLM_CONTAINER", "spawnpoint-llm")
 IMAGE = os.environ.get("VLLM_IMAGE", "vllm/vllm-openai:v0.10.2")  # CUDA 12.8: NVIDIA driver >= 570
 MODEL = os.environ.get("SPAWNPOINT_MODEL", "smoky1496/SpawnPoint-Coder-7B-AWQ")
 SERVED = "SpawnPoint-Coder-7B"
+OLLAMA_MODEL = os.environ.get("SPAWNPOINT_OLLAMA_MODEL", "hf.co/smoky1496/SpawnPoint-Coder-7B-GGUF:Q4_K_M")
+OLLAMA_PORT = 11434
+
+
+def pick_backend(choice: str = "auto") -> str:
+    if choice != "auto":
+        return choice
+    if shutil.which("docker") and shutil.which("nvidia-smi"):
+        return "vllm"
+    if shutil.which("ollama"):
+        return "ollama"
+    raise RuntimeError("no local backend found: install Ollama (https://ollama.com/download) on any machine, "
+                       "or Docker + the NVIDIA container toolkit for vLLM. A hosted API works too: "
+                       "set SPAWNPOINT_LLM_BASE_URL / SPAWNPOINT_LLM_MODEL / SPAWNPOINT_LLM_API_KEY.")
+
+
+def _ollama(*args: str, capture: bool = True) -> subprocess.CompletedProcess:
+    return subprocess.run(["ollama", *args], capture_output=capture, text=True)
+
+
+def ollama_up(say=print) -> int:
+    if _ollama("list").returncode != 0:
+        say("Ollama is installed but its server is not running: start the Ollama app or run `ollama serve`.")
+        return 1
+    say(f"Pulling {OLLAMA_MODEL} with Ollama (first time ~4.7 GB) ...")
+    if _ollama("pull", OLLAMA_MODEL, capture=False).returncode != 0:
+        return 1
+    say(f"Ready: http://localhost:{OLLAMA_PORT}/v1 (model {OLLAMA_MODEL}). Spawn Point finds it automatically.")
+    return 0
 
 
 def _docker(*args: str, check: bool = True, capture: bool = True) -> subprocess.CompletedProcess:
@@ -39,7 +72,9 @@ def ready(port: int = 8000) -> bool:
         return False
 
 
-def up(port: int = 8000, max_len: int = 16384, say=print) -> int:
+def up(port: int = 8000, max_len: int = 16384, say=print, backend: str = "auto") -> int:
+    if pick_backend(backend) == "ollama":
+        return ollama_up(say)
     if _exists():
         _docker("start", NAME)
     else:
@@ -62,8 +97,11 @@ def up(port: int = 8000, max_len: int = 16384, say=print) -> int:
     return 0
 
 
-def down(say=print) -> int:
-    if _exists():
+def down(say=print, backend: str = "auto") -> int:
+    if pick_backend(backend) == "ollama":
+        _ollama("stop", OLLAMA_MODEL)
+        say("Unloaded from Ollama.")
+    elif _exists():
         _docker("stop", NAME)
         say("Stopped.")
     else:
@@ -71,7 +109,12 @@ def down(say=print) -> int:
     return 0
 
 
-def status(port: int = 8000, say=print) -> int:
+def status(port: int = 8000, say=print, backend: str = "auto") -> int:
+    if pick_backend(backend) == "ollama":
+        have = OLLAMA_MODEL.split(":")[0].lower() in _ollama("list").stdout.lower()
+        say(f"Ollama model {OLLAMA_MODEL}: {'pulled' if have else 'not pulled'}; "
+            f"API on :{OLLAMA_PORT}: {'ready' if ready(OLLAMA_PORT) else 'not responding'}")
+        return 0
     say(f"container {NAME}: {'running' if _exists() and _running() else 'stopped'}; "
         f"API on :{port}: {'ready' if ready(port) else 'not responding'}")
     return 0

{spawnpoint_studio-0.1.1 → spawnpoint_studio-0.2.0}/compiler/spawnpoint/playtest/report.py

@@ -22,6 +22,7 @@ class ProfileStats:
     jumps_missed: int
     pickup_rate: float
     stuck: int
+    hits: int = 0  # times the player took damage (dying or not)
 
     @property
     def win_rate(self) -> float:
@@ -71,6 +72,7 @@ def aggregate(runs: list[dict], goal_entities: set[str] | None = None) -> Report
             jumps_missed=sum(len(r["jumps"]["missed"]) for r in rs),
             pickup_rate=round(sum(r["pickups"]["collected"] for r in rs) / total, 3) if total else 1.0,
             stuck=sum(len(r["stuck"]) for r in rs),
+            hits=sum(len(r.get("damage", [])) for r in rs),
         )
     return Report(stats, runs, _level_issues(runs, stats, goal_entities))
 
@@ -118,8 +120,9 @@ def heatmap(plan: dict, runs: list[dict], out: Path, cell: int = 12) -> Path:
         else:
             d.rectangle((box[0], box[1], box[2], box[1] + 2), fill=(171, 82, 54))
     ts = plan["tile_size"]
+    players = {e["name"] for e in plan["entities"] if any(c["name"] == "PlayerInput" for c in e["components"])}
     for p in plan["placements"]:
-        if p["entity"] == "Player":
+        if p["entity"] in players:
             cx, cy = p["x"] / ts * cell, p["y"] / ts * cell
             d.ellipse((cx - 4, cy - 4, cx + 4, cy + 4), outline=(0, 228, 54), width=2)
     causes = sorted({dd["cause"] for r in runs for dd in r["deaths"]})