# Scene To Level

> Use when the user wants to go from a single scene reference image (a screenshot or concept art of how the final game should look) all the way to a playable Godot scene populated with the right assets and terrain. Orchestrates concept → asset pack → terrain → composition → scene assembly. Trigger on "build this scene", "make this playable", "I want a level that looks like this", "from a screenshot…

- **Type:** Skill
- **Install:** `agentstack add skill-summerengine-summer-engine-agent-scene-to-level`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [SummerEngine](https://agentstack.voostack.com/s/summerengine)
- **Installs:** 0
- **Category:** [Content & Media](https://agentstack.voostack.com/c/content-and-media)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [SummerEngine](https://github.com/SummerEngine)
- **Source:** https://github.com/SummerEngine/summer-engine-agent/tree/main/skills/level-design/scene-to-level
- **Website:** https://summerengine.com/

## Install

```sh
agentstack add skill-summerengine-summer-engine-agent-scene-to-level
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# scene-to-level — From a reference image to a playable scene

This is the **orchestrator** skill. It doesn't generate art, doesn't slice sheets, doesn't write game code — it routes the user through the chain of skills that do, and stitches their outputs together into a placeable Godot scene.

Use it when the user shows you a screenshot or concept image and says "build this." The output is a `.tscn` you can hit play on, populated with assets that match the reference's style.

## The pipeline (decision tree)

```
1. Read the reference image (vision).
   └── What kind of scene is it?
        ├─ 2D top-down / isometric / side-scroller
        │   └── route to TERRAIN + 2D ASSETS path
        ├─ 3D third-person / first-person
        │   └── route to 3D ASSETS path (out of scope for this skill —
        │       use summer:3d-assets/ subskills directly)
        └─ UI-only screen (menu, HUD)
            └── route to UI ASSETS path (just plan-asset-pack)

2. For each visible element, route to the right sub-pipeline:

   TERRAIN  → summer:2d-assets/tileable-texture
              (auto-tiling Wang / 47-tile sheet; CURRENTLY a placeholder
              that generates a single tile — full auto-tile work is
              tracked in publicsummerengine/Docs/assetCreation/
              TERRAIN_AUTOTILE_IDEA.md and not yet built)

   PROPS / DECOR / LIGHTING / NATURE / WATER / BUILDINGS / UI / VFX
       ── If user has time for individual generation, prefer:
       │   summer:2d-assets/create-asset-sheet (Plan + Generate Pack
       │   mode at /studio/plan-asset-pack — higher quality, each asset
       │   gets full model attention)
       └── If user wants fast / exploratory:
           summer:2d-assets/create-asset-sheet (Slice from a sheet at
           /studio/create-tileset — one sheet, autoslice, cheaper)

   CHARACTERS → summer:2d-assets/character-portrait first for the static
                frame, then summer:2d-assets/sprite-sheet for animation

3. Once assets exist, USE-WIDGET-ASSET on any UI / panel / bar /
   toggle pack files to wire them as NinePatchRect / TextureProgressBar
   / etc. (see summer:2d-assets/use-widget-asset)

4. Compose the scene:
   - summer_create_scene with a Node2D / Control root depending on the
     scene type
   - Add a TileMap node for terrain; assign the generated tileset
     resource
   - Place props as Sprite2D / TextureRect children, positioned to
     match the reference's composition
   - Wire UI as Control nodes anchored to the viewport

5. Validate:
   - summer_get_script_errors
   - summer_play (the user takes over from here)
```

## When to use

- "Make this screenshot playable."
- "I want a level that looks exactly like this concept art."
- "Build a Japanese village scene like this reference."
- "I have a UI mockup — implement it."

## When NOT to use

- The user wants a **single asset** → `summer:2d-assets/pixel-art` or a leaf skill directly.
- The user wants to **design** a level from scratch (gameplay beats, pacing, encounters) → `summer:level-design/design-level`. This skill is post-design — it implements a known visual target.
- The user wants a **3D level** → use `summer:3d-assets/` subskills directly; the orchestration for 3D scenes isn't in this skill yet.
- The user wants a **playable prototype with mechanics already** → mechanics aren't in scope. This skill produces the *visuals*; the mechanic skills (e.g. `summer:gameplay-mechanics/design-mechanic`) handle behavior.

## Required up-front

Before starting, you need either:

1. A reference image (URL or local file) the user provides, OR
2. A vivid text description of the target scene from the user

If neither is offered, stop and ask. Don't guess what a "japanese village scene" looks like — get the reference first.

## Honest reliability map

| Pipeline node | Reliability | Cost (rough) | What can go wrong |
|---|---|---|---|
| Reading the reference (vision call) | High | $0.02 | Model misidentifies the scene type |
| Plan + Generate Pack (theme → per-asset) | High for props / icons / UI | $0.10–0.50 per pack | Style drift across items if no style ref |
| Slice from a sheet (single-sheet path) | Medium for dense sheets | $0.08 + upscales | Touching sprites merge into one slice |
| Tileable terrain (auto-tile) | LOW today — not built. | n/a | Use a single tile placeholder or stitch by hand |
| Sprite-sheet animation | Medium — see that skill's own honesty section | varies | Frame consistency is the hard part |
| Scene assembly via `summer_*` tools | High | free | Engine must be running |

Surface this map to the user when relevant — don't claim "ready to play in 10 minutes" if terrain auto-tiling is what they actually need.

## A worked example

User shows you a screenshot of a Japanese village with multiple islands, water between them, buildings, characters, and a bottom palette UI:

1. **Vision pass** identifies the scene as 2D isometric with: water terrain (large area), grass terrain (per island), buildings (5+ distinct), characters (2), UI palette + toolbar.
2. **Plan the props pack** via the create-asset-sheet planner: 12 props at minimum (torii, sakura, lantern, pagoda, bridge, well, sign, banner, bucket, hay, fence, crate). Generated per-asset for quality.
3. **Plan the buildings pack**: 5 distinct buildings (small house, barn, shop, pagoda, watchtower).
4. **Generate terrain**: today, single grass tile + single water tile + edge variant placeholders. Full Wang-tile auto-tiling is the TERRAIN_AUTOTILE_IDEA.md unbuilt path.
5. **Plan the UI pack** via the planner with theme "isometric voxel game UI: bottom palette, toolbar with Place/Erase/Pan/Save/Reset, asset category tabs, instruction panel."
6. **For each UI slice that's a panel / button**, use `summer:2d-assets/use-widget-asset` to wire as NinePatchRect.
7. **Compose**: TileMap for terrain; Sprite2D placement matching the reference; Control nodes for the UI.
8. **Validate + hand off**.

Total wall-clock: maybe 30 min for the asset packs (parallel), another 15 for scene composition. NOT a five-minute thing.

## What this skill explicitly defers

- **3D scene assembly.** Out of scope; use `summer:3d-assets/` directly until a 3D variant of this orchestrator exists.
- **Auto-tiling terrain.** The pipeline node exists in the decision tree but the leaf skill that implements it is not built — see `publicsummerengine/Docs/assetCreation/TERRAIN_AUTOTILE_IDEA.md`.
- **Animation orchestration.** Per-character `summer:2d-assets/sprite-sheet` is invoked manually; no auto-pairing of characters with their animation pipelines yet.
- **Gameplay code.** Player movement, interactions, win conditions — those are level-design + gameplay-mechanics skills, not this one.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [SummerEngine](https://github.com/SummerEngine)
- **Source:** [SummerEngine/summer-engine-agent](https://github.com/SummerEngine/summer-engine-agent)
- **License:** MIT
- **Homepage:** https://summerengine.com/

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-summerengine-summer-engine-agent-scene-to-level
- Seller: https://agentstack.voostack.com/s/summerengine
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.