router

interface:
  display_name: "Game Development Router"
  short_description: "Route game work to focused expert skills"
  default_prompt: "Use $router to choose the smallest useful skill set for this game-development task."

# Engine detection — full project fingerprint

The router body carries the primary signal per engine; this file holds the **complete**
fingerprint table, the disambiguation rules, and the secondary signals. Detection is
**exclusive**: pick exactly one engine skill set (or "unknown" and use the fallback).

Scan for the highest-confidence signal and stop at the first match in this precedence order.

| # | Engine | Primary signal (project files) | Secondary signals | Skill set root |
|:-:|--------|--------------------------------|-------------------|----------------|
| 1 | Godot | `project.godot` | `*.tscn`, `*.gd`, `*.gdshader`, `*.tres`, `export_presets.cfg` | `skills/godot/` |
| 2 | Unreal | `*.uproject` | `Source/**/*.Build.cs`, `Config/Default*.ini`, `*.uasset`, `Content/` | `skills/unreal/` |
| 3 | Unity | `Assets/` **and** `ProjectSettings/ProjectVersion.txt` | `*.unity`, `*.prefab`, `*.asmdef`, `Packages/manifest.json` | `skills/unity/` |
| 4 | Bevy | `Cargo.toml` with a `bevy` dependency | `*.rs` with `App::new()` / `use bevy::prelude` | `skills/other-engines/bevy-ecs/` |
| 5 | Phaser | `package.json` dep `phaser` | `import Phaser`, `new Phaser.Game` | `skills/web-engines/phaser-core`, `skills/web-engines/phaser-arcade-physics` |
| 6 | PixiJS | `package.json` dep `pixi.js` | `import * as PIXI`, `new PIXI.Application` | `skills/web-engines/pixijs-rendering/` |
| 7 | three.js | `package.json` dep `three` | `import * as THREE`, `*.gltf` / `*.glb` | `skills/web-engines/threejs-scene-setup`, `threejs-gltf-loading`, `threejs-materials-lighting` |
| 8 | LÖVE | `conf.lua`, or `main.lua` calling `love.*` | `*.love` | `skills/other-engines/love2d-core/` |
| 9 | pygame | `*.py` with `import pygame` | `pygame.init()`, `pygame.display.set_mode` | `skills/other-engines/pygame-core/` |
| 10 | Roblox | `*.rbxl` / `*.rbxlx`, or `*.project.json` (Rojo) | `*.luau`, `DataStoreService`, `game:GetService` | `skills/other-engines/roblox-luau`, `roblox-datastores` |

## Detect the installed version

Engine identity is not enough. Read the version source before using version-sensitive APIs:

| Stack | Version source |
|-------|----------------|
| Godot | feature tags in `project.godot`, then the project's documented toolchain or `godot --version` when available |
| Unity | `ProjectSettings/ProjectVersion.txt` plus package versions in `Packages/manifest.json` / `packages-lock.json` |
| Unreal | `EngineAssociation` in `*.uproject`, project documentation, or the selected installed engine |
| Phaser / PixiJS / three.js | `package.json` **and the resolved lockfile**, not a tutorial's version |
| Bevy | `Cargo.toml` and the resolved `Cargo.lock` entry |
| pygame-ce | `pyproject.toml`, requirements/lock files, then the active environment |
| LÖVE | `conf.lua` version when declared, then the installed runtime |
| Roblox | platform APIs are rolling; inspect current Creator Hub documentation for unstable APIs |

For a new project use the baseline in `../../docs/VERSION-SUPPORT.md`. For an existing project,
preserve the detected version unless the user explicitly requests migration.

## Disambiguation rules (must-handle ambiguities)

- **Godot C# vs Unity vs Bevy** — all may contain a `.csproj` or `Cargo.toml`. The presence of
  `project.godot` means **Godot** (route `godot-csharp` for C# work) even when a `.csproj`
  exists. Unity requires the `Assets/` + `ProjectSettings/` pair, not just any `.cs`. Bevy
  requires a `bevy` dependency, not just any Rust crate.
- **Multiple web deps** — a `package.json` may list more than one of `phaser` / `pixi.js` /
  `three`. Prefer the library actually imported in the file under discussion; if unclear, ask
  which renderer the task targets before loading a web-engine skill.
- **Monorepo / multiple engines** — if more than one engine fingerprint is present, route by the
  file or subdirectory the request is about. If still ambiguous, ask one targeted question.
- **No engine files at all** — go to the unknown-engine fallback (router body §6). Many
  discipline / genre / workflow tasks need no engine at all.

## Plain-text engine mentions

If there are no project files but the request names an engine in prose ("in Unity", "using
Phaser", "a Godot game"), adopt that engine. Never load an engine skill on a guess when neither
a file signal nor a named engine is present.

## Confidence boosters from task files

Some non-project files raise confidence about the *task* (not the engine):

- `*.yarn` / `*.ink` → `dialogue-systems` (and `visual-novel` if the whole game is one).
- `steam_appid.txt` / Steamworks SDK → `steam-publish`.
- `.itch.toml` / `butler` usage → `itch-publish`.
- `*.inputactions` → `unity-input-system`; `IA_`/`IMC_` assets → `unreal-enhanced-input`.
- `NavMesh.asset` / baked navmesh → `unity-navmesh`; `BT_`/`BB_` assets → `unreal-behavior-trees`.

# Full routing table — every authored skill

The exhaustive `task → category → skill` lookup the router body summarizes. Every name here is
a real folder at `skills/<category>/<name>/SKILL.md`. Trigger words (`says:`) and file signals
(`files:`) are the cues that should select each skill. `*` in a binding is filled with the
**detected** engine (router body §1); where an engine lacks the exact skill, see "Binding gaps".

## Engine skills

### Godot (`skills/godot/`, target Godot 4.7) — read after `project.godot` is detected

| Skill | Pick it when the request says / file signal |
|-------|---------------------------------------------|
| `godot-gdscript` | "GDScript", `_ready`/`_process`, typing, `@export`, `await`; `*.gd` |
| `godot-nodes-scenes` | "scene", "node tree", "instance a scene", autoloads, `PackedScene`; `*.tscn` |
| `godot-signals-groups` | "signal", "emit", "connect", "groups", decoupling/observer |
| `godot-2d-movement` | "2D movement", "platformer controller", `CharacterBody2D`, `move_and_slide` |
| `godot-tilemap` | "tilemap", "tileset", "autotile", `TileMapLayer`; tileset `*.tres` |
| `godot-physics` | "rigidbody", "area2d", "collision layer", "raycast" (2D + 3D) |
| `godot-ui-control` | "UI", "Control node", "anchors", "theme", "HUD" |
| `godot-animation` | `AnimationPlayer`, `AnimationTree`, "blend", `Tween` |
| `godot-shaders` | "Godot shader", "gdshader", fragment/vertex, screen-reading; `*.gdshader` |
| `godot-3d-essentials` | "3D", `Camera3D`, `WorldEnvironment`, `GridMap`; `Node3D` |
| `godot-resources` | "custom Resource", "data resource", `.tres`, `ResourceLoader` |
| `godot-audio` | "Godot audio", "audio bus", "play sound/music", sync-to-beat |
| `godot-multiplayer` | "multiplayer", "RPC", "networked", `MultiplayerSpawner`; `@rpc` |
| `godot-export` | "export Godot", "build for web/windows", `export_presets.cfg` |
| `godot-csharp` | "Godot C#", "GodotSharp", "C# signals in Godot"; `*.cs` + `*.csproj` in a Godot project |
| `godot-gdscript-headless-testing` | "headless test", "run tests from CLI", `godot --headless --script`, CI job for `.gd` tests |

### Unity (`skills/unity/`, target Unity 6.3 LTS / 6000.3)

| Skill | Pick it when |
|-------|--------------|
| `unity-csharp-scripting` | "Unity script", `MonoBehaviour`, `Start`/`Update`, coroutines; `*.cs` + `*.asmdef` |
| `unity-input-system` | "Input System", `InputAction`, "action map"; `*.inputactions` |
| `unity-physics` | "Unity physics", `Rigidbody`, "collision layers", "joint" |
| `unity-animation` | "Animator", "state machine", "blend tree", "Mecanim"; `*.controller` |
| `unity-scriptableobjects` | `ScriptableObject`, "SO architecture", "data asset", event channels |
| `unity-tilemap-2d` | "Unity tilemap", "tile palette", "rule tile" |
| `unity-navmesh` | `NavMesh`, `NavMeshAgent`, "pathfinding in Unity" |
| `unity-build-pipeline` | "build Unity", "player settings", "IL2CPP", "Addressables" |

### Unreal (`skills/unreal/`, target UE 5.8)

| Skill | Pick it when |
|-------|--------------|
| `unreal-blueprints` | "Blueprint", "BP graph", "event graph"; Blueprint `*.uasset` |
| `unreal-cpp-gameplay` | "Unreal C++", `GameMode`, `Pawn`, `ACharacter`; `Source/**/*.cpp` + `*.Build.cs` |
| `unreal-enhanced-input` | "Enhanced Input", "Input Mapping Context", `IA_`/`IMC_` |
| `unreal-behavior-trees` | "Behavior Tree", "Blackboard", `AIController`, `BTTask`; `BT_`/`BB_` |
| `unreal-niagara` | "Niagara", "VFX", "particle system"; `NS_`/`NE_` |
| `unreal-packaging` | "package Unreal", "cook content", "shipping build" |

### Web engines (`skills/web-engines/`) — detected from `package.json` + imports

| Skill | Pick it when |
|-------|--------------|
| `phaser-core` | "Phaser", "Phaser scene", `preload`/`create`/`update`; dep `phaser` |
| `phaser-arcade-physics` | "Arcade Physics", "collider", "overlap", world bounds |
| `pixijs-rendering` | "PixiJS", "Pixi sprite", "stage", `Container`; dep `pixi.js` |
| `threejs-scene-setup` | "three.js", `THREE.Scene`, `WebGLRenderer`, render loop; dep `three` |
| `threejs-gltf-loading` | "load gltf", `GLTFLoader`, `AnimationMixer`; `*.gltf`/`*.glb` |
| `threejs-materials-lighting` | `MeshStandardMaterial`, "lighting", "shadows", env maps |

### Other engines (`skills/other-engines/`)

| Skill | Pick it when |
|-------|--------------|
| `bevy-ecs` | "Bevy", "ECS system/query", `Commands`, "Bevy plugin"; `Cargo.toml` dep `bevy` |
| `pygame-core` | "pygame", "blit", "sprite group", game loop; `import pygame` |
| `love2d-core` | "LÖVE", "love2d", `love.draw`, `love.update(dt)`; `main.lua`/`conf.lua`/`*.love` |
| `roblox-luau` | "Roblox", "Luau", `RemoteEvent`, services; `*.luau` + `*.rbxl(x)` / Rojo |
| `roblox-datastores` | "DataStore", "save player data", `GetDataStore`; `DataStoreService` |
| `roblox-ui` | Roblox HUD/menu/inventory/shop, `ScreenGui`, `PlayerGui`, `UDim2`, `AutomaticSize`, `GuiService`, UI clipping/respawn, touch/gamepad focus, generic generated UI |
| `roblox-networking` | Roblox remotes/security/replication, `RemoteEvent`, `RemoteFunction`, `UnreliableRemoteEvent`, exploit, request spam, server authority, desync |
| `roblox-characters` | Roblox character/respawn/rig/movement/animation, `CharacterAdded`, `Humanoid`, `Animator`, R6/R15, Tool, stale character reference |
| `roblox-physics` | Roblox assembly/constraint/collision/query/ownership, `RaycastParams`, overlap, `CanQuery`, impulse, BodyMover, projectile/vehicle/knockback |
| `roblox-studio-workflow` | edit/inspect/test a Roblox place in Studio, Explorer, Script/LocalScript/ModuleScript placement, tags/Attributes, duplicate remotes/systems, Server & Clients, Output |

## Disciplines (`skills/disciplines/`) — cross-engine concepts, load **with** the engine skill

| Concept skill | `says:` triggers | Pairs with (engine API skill) |
|---------------|------------------|-------------------------------|
| `create-game-assets` | art direction, game assets, sprite/sprite sheet, tileset, texture, icon, concept art, 3D prop, consistent style | engine importer/rendering skill; installed `imagegen` for raster generation when available |
| `game-ai` | enemy AI, behavior tree, state machine, steering, pathfinding | `unity-navmesh` / `unreal-behavior-trees` / Godot nav (`godot-nodes-scenes` + `godot-physics`) |
| `ai-behavior-trees-utility-ai` | behavior tree runtime, blackboard, action/condition node, selector/sequence/parallel, decorator, utility AI, scoring/response curve, consideration, hybrid AI | `game-ai` (FSM/BT/steering choice) / `unreal-behavior-trees` (engine BT/Blackboard assets) |
| `procedural-gen` | procedural generation, perlin/simplex noise, random seed, dungeon generator | engine tilemap/grid: `godot-tilemap` / `unity-tilemap-2d` / `godot-3d-essentials` |
| `dialogue-systems` | dialogue system, branching dialogue, Yarn Spinner, Ink, conversation tree; `*.yarn`/`*.ink` | engine UI: `godot-ui-control` / Unity UI |
| `save-systems` | save system, save/load, persistence, save slots; `save*.json`/`*.sav` | `roblox-datastores` / Godot IO / engine serialization |
| `audio-design` | audio design, adaptive music, audio mixer, ducking, SFX | `godot-audio` / Unity AudioMixer |
| `shader-programming` | shader, fragment shader, dissolve/outline effect, GLSL/HLSL; `*.gdshader`/`*.shader`/`*.hlsl` | `godot-shaders` / engine material docs |
| `physics-tuning` | physics feel, jitter/tunneling, fixed timestep, collision tuning | `godot-physics` / `unity-physics` |
| `level-design` | level design, whitebox/blockout, tilemap layout, pacing | `godot-tilemap` / `unity-tilemap-2d` / `godot-3d-essentials` (GridMap) |
| `input-systems` | input mapping, rebind controls, gamepad support, input buffering; `*.inputactions`/IMC | `unity-input-system` / `unreal-enhanced-input` / Godot InputMap |
| `game-feel` | game feel, juice, screen shake, hit-stop/freeze frame, squash & stretch, knockback, "make it punchy/satisfying" | engine animation/tween (`godot-animation`/`unity-animation`) + `camera-systems` (shake) + `audio-design` |
| `camera-systems` | camera follow, follow camera, deadzone, look-ahead, camera bounds/limits, third-person/orbit camera, first-person look, Cinemachine, camera jitter | `godot-2d-movement`/`godot-3d-essentials` / Unity Cinemachine 3 / Godot `Camera2D`/`Camera3D` |
| `game-ui-ux` | HUD, health bar, main/pause/settings menu, UI layout, anchors, UI scaling, aspect ratio, safe area, controller/keyboard menu nav | `godot-ui-control` / Unity UI (UGUI/UI Toolkit) |
| `performance-optimization` | performance, optimize, low/dropping FPS, frame drops, stutter, lag, frame budget, draw calls, batching, GC spikes, object pooling, profiler | engine profiler (Godot Monitors / Unity Profiler / Unreal `stat unit`) + `physics-tuning` |

## Genres (`skills/genres/`) — whole-game templates, **compose** engine + disciplines

| Genre skill | `says:` triggers | composes (bind `*` to the detected engine) |
|-------------|------------------|---------------------------------------------|
| `platformer` | platformer, jump mechanic, double jump, Mario-like | `godot-2d-movement` (or engine physics) + `godot-tilemap`/`unity-tilemap-2d` + `level-design` + `camera-systems` + `game-feel` |
| `roguelike` | roguelike, procedural dungeon, permadeath, turn-based grid | `procedural-gen` + `godot-tilemap`/`unity-tilemap-2d` + `game-ai` + `save-systems` + `game-feel` |
| `rpg` | RPG, stats/leveling, inventory, quest system | `godot-resources`/`unity-scriptableobjects` + `dialogue-systems` + `save-systems` + `game-ui-ux` |
| `fps-shooter` | FPS, first-person shooter, hitscan, aim/shoot | `godot-3d-essentials`/`unreal-cpp-gameplay` + `input-systems` + `game-ai` + `camera-systems` + `game-feel` |
| `tower-defense` | tower defense, wave spawner, enemy path, tower targeting | `game-ai` + `godot-2d-movement`/engine movement + `level-design` + `game-ui-ux` |
| `card-game` | card game, deckbuilder, hand/deck/discard, TCG | `godot-resources`/`unity-scriptableobjects` + `game-ui-ux` + `godot-ui-control` (engine UI) |
| `visual-novel` | visual novel, VN, branching story, choice menu; `*.ink`/`*.yarn` | `dialogue-systems` + `save-systems` + `game-ui-ux` |
| `survival-crafting` | survival game, crafting system, inventory, resource gathering | `save-systems` + `godot-resources`/`unity-scriptableobjects` + `procedural-gen` + `game-ui-ux` |
| `puzzle` | puzzle game, match-3, grid logic, tile-matching | `godot-tilemap`/`unity-tilemap-2d` + `level-design` + `game-feel` |

## Workflows (`skills/workflows/`) — process & shipping, engine-independent

| Workflow skill | `says:` / `files:` triggers |
|----------------|------------------------------|
| `game-jam` | game jam, 48-hour game, Ludum Dare / GMTK, jam submission |
| `prototype-fast` | prototype fast, vertical slice, MVP game, greybox |
| `steam-publish` | publish on Steam, Steamworks, store page, depot/build upload; `steam_appid.txt` |
| `itch-publish` | publish on itch, itch.io page, `butler push`, upload build; `.itch.toml` |

## Binding gaps (be honest; do not fabricate a skill)

The collection does not yet have a skill for every engine × concept. Several cross-cutting
concerns are now covered **engine-neutrally** by disciplines that pair with any detected engine —
camera work (`camera-systems`), HUD/menus (`game-ui-ux`), juice/feedback (`game-feel`), and
performance (`performance-optimization`) — so those are no longer gaps; bind them on top of the
engine. The remaining true gaps are engine-specific primitives. When a genre binding names a slot
the detected engine lacks, load the closest skill(s) and **state the gap** plainly:

- **No `*-2d-movement` for Unity / Unreal / web.** For a Unity platformer, bind movement to
  `unity-csharp-scripting` + `unity-physics`; for Phaser, `phaser-arcade-physics`. Say there is
  no dedicated `unity-2d-movement` skill.
- **No dedicated 3D-essentials for Unity.** For a Unity FPS, use `unity-csharp-scripting` +
  `unity-physics` + `unity-navmesh`; only Godot has `godot-3d-essentials` and Unreal has
  `unreal-cpp-gameplay`.
- **No `*-tilemap` for web / Bevy / pygame / Roblox / LÖVE.** Use `level-design` for the concept
  and the engine's rendering skill for drawing; note the missing engine tilemap skill.
- **No engine-specific save skill except Roblox.** `save-systems` owns the concept and cites
  Godot IO; `roblox-datastores` is the one engine-specific persistence skill.

---
name: router
description: >
  Routes any game-development request to the right specialized skill(s): it detects the engine
  (Godot, Unity, Unreal, Bevy, Phaser, PixiJS, three.js, LÖVE, pygame, Roblox) and the task, then
  reads the chosen skill before acting. Use to make a game or to decide which skill applies — for
  players, levels, enemies, shaders, art direction, sprites, tiles, textures, 3D assets, UI/UX,
  cameras, game feel, physics, input, audio, saving, multiplayer, AI, dialogue, procedural
  generation, or performance, for genres (platformer,
  roguelike, RPG, FPS, tower-defense, card game, visual novel, survival-crafting, puzzle), and for
  shipping (game jam, Steam, itch). Start here
  when unsure which gamedev skill to use.
---

# Master Router — Game-Development Skill Dispatcher

The entry point for game-development work. It fingerprints the project to pick **one** engine,
classifies the task from the request, names the **minimal** set of specialized skills, and tells
you to read them before acting. It **dispatches and composes** — it does not re-teach engine APIs.

## When to use

- Use at the **start of any game-development request** — building or debugging a game, level,
  player, enemy, shader, UI, save system, multiplayer, input, audio, AI, dialogue, procedural
  content, or visual asset set — to decide which skill(s) to load.
- Use when the user names an engine or genre, says "make a game", or asks "which skill should I
  use?".

**When *not* to use:** once the right skill is loaded and the task is squarely inside it, work
from that skill — don't re-run the router every turn. Re-route only when the task **pivots** to a
new engine or concern (router step 6).

## Routing algorithm

1. **Detect engine and version** — project fingerprint → at most one engine skill set (or
   "unknown"), then read the project's version source. §1.
2. **Classify task** — phrasing → discipline(s) + at most one genre + workflow(s). §2.
3. **Resolve** — the minimal set: engine skill(s) + discipline(s) + genre + workflow(s). §3.
4. **Read (disclosure)** — open only the chosen `SKILL.md` bodies; `references/` only on demand. §4.
5. **Compose** — order: engine fundamentals → discipline concept → genre glue → workflow. §5.
6. **Fallback** — engine unknown or no skill fits → ask or default to Godot; state any gap. §6.

---

## 1. Engine detection (project fingerprint)

Scan for the highest-confidence signal; **choose exactly one** engine. Stop at the first match.

| # | Engine | Primary signal | Skill set root |
|:-:|--------|----------------|----------------|
| 1 | Godot | `project.godot` | `skills/godot/` |
| 2 | Unreal | `*.uproject` | `skills/unreal/` |
| 3 | Unity | `Assets/` **and** `ProjectSettings/ProjectVersion.txt` | `skills/unity/` |
| 4 | Bevy | `Cargo.toml` with a `bevy` dependency | `skills/other-engines/bevy-ecs/` |
| 5 | Phaser | `package.json` dep `phaser` | `skills/web-engines/phaser-*` |
| 6 | PixiJS | `package.json` dep `pixi.js` | `skills/web-engines/pixijs-rendering/` |
| 7 | three.js | `package.json` dep `three` | `skills/web-engines/threejs-*` |
| 8 | LÖVE | `conf.lua` / `main.lua` calling `love.*` | `skills/other-engines/love2d-core/` |
| 9 | pygame | `*.py` with `import pygame` | `skills/other-engines/pygame-core/` |
| 10 | Roblox | `*.rbxl(x)` / `*.project.json` (Rojo) | `skills/other-engines/roblox-*` |

For secondary signals, the Godot-C#/Unity/Bevy and multi-web disambiguation rules, monorepos,
and plain-text engine mentions, read `references/engine-detection.md`.

After identifying the engine, read its version from project metadata or dependency locks before
choosing APIs. Existing projects keep their pinned version unless migration is requested; the
catalog baseline is only for new projects. The exact version sources are in the detection reference
and `../docs/VERSION-SUPPORT.md`.

## 2. Task classification (phrasing → category)

After the engine, read the request for task signals (three **additive** categories):

- **disciplines** (cross-engine concepts): `create-game-assets`, `game-ai`, `ai-behavior-trees-utility-ai`, `procedural-gen`, `dialogue-systems`,
  `save-systems`, `audio-design`, `shader-programming`, `physics-tuning`, `level-design`,
  `input-systems`, `game-feel`, `camera-systems`, `game-ui-ux`, `performance-optimization`.
  Triggered by concept words ("sprite sheet", "art direction", "texture", "pathfinding",
  "save slots", "fragment shader", "screen shake", "camera follow", "HUD/menu",
  "optimize/low FPS").
- **genres** (whole-game templates): `platformer`, `roguelike`, `rpg`, `fps-shooter`,
  `tower-defense`, `card-game`, `visual-novel`, `survival-crafting`, `puzzle`. Triggered by genre
  words ("make a roguelike", "deckbuilder").
- **workflows** (process/shipping): `game-jam`, `prototype-fast`, `steam-publish`,
  `itch-publish`. Triggered by process words ("publish on Steam", "vertical slice").

File signals sharpen this: `*.yarn`/`*.ink` → `dialogue-systems`/`visual-novel`; `steam_appid.txt`
→ `steam-publish`; `*.inputactions` → `unity-input-system`.

## 3. Routing table (task → category → skill)

### 3a. Engine skills — read the one matching the detected engine + sub-task

- **Godot** (`skills/godot/`): language `godot-gdscript` / `godot-csharp`; structure
  `godot-nodes-scenes`, `godot-signals-groups`; 2D `godot-2d-movement`, `godot-tilemap`; 3D
  `godot-3d-essentials`; physics `godot-physics`; UI `godot-ui-control`; animation
  `godot-animation`; shaders `godot-shaders`; data `godot-resources`; audio `godot-audio`;
  netcode `godot-multiplayer`; headless CLI tests `godot-gdscript-headless-testing`; ship
  `godot-export`.
- **Unity** (`skills/unity/`): scripting `unity-csharp-scripting`; input `unity-input-system`;
  physics `unity-physics`; animation `unity-animation`; data `unity-scriptableobjects`; 2D
  `unity-tilemap-2d`; AI nav `unity-navmesh`; ship `unity-build-pipeline`.
- **Unreal** (`skills/unreal/`): visual scripting `unreal-blueprints`; C++ gameplay
  `unreal-cpp-gameplay`; input `unreal-enhanced-input`; AI `unreal-behavior-trees`; VFX
  `unreal-niagara`; ship `unreal-packaging`.
- **Web** (`skills/web-engines/`): `phaser-core`, `phaser-arcade-physics`; `pixijs-rendering`;
  `threejs-scene-setup`, `threejs-gltf-loading`, `threejs-materials-lighting`.
- **Other** (`skills/other-engines/`): `bevy-ecs`, `pygame-core`, `love2d-core`; Roblox foundation
  `roblox-luau`, persistence `roblox-datastores`, UI `roblox-ui`, remotes/security
  `roblox-networking`, character lifecycle `roblox-characters`, simulation/queries
  `roblox-physics`, and in-Studio operation `roblox-studio-workflow`.

### 3b. Disciplines — load **with** the engine skill (concept ↔ engine API)

| Concept (`says:`) | Discipline skill | Pairs with (engine API) |
|-------------------|------------------|-------------------------|
| art direction, game assets, sprites, tilesets, textures, icons, 3D props | `create-game-assets` | engine importer/rendering skill; `imagegen` when available |
| enemy AI, behavior tree, pathfinding, steering | `game-ai` | `unity-navmesh` / `unreal-behavior-trees` / Godot nav |
| BT runtime, blackboard, decorator, selector/sequence, utility AI, response curve, consideration | `ai-behavior-trees-utility-ai` | `game-ai` (model choice) / `unreal-behavior-trees` (engine assets) |
| procedural, noise, seed, dungeon generator | `procedural-gen` | engine tilemap/grid skill |
| dialogue, Yarn, Ink, conversation tree | `dialogue-systems` | engine UI skill |
| save/load, slots, persistence | `save-systems` | `roblox-datastores` / engine IO |
| adaptive music, mixer, ducking, SFX | `audio-design` | `godot-audio` / Unity AudioMixer |
| shader, fragment, dissolve/outline | `shader-programming` | `godot-shaders` / engine material |
| jitter, tunneling, fixed timestep | `physics-tuning` | `godot-physics` / `unity-physics` |
| whitebox, blockout, tile layout, pacing | `level-design` | `godot-tilemap` / `unity-tilemap-2d` |
| rebind, gamepad, input buffering | `input-systems` | `unity-input-system` / `unreal-enhanced-input` / Godot InputMap |
| screen shake, hit-stop, juice, squash & stretch, "make it punchy" | `game-feel` | engine animation/tween + `camera-systems` (shake) |
| camera follow, deadzone, look-ahead, orbit, first-person | `camera-systems` | `godot-2d-movement` / `godot-3d-essentials` / Cinemachine |
| HUD, menu, UI layout, scaling, safe area, focus nav | `game-ui-ux` | `godot-ui-control` / Unity UI (UGUI/UI Toolkit) |
| low FPS, optimize, draw calls, GC spike, pooling, profiler | `performance-optimization` | engine profiler + `physics-tuning` |

For Roblox, compose cross-engine concepts with the focused engine skill: HUD/menu requests use
`roblox-ui` + `game-ui-ux` (+ `input-systems` for gameplay bindings); remote exploit or
replication requests use `roblox-networking` + `roblox-luau`; respawn/rig requests use
`roblox-characters`; physical simulation/query requests use `roblox-physics` (+
`physics-tuning` for stability); direct place editing also uses `roblox-studio-workflow`.

### 3c. Genres — **compose** engine + disciplines (bind `*` to the detected engine)

| Genre (`says:`) | composes |
|-----------------|----------|
| platformer, jump, double jump | `godot-2d-movement` (or engine physics) + `godot-tilemap`/`unity-tilemap-2d` + `level-design` + `camera-systems` + `game-feel` |
| roguelike, procedural dungeon, permadeath | `procedural-gen` + `godot-tilemap`/`unity-tilemap-2d` + `game-ai` + `save-systems` + `game-feel` |
| RPG, stats, inventory, quests | `godot-resources`/`unity-scriptableobjects` + `dialogue-systems` + `save-systems` + `game-ui-ux` |
| FPS, first-person, hitscan | `godot-3d-essentials`/`unreal-cpp-gameplay` + `input-systems` + `game-ai` + `camera-systems` + `game-feel` |
| tower defense, waves, lanes | `game-ai` + engine movement + `level-design` + `game-ui-ux` |
| card game, deckbuilder, TCG | `godot-resources`/`unity-scriptableobjects` + `game-ui-ux` (+ engine UI) |
| visual novel, branching story | `dialogue-systems` + `save-systems` + `game-ui-ux` |
| survival, crafting, gathering | `save-systems` + `godot-resources`/`unity-scriptableobjects` + `procedural-gen` + `game-ui-ux` |
| puzzle, match-3, grid logic | `godot-tilemap`/`unity-tilemap-2d` + `level-design` + `game-feel` |

### 3d. Workflows — engine-independent process & shipping

`game-jam` (jam, 48-hour, Ludum Dare/GMTK) · `prototype-fast` (vertical slice, MVP, greybox) ·
`steam-publish` (Steam, Steamworks, depot; `steam_appid.txt`) · `itch-publish` (itch.io, butler;
`.itch.toml`).

For the exhaustive per-skill trigger list and every engine binding, read
`references/routing-table.md`.

## 4. Read protocol (progressive disclosure)

1. **Preloaded:** only each skill's `name` + `description` are in context. Decide from those plus
   the fingerprint — do **not** pre-read bodies.
2. **On selection:** read the body of **each chosen** `skills/<category>/<name>/SKILL.md` — and
   only those. Never bulk-load a whole category.
3. **On demand:** read a skill's bundled `references/` files only when the subtask needs that
   depth (the skill body says when).
4. **Re-route on pivot:** if the task changes (movement → saving), select and read the newly
   relevant skill instead of keeping everything loaded.

Announce what you load and why, e.g.: *"Detected Godot (`project.godot`). Loading
`godot-2d-movement` for the controller and `platformer` for jump feel; will open the platformer
skill's `feel-tuning.md` reference if you want coyote-time/buffering."*

## 5. Composition rules

- **One engine set, additive concepts.** Exactly one engine skill set; add the disciplines the
  task needs and usually **at most one** genre. Workflows attach independently.
- **Order:** engine fundamentals → discipline concept → genre orchestration → workflow. For asset
  production, approve the visual target before generating a family, then finish with the engine
  import settings and an in-context capture.
- **Ownership on overlap:** the **engine** skill owns API/syntax; the **discipline** skill owns
  the portable concept/algorithm and defers to the engine skill for code; the **genre** skill owns
  structure/glue and links out instead of re-teaching a primitive.
- **Hand-offs:** when a genre's `composes` names a slot like `*-2d-movement`, bind it to the
  detected engine. If that engine lacks the exact skill, see §6 and `references/routing-table.md`
  ("Binding gaps").

## 6. Unknown-engine & no-skill fallback

**Engine unknown** (no fingerprint, no engine named):

1. Check the request for a plain-text engine name ("in Unity", "using Phaser"). If found, adopt it.
2. If the task is a pure concept/genre/workflow question, route straight to the engine-agnostic
   discipline/genre/workflow skill — no engine needed ("what's a good save format?" → `save-systems`).
3. Only if engine choice actually blocks the answer, ask **one** targeted question ("Which engine —
   Godot, Unity, Unreal, or a web/other engine?"). If the user has no preference and one is needed,
   **default to Godot** (the most fully covered engine here) and say so.
4. Never invent an engine or load an engine skill on a guess.

**Engine known but no skill covers the subtask:** load the closest engine skill plus the relevant
discipline and **state the gap** plainly (e.g. "no dedicated Unity 2D-movement skill; using
`unity-csharp-scripting` + `unity-physics`"). Never fabricate a skill name.

**Conflicting/multiple genres:** pick the dominant genre from the phrasing; mention the secondary
and offer to load it if the user confirms.

## Worked examples

| Request | Detected engine | Skills loaded (in order) |
|---------|-----------------|--------------------------|
| "add a double jump to my Godot player" | Godot (`project.godot`) | `godot-2d-movement` → `platformer` |
| "make an inventory for my Unity RPG" | Unity (`Assets/`+`ProjectSettings/`) | `unity-scriptableobjects` → `rpg` → `save-systems` |
| "procedural dungeon roguelike in Godot" | Godot | `godot-tilemap` → `procedural-gen` → `roguelike` |
| "branching dialogue from a `.yarn` file" | (none required) | `dialogue-systems` (+ engine UI skill if an engine is detected) |
| "how do I design save slots with migration?" | (none) | `save-systems` only |
| "publish my game on itch with butler" | (any/none) | `itch-publish` only |
| "I want to make a game but don't know what to use" | unknown → ask, default Godot | router asks once; then e.g. `godot-nodes-scenes` |
| "make hits feel punchy in my Godot game" | Godot (`project.godot`) | `game-feel` (+ `camera-systems` for shake) |
| "the camera should follow my player smoothly" | (detected engine) | `camera-systems` (+ engine movement skill) |
| "my Unity game drops to 30 FPS, optimize it" | Unity (`Assets/`+`ProjectSettings/`) | `performance-optimization` (profile first) → engine skill |
| "make a cohesive pixel-art player and enemy set" | (detected engine) | `create-game-assets` → relevant engine import/rendering skill |

## References

- Full engine fingerprints, secondary signals, and disambiguation: `references/engine-detection.md`.
- Exhaustive per-skill trigger words, engine bindings, and binding gaps: `references/routing-table.md`.