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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spawnpoint-studio
-Version: 0.1.1
+Version: 0.3.0
 Summary: Turn a sentence into a juicy, playable Godot 4 game — locally, on a consumer GPU.
 Author: smoky1496
 License: MIT
@@ -29,15 +29,26 @@ 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">
-  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/pixel-hopper.gif" width="48%" alt="Pixel Hopper — generated platformer">
-  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/pixel-arena.gif" width="48%" alt="Pixel Arena — generated top-down shooter">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/knight-quest.gif" width="48%" alt="Knight's Quest: a cartoon-style sword platformer">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/castle-defense.gif" width="48%" alt="Castle Defense: a tower defense game">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/ninja-rescue.gif" width="48%" alt="Ninja Rescue: a platformer where a ninja frees his mother">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/dino-eggs.gif" width="48%" alt="Dino Eggs: a bubble shooter with dinosaur eggs">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/night-survivor.gif" width="48%" alt="Night Survivor: auto-fire, gems, level-ups">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/pixel-hopper.gif" width="48%" alt="Pixel Hopper: a Mario-style platformer">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/star-run.gif" width="48%" alt="Star Run: a side-scrolling shooter with power-ups and a boss">
 </p>
-<p align="center"><sub>Both games are built from <code>examples/pixel_hopper.json</code> and
-<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"><sub>Seven of the demo games, each one a small JSON graph in <code>examples/</code> built from the
+same component library: generated cartoon or pixel art, collision traced from the sprites, 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 cartoon
+knight with a sword, tower defense, a ninja rescue, a dinosaur-egg bubble shooter, a survivor with level-ups, a farming
+game, an arena shooter and a side-scrolling space shooter. No install needed, and
+they work on phones too (touch controls).</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
@@ -62,16 +73,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 +113,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"
 ```
 
@@ -145,23 +156,42 @@ Only what you asked for changes, and the level layout is kept. Prompts can be in
 **The model.** [SpawnPoint-Coder-7B](https://huggingface.co/smoky1496/SpawnPoint-Coder-7B-AWQ) is a 7B model
 fine-tuned to generate Godot 4 games through this pipeline: it writes the game design, tweaks and entity
 edits as strict JSON, and the compiler turns that into Godot scenes and GDScript. It runs on a single 12 GB
-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.
+GPU (AWQ 4-bit). v5 adds **side-scrolling shooters** (flight patterns, power-ups, a boss), reads **Vietnamese prompts directly** and writes a small per-genre format instead of one big form. The downloadable AWQ build gets 75% of a sealed set of 16 human-written prompts for shooters and the v4 fixes fully right, and 77% of 30 human-written game ideas in English and Vietnamese (v4 scored a bit higher on its older sets; the model card lists every number and where v5 is behind). The GGUF Q4_K_M build scores 73% on those 30. Older models still work with `SPAWNPOINT_BRIEF_FORMAT=v4`. It is tuned for the 2D game kinds Spawn Point builds; other genres 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`.
 
 ## Sprites: generated or your own
 
-Layer 2 replaces placeholder shapes with **procedural pixel-art sprites** — no assets, no GPU. The
+Layer 2 replaces placeholder shapes with **procedural sprites** — no assets, no GPU — in one of two art styles:
+**pixel art** (the default) or **cartoon** (`"art_style": "cartoon"` in the graph settings, or "cartoon style" in
+the prompt): smooth shaded sprites with a sticker outline, rounded tiles, and a parallax sky with hills, clouds and
+trees. The
 kind follows the entity (`Goblin` → humanoid, `FireBat` → flyer, `LaserBot` → robot, `Crystal` → gem…)
-and details follow the name (`Ninja` → mask, `Fox` → ears and tail, `Spider` → legs). Every sprite has
-idle / run / jump / fall / hurt animations driven automatically by an `Animator` component.
+and details follow the name (`Ninja` → mask, `Fox` → ears and tail, `Spider` → legs, a sword-wielder holds a sword).
+Every sprite has idle / run / jump / fall / hurt animations driven automatically by an `Animator` component, plus
+`attack` (played each time its weapon fires) and `die` (a death sequence that plays on after the entity is gone) for
+anything that fights or can be hurt; heroes breathe and blink while they stand.
+
+**Pixel-art settings** (`settings` in the graph; the assembler sets the first two from the game's theme):
+
+| Setting | Values | What it does |
+|---|---|---|
+| `pixel_palette` | `none`, `pico8`, `sweetie16`, `endesga32` | Limits every sprite, tile and backdrop colour to a classic palette, so the whole game shares one set of colours. |
+| `scenery` | `auto`, `flat`, or a theme (`night`, `forest`, `desert`, `neon`, `candy`, `ocean`, `lava`, `snow`) | A banded sky with sun or moon and stars, parallax clouds, mountains, hills and themed trees, cacti, skylines or kelp (a themed floor for top-down games). `auto` picks one that fits the background colour, `flat` keeps the plain hills. |
+| `pixel_size` | `2` (default), `1` | `2` is chunky (NES-like); `1` draws the same art at twice the resolution (SNES-like) at the same on-screen size. |
+
+<p align="center"><img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/pixel-size.png" width="92%" alt="The same game with pixel_size 2 (chunky) and pixel_size 1 (fine)"><br><sub>The same game, same moment: <code>pixel_size: 2</code> (left) and <code>pixel_size: 1</code> (right).</sub></p>
+
+Ground tiles are drawn for their neighbours (grass on top, outlined exposed edges, rounded and notched corners,
+varied interiors, capped one-way planks), and pixel-art levels get pixel effects: skidding dust, hit sparks and a
+screen shake in whole pixels.
 
 **Collision comes from the pixels.** Hitboxes, hurtboxes, pickups, hazards and static bodies use the
 sprite's traced outline (`CollisionPolygon2D`); moving bodies keep a smooth capsule/circle fitted to
@@ -325,8 +355,13 @@ 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` |
+| Combat | `Health`, `Hitbox`, `Hurtbox`, `Stomp`, `Weapon`, `Projectile` (a sword is a `Weapon` whose projectile is a short, piercing slash) |
+| 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) |
+| Shooters | `FlightPath` (straight, wave, dive and hover patterns across the screen), `ShmupShip` (auto-fire, power-ups that add shots and spread), `HealthBar` (boss bars), and `WaveSpawner` gates (`autostart`, `endless`, random spread) |
+| Tower defense | `PathFollower` (walks the road to the base), `Base` (loses a life per invader that gets in), `WaveSpawner` ("8 x Goblin every 1.2; ..."), `TowerSlot`, `TowerBuilder` (click a pad, pay in gold), `TowerBrain` (targets the invader furthest along), `GroundPatch` (roads and paths) |
+| Farming | `FarmPlot` (soil that grows a crop only while watered), `Farmer` (plant / water / harvest, a basket, crop choice), `Market` (sell the basket), `CropPest` (crows that eat crops) |
 | Feel | `Juice` — attached to every entity unless `"juice": "none"` |
 
 Runtime autoloads: `GameState` (score, lives, variables, win/lose), `World` (spawning, rule
@@ -361,6 +396,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.3.0}/README.md

@@ -5,15 +5,26 @@
 [![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">
-  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/pixel-hopper.gif" width="48%" alt="Pixel Hopper — generated platformer">
-  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/pixel-arena.gif" width="48%" alt="Pixel Arena — generated top-down shooter">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/knight-quest.gif" width="48%" alt="Knight's Quest: a cartoon-style sword platformer">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/castle-defense.gif" width="48%" alt="Castle Defense: a tower defense game">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/ninja-rescue.gif" width="48%" alt="Ninja Rescue: a platformer where a ninja frees his mother">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/dino-eggs.gif" width="48%" alt="Dino Eggs: a bubble shooter with dinosaur eggs">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/night-survivor.gif" width="48%" alt="Night Survivor: auto-fire, gems, level-ups">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/pixel-hopper.gif" width="48%" alt="Pixel Hopper: a Mario-style platformer">
+  <img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/star-run.gif" width="48%" alt="Star Run: a side-scrolling shooter with power-ups and a boss">
 </p>
-<p align="center"><sub>Both games are built from <code>examples/pixel_hopper.json</code> and
-<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"><sub>Seven of the demo games, each one a small JSON graph in <code>examples/</code> built from the
+same component library: generated cartoon or pixel art, collision traced from the sprites, 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 cartoon
+knight with a sword, tower defense, a ninja rescue, a dinosaur-egg bubble shooter, a survivor with level-ups, a farming
+game, an arena shooter and a side-scrolling space shooter. No install needed, and
+they work on phones too (touch controls).</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
@@ -38,16 +49,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 +89,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"
 ```
 
@@ -121,23 +132,42 @@ Only what you asked for changes, and the level layout is kept. Prompts can be in
 **The model.** [SpawnPoint-Coder-7B](https://huggingface.co/smoky1496/SpawnPoint-Coder-7B-AWQ) is a 7B model
 fine-tuned to generate Godot 4 games through this pipeline: it writes the game design, tweaks and entity
 edits as strict JSON, and the compiler turns that into Godot scenes and GDScript. It runs on a single 12 GB
-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.
+GPU (AWQ 4-bit). v5 adds **side-scrolling shooters** (flight patterns, power-ups, a boss), reads **Vietnamese prompts directly** and writes a small per-genre format instead of one big form. The downloadable AWQ build gets 75% of a sealed set of 16 human-written prompts for shooters and the v4 fixes fully right, and 77% of 30 human-written game ideas in English and Vietnamese (v4 scored a bit higher on its older sets; the model card lists every number and where v5 is behind). The GGUF Q4_K_M build scores 73% on those 30. Older models still work with `SPAWNPOINT_BRIEF_FORMAT=v4`. It is tuned for the 2D game kinds Spawn Point builds; other genres 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`.
 
 ## Sprites: generated or your own
 
-Layer 2 replaces placeholder shapes with **procedural pixel-art sprites** — no assets, no GPU. The
+Layer 2 replaces placeholder shapes with **procedural sprites** — no assets, no GPU — in one of two art styles:
+**pixel art** (the default) or **cartoon** (`"art_style": "cartoon"` in the graph settings, or "cartoon style" in
+the prompt): smooth shaded sprites with a sticker outline, rounded tiles, and a parallax sky with hills, clouds and
+trees. The
 kind follows the entity (`Goblin` → humanoid, `FireBat` → flyer, `LaserBot` → robot, `Crystal` → gem…)
-and details follow the name (`Ninja` → mask, `Fox` → ears and tail, `Spider` → legs). Every sprite has
-idle / run / jump / fall / hurt animations driven automatically by an `Animator` component.
+and details follow the name (`Ninja` → mask, `Fox` → ears and tail, `Spider` → legs, a sword-wielder holds a sword).
+Every sprite has idle / run / jump / fall / hurt animations driven automatically by an `Animator` component, plus
+`attack` (played each time its weapon fires) and `die` (a death sequence that plays on after the entity is gone) for
+anything that fights or can be hurt; heroes breathe and blink while they stand.
+
+**Pixel-art settings** (`settings` in the graph; the assembler sets the first two from the game's theme):
+
+| Setting | Values | What it does |
+|---|---|---|
+| `pixel_palette` | `none`, `pico8`, `sweetie16`, `endesga32` | Limits every sprite, tile and backdrop colour to a classic palette, so the whole game shares one set of colours. |
+| `scenery` | `auto`, `flat`, or a theme (`night`, `forest`, `desert`, `neon`, `candy`, `ocean`, `lava`, `snow`) | A banded sky with sun or moon and stars, parallax clouds, mountains, hills and themed trees, cacti, skylines or kelp (a themed floor for top-down games). `auto` picks one that fits the background colour, `flat` keeps the plain hills. |
+| `pixel_size` | `2` (default), `1` | `2` is chunky (NES-like); `1` draws the same art at twice the resolution (SNES-like) at the same on-screen size. |
+
+<p align="center"><img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/pixel-size.png" width="92%" alt="The same game with pixel_size 2 (chunky) and pixel_size 1 (fine)"><br><sub>The same game, same moment: <code>pixel_size: 2</code> (left) and <code>pixel_size: 1</code> (right).</sub></p>
+
+Ground tiles are drawn for their neighbours (grass on top, outlined exposed edges, rounded and notched corners,
+varied interiors, capped one-way planks), and pixel-art levels get pixel effects: skidding dust, hit sparks and a
+screen shake in whole pixels.
 
 **Collision comes from the pixels.** Hitboxes, hurtboxes, pickups, hazards and static bodies use the
 sprite's traced outline (`CollisionPolygon2D`); moving bodies keep a smooth capsule/circle fitted to
@@ -301,8 +331,13 @@ 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` |
+| Combat | `Health`, `Hitbox`, `Hurtbox`, `Stomp`, `Weapon`, `Projectile` (a sword is a `Weapon` whose projectile is a short, piercing slash) |
+| 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) |
+| Shooters | `FlightPath` (straight, wave, dive and hover patterns across the screen), `ShmupShip` (auto-fire, power-ups that add shots and spread), `HealthBar` (boss bars), and `WaveSpawner` gates (`autostart`, `endless`, random spread) |
+| Tower defense | `PathFollower` (walks the road to the base), `Base` (loses a life per invader that gets in), `WaveSpawner` ("8 x Goblin every 1.2; ..."), `TowerSlot`, `TowerBuilder` (click a pad, pay in gold), `TowerBrain` (targets the invader furthest along), `GroundPatch` (roads and paths) |
+| Farming | `FarmPlot` (soil that grows a crop only while watered), `Farmer` (plant / water / harvest, a basket, crop choice), `Market` (sell the basket), `CropPest` (crows that eat crops) |
 | Feel | `Juice` — attached to every entity unless `"juice": "none"` |
 
 Runtime autoloads: `GameState` (score, lives, variables, win/lose), `World` (spawning, rule
@@ -337,6 +372,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.3.0}/compiler/spawnpoint/analyze.py

@@ -46,6 +46,7 @@ class Analysis:
     rules_source: str | None = None
     sprites: dict[str, SpriteSet] = field(default_factory=dict)  # entity -> resolved sprite sheet
     tiles_image: Any = None  # pixel-art tile atlas (PIL image), written to res://sprites/tiles.png
+    scenery_images: dict[str, Any] = field(default_factory=dict)  # name -> PIL image, written to res://sprites/<name>.png
 
     @property
     def ok(self) -> bool:
@@ -69,6 +70,7 @@ class _Analyzer:
         self.genre = GENRE_DEFAULTS[graph.genre]
         self.sprites: dict[str, SpriteSet] = {}
         self.tiles_image = None
+        self.scenery_images: dict[str, Any] = {}
 
     # -- entry -----------------------------------------------------------------------------
     def run(self) -> Analysis:
@@ -99,7 +101,7 @@ class _Analyzer:
         if not self.d.ok or data is None:
             return Analysis(g, self.d)
         plan = self._plan(data, teams, params_by_entity, players[0])
-        return Analysis(g, self.d, plan, rules.source, self.sprites, self.tiles_image)
+        return Analysis(g, self.d, plan, rules.source, self.sprites, self.tiles_image, self.scenery_images)
 
     # -- sprites ---------------------------------------------------------------------------
     def _resolve_sprites(self, teams: dict[str, str]) -> None:
@@ -110,7 +112,10 @@ class _Analyzer:
             try:
                 path = join_path("entities", name, "sprite")
                 sprite = sprite_resolve.resolve(name, ent, self.base_dir, color,
-                                                warn=lambda m, p=path: self.d.warning("W_AI_SPRITE", p, m))
+                                                warn=lambda m, p=path: self.d.warning("W_AI_SPRITE", p, m),
+                                                style=self.g.settings.art_style,
+                                                palette=self.g.settings.pixel_palette,
+                                                fine=self.g.settings.pixel_size == 1)
             except SpriteError as e:
                 self.d.error("E_SPRITE", join_path("entities", name, "sprite"), str(e),
                              "Generator kinds: " + ", ".join(sorted(sprite_resolve.KINDS)) if "kind" in str(e) else None)
@@ -120,6 +125,37 @@ class _Analyzer:
                 # No explicit shape: the body collision comes from the drawing.
                 ent.shape = sprite_resolve.derived_shape(ent, sprite, self.g.genre)
 
+    def _scenery(self, background: str) -> dict | None:
+        """Pixel-art backdrop images (written next to the sprites) and how the level should lay them out."""
+        s = self.g.settings
+        from .sprites import scenery as sc
+
+        if s.scenery == "space":  # scrolling stars for shooters, in any art style
+            sky, stars = sc.space(background, s.pixel_palette if s.art_style == "pixel" else None, s.seed)
+            self.scenery_images["scenery_sky"] = sc.to_image(sky)
+            layers = []
+            for name, image, speed in stars:
+                self.scenery_images[f"scenery_stars_{name}"] = sc.to_image(image)
+                layers.append({"name": name, "texture": f"res://sprites/scenery_stars_{name}.png", "speed": speed,
+                               "height": int(image.shape[0])})
+            return {"sky": "res://sprites/scenery_sky.png", "stars": layers, "pixel": 2, "width": sc.WIDTH}
+        if s.art_style != "pixel" or s.scenery == "flat" or s.tile_style != "pixel":
+            return None
+
+        theme = s.scenery if s.scenery in sc.THEMES else "auto"
+        if self.g.genre == "topdown":
+            self.scenery_images["scenery_floor"] = sc.to_image(sc.floor_tile(theme, background, s.pixel_palette, s.seed))
+            return {"floor": "res://sprites/scenery_floor.png", "pixel": 2}
+        sky, layers = sc.build(theme, background, s.pixel_palette, s.seed)
+        self.scenery_images["scenery_sky"] = sc.to_image(sky)
+        out = []
+        for layer in layers:
+            name = f"scenery_{layer.name}"
+            self.scenery_images[name] = sc.to_image(layer.image)
+            out.append({"name": layer.name, "texture": f"res://sprites/{name}.png", "scroll": layer.scroll,
+                        "anchor": layer.anchor, "lift": layer.lift, "height": int(layer.image.shape[0])})
+        return {"sky": "res://sprites/scenery_sky.png", "layers": out, "pixel": 2, "width": sc.WIDTH}
+
     # -- entities --------------------------------------------------------------------------
     def _team(self, e: Entity) -> str:
         if e.team:
@@ -331,11 +367,26 @@ class _Analyzer:
                       "top": (solid and solid.top) or self.genre["solid_top"]},
             "oneway": {"color": (oneway and oneway.color) or self.genre["oneway"]},
         }
+        variant_of: dict[tuple[int, int], int] = {}
         if s.tile_style == "pixel":
-            from .sprites.tiles import tileset
-            self.tiles_image = tileset(g.genre, tiles_style["solid"]["color"], tiles_style["solid"]["top"],
-                                       tiles_style["oneway"]["color"], ts, s.seed)
+            from .sprites.tiles import tileset_cartoon
+            if s.art_style == "pixel":
+                from .sprites.tiles import tileset_auto
+                # Pixel ground is drawn for each cell's real neighbours (grass on top, outlines, rounded corners).
+                self.tiles_image, kinds, variant_of = tileset_auto(
+                    g.genre, tiles_style["solid"]["color"], tiles_style["solid"]["top"], tiles_style["oneway"]["color"],
+                    ts, s.seed, s.pixel_palette, data.tiles, data.width, data.height, s.pixel_size)
+                tiles_style["variants"] = kinds
+            else:
+                self.tiles_image = tileset_cartoon(g.genre, tiles_style["solid"]["color"], tiles_style["solid"]["top"],
+                                                   tiles_style["oneway"]["color"], ts, s.seed)
             tiles_style["texture"] = "res://sprites/tiles.png"
+            tiles_style["smooth"] = s.art_style == "cartoon"
+            if s.art_style == "cartoon":
+                from .sprites.tiles import CARTOON_GAP
+                tiles_style["separation"] = CARTOON_GAP
+        background = s.background or self.genre["background"]
+        scenery_plan = self._scenery(background)
         return {
             "format": PLAN_FORMAT,
             "name": g.name,
@@ -344,11 +395,16 @@ class _Analyzer:
             "lives": s.lives,
             "viewport": list(s.viewport),
             "zoom": s.zoom,
-            "background": s.background or self.genre["background"],
+            "art_style": s.art_style,
+            "background": background,
+            **({"scenery": scenery_plan} if scenery_plan else {}),
             "gravity": s.gravity if s.gravity is not None else self.genre["gravity"],
             "tiles": tiles_style,
             "map": {"width": data.width, "height": data.height,
-                    "cells": [[x, y, k] for (x, y), k in sorted(data.tiles.items(), key=lambda kv: (kv[0][1], kv[0][0]))]},
+                    "cells": [[x, y, k] for (x, y), k in sorted(data.tiles.items(), key=lambda kv: (kv[0][1], kv[0][0]))],
+                    # parallel to cells: the atlas variant drawn for each one (neighbour-aware pixel tiles)
+                    **({"cell_variants": [variant_of[c] for c, _ in sorted(data.tiles.items(), key=lambda kv: (kv[0][1], kv[0][0]))]}
+                       if variant_of else {})},
             "bounds": [0, 0, data.width * ts, data.height * ts],
             "walls": self.genre["walls"],
             "entities": entities,

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

@@ -65,7 +65,8 @@ def build(data: Any, out_dir: Path, *, manifest: Manifest | None = None, smoke:
 
     t = time.perf_counter()
     feature = _godot_feature()
-    project.write(out_dir, data, plan, analysis.rules_source, feature, analysis.sprites, analysis.tiles_image)
+    project.write(out_dir, data, plan, analysis.rules_source, feature, analysis.sprites, analysis.tiles_image,
+                  analysis.scenery_images)
     sfx.write_all(out_dir / "sfx", seed=analysis.graph.settings.seed)
     timings["write"] = time.perf_counter() - t
 
@@ -142,5 +143,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.3.0}/compiler/spawnpoint/cli.py

@@ -73,20 +73,27 @@ 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)")
     gf.add_argument("--seconds", type=float, default=8.0)
     gf.add_argument("--fps", type=int, default=20)
     gf.add_argument("--width", type=int, default=640)
+    gf.add_argument("--skip", type=float, default=0.0, help="seconds of play before the clip starts")
 
     sp = sub.add_parser("sprites", help="import, generate or preview sprites")
     sps = sp.add_subparsers(dest="sprites_cmd", required=True)
@@ -130,7 +137,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 +215,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
@@ -237,11 +246,23 @@ def _gif(args) -> int:
     from .gif import record_gif
 
     out = args.out or args.project / "demo.gif"
-    path = record_gif(args.project.resolve(), out.resolve(), args.seconds, args.fps, args.width)
+    path = record_gif(args.project.resolve(), out.resolve(), args.seconds, args.fps, args.width, args.skip)
     print(f"Wrote {out} ({path.stat().st_size / 1e6:.1f} MB)")
     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