gamedev-skills/awesome-gamedev-agent-skills

Master-Router – Game-Development-Skill-Dispatcher

Der Einstiegspunkt für Spieleentwicklungsarbeiten. Er erfasst den Fingerabdruck des Projekts, wählt eine Engine aus, klassifiziert die Aufgabe anhand der Anfrage, benennt den minimalen Satz an spezialisierten Skills und weist dich an, diese zu lesen, bevor du handelst. Er dispatched und komponiert – er lehrt keine Engine-APIs neu.

Wann verwenden

• Verwende am Anfang jeder Spieleentwicklungsanfrage – beim Erstellen oder Debuggen eines Spiels, Levels, Spielers, Gegners, Shaders, UI, Speichersystems, Multiplayers, Inputs, Audio, KI, Dialogs oder prozeduralen Inhalts – um zu entscheiden, welche(s) Skill(s) geladen werden sollen.
• Verwende, wenn der Nutzer eine Engine oder ein Genre nennt, „mach ein Spiel“ sagt oder fragt „welchen Skill soll ich verwenden?“.

Wann nicht zu verwenden: Sobald der richtige Skill geladen ist und die Aufgabe klar darin liegt, arbeite von diesem Skill aus – führe den Router nicht in jeder Runde erneut aus. Leite nur dann um, wenn die Aufgabe zu einer neuen Engine oder einem neuen Bereich wechselt (Router-Schritt 6).

Routing-Algorithmus

1. Engine erkennen – Projekt-Fingerabdruck → höchstens ein Engine-Skill-Set (oder „unbekannt“). §1.
2. Aufgabe klassifizieren – Formulierung → Disziplin(en) + höchstens ein Genre + Workflow(s). §2.
3. Auflösen – der minimale Satz: Engine-Skill(s) + Disziplin(en) + Genre + Workflow(s). §3.
4. Lesen (Offenlegung) – nur die gewählten SKILL.md-Texte öffnen; references/ nur bei Bedarf. §4.
5. Komponieren – Reihenfolge: Engine-Grundlagen → Disziplin-Konzept → Genre-Kleber → Workflow. §5.
6. Fallback – Engine unbekannt oder kein Skill passt → nachfragen oder auf Godot zurückgreifen; eventuelle Lücken benennen. §6.

---

1. Engine-Erkennung (Projekt-Fingerabdruck)

Scanne nach dem Signal mit der höchsten Zuverlässigkeit; wähle genau eine Engine aus. Stoppe beim ersten Treffer.

#	Engine	Primäres Signal	Skill-Set-Root
1	Godot	project.godot	skills/godot/
2	Unreal	*.uproject	skills/unreal/
3	Unity	Assets/ und ProjectSettings/ProjectVersion.txt	skills/unity/
4	Bevy	Cargo.toml mit einer bevy-Abhängigkeit	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 ruft love.* auf	skills/other-engines/love2d-core/
9	pygame	*.py mit import pygame	skills/other-engines/pygame-core/
10	Roblox	*.rbxl(x) / *.project.json (Rojo)	skills/other-engines/roblox-*

Für sekundäre Signale, die Godot-C#/Unity/Bevy- und Multi-Web-Disambiguierungsregeln, Monorepos und reine Text-Engine-Erwähnungen, lies references/engine-detection.md.

2. Aufgabenklassifikation (Formulierung → Kategorie)

Nach der Engine die Anfrage auf Aufgabensignale prüfen (drei additive Kategorien):

• Disziplinen (engineübergreifende Konzepte): game-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. Ausgelöst durch Konzeptwörter („Pathfinding“, „Speicherplätze“, „Fragment-Shader“, „Bildschirmwackeln“, „Kamera folgt“, „HUD/Menü“, „optimieren/niedrige FPS“).
• Genres (ganzheitliche Spielvorlagen): platformer, roguelike, rpg, fps-shooter, tower-defense, card-game, visual-novel, survival-crafting, puzzle. Ausgelöst durch Genre-Wörter („mach ein Roguelike“, „Deckbuilder“).
• Workflows (Prozess/Veröffentlichung): game-jam, prototype-fast, steam-publish, itch-publish. Ausgelöst durch Prozesswörter („auf Steam veröffentlichen“, „Vertical Slice“).

Dateisignale schärfen dies: *.yarn/*.ink → dialogue-systems/visual-novel; steam_appid.txt → steam-publish; *.inputactions → unity-input-system.

3. Routing-Tabelle (Aufgabe → Kategorie → Skill)

3a. Engine-Skills – lies den, der zur erkannten Engine + Unteraufgabe passt

• Godot (skills/godot/): Sprache godot-gdscript / godot-csharp; Struktur godot-nodes-scenes, godot-signals-groups; 2D godot-2d-movement, godot-tilemap; 3D godot-3d-essentials; Physik godot-physics; UI godot-ui-control; Animation godot-animation; Shader godot-shaders; Daten godot-resources; Audio godot-audio; Netzwerkcode godot-multiplayer; Veröffentlichen godot-export.
• Unity (skills/unity/): Scripting unity-csharp-scripting; Input unity-input-system; Physik unity-physics; Animation unity-animation; Daten unity-scriptableobjects; 2D unity-tilemap-2d; KI-Navigation unity-navmesh; Veröffentlichen unity-build-pipeline.
• Unreal (skills/unreal/): Visuelles Scripting unreal-blueprints; C++-Gameplay unreal-cpp-gameplay; Input unreal-enhanced-input; KI unreal-behavior-trees; VFX unreal-niagara; Veröffentlichen unreal-packaging.
• Web (skills/web-engines/): phaser-core, phaser-arcade-physics; pixijs-rendering; threejs-scene-setup, threejs-gltf-loading, threejs-materials-lighting.
• Andere (skills/other-engines/): bevy-ecs, pygame-core, love2d-core, roblox-luau, roblox-datastores.

3b. Disziplinen – zusammen mit dem Engine-Skill laden (Konzept ↔ Engine-API)

Konzept („sagt:“)	Disziplin-Skill	Paart mit (Engine-API)
Gegner-KI, Behavior Tree, Pathfinding, Steering	game-ai	unity-navmesh / unreal-behavior-trees / Godot-Navigation
prozedural, Rauschen, Samen, Dungeon-Generator	procedural-gen	Engine-Tilemap/Gitter-Skill
Dialog, Yarn, Ink, Gesprächsbaum	dialogue-systems	Engine-UI-Skill
Speichern/Laden, Slots, Persistenz	save-systems	roblox-datastores / Engine-E/A
adaptive Musik, Mixer, Ducking, SFX	audio-design	godot-audio / Unity AudioMixer
Shader, Fragment, Dissolve/Outline	shader-programming	godot-shaders / Engine-Material
Ruckeln, Tunneling, fester Zeitschritt	physics-tuning	godot-physics / unity-physics
Whitebox, Blockout, Kachel-Layout, Rhythmus	level-design	godot-tilemap / unity-tilemap-2d
Neubelegen, Gamepad, Input-Pufferung	input-systems	unity-input-system / unreal-enhanced-input / Godot InputMap
Bildschirmwackeln, Hit-Stop, Juice, Squash & Stretch, „mach es knallig“	game-feel	Engine-Animation/Tween + camera-systems (Wackeln)
Kamera folgt, Deadzone, Look-Ahead, Orbit, First-Person	camera-systems	godot-2d-movement / godot-3d-essentials / Cinemachine
HUD, Menü, UI-Layout, Skalierung, Safe Area, Fokus-Navigation	game-ui-ux	godot-ui-control / Unity UI (UGUI/UI Toolkit)
niedrige FPS, optimieren, Draw Calls, GC-Spike, Pooling, Profiler	performance-optimization	Engine-Profiler + physics-tuning

3c. Genres – komponiere Engine + Disziplinen (binde * an die erkannte Engine)

Genre („sagt:“)	komponiert
Plattformer, Sprung, Doppelsprung	godot-2d-movement (oder Engine-Physik) + godot-tilemap/unity-tilemap-2d + level-design + camera-systems + game-feel
Roguelike, prozeduraler Dungeon, Permadeath	procedural-gen + godot-tilemap/unity-tilemap-2d + game-ai + save-systems + game-feel
RPG, Stats, Inventar, 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, Wellen, Bahnen	game-ai + Engine-Bewegung + level-design + game-ui-ux
Kartenspiel, Deckbuilder, TCG	godot-resources/unity-scriptableobjects + game-ui-ux (+ Engine-UI)
Visual Novel, verzweigte Geschichte	dialogue-systems + save-systems + game-ui-ux
Survival, Crafting, Sammeln	save-systems + godot-resources/unity-scriptableobjects + procedural-gen + game-ui-ux
Puzzle, Match-3, Gitter-Logik	godot-tilemap/unity-tilemap-2d + level-design + game-feel

3d. Workflows – engineunabhängige Prozesse & Veröffentlichung

game-jam (Jam, 48 Stunden, Ludum Dare/GMTK) · prototype-fast (Vertical Slice, MVP, Greybox) · steam-publish (Steam, Steamworks, Depot; steam_appid.txt) · itch-publish (itch.io, butler; .itch.toml).

Für die erschöpfende pro-Skill-Trigger-Liste und alle Engine-Bindungen lies references/routing-table.md.

4. Leseprotokoll (progressive Offenlegung)

1. Vorab geladen: nur der name + die description jedes Skills sind im Kontext. Entscheide anhand dieser plus dem Fingerabdruck – lies keine Körper vorab.
2. Bei Auswahl: lies den Körper jedes ausgewählten skills/<category>/<name>/SKILL.md – und nur diese. Lade niemals eine ganze Kategorie auf einmal.
3. Auf Anfrage: lies die gebündelten references/-Dateien eines Skills nur, wenn die Unteraufgabe diese Tiefe benötigt (der Skill-Körper sagt, wann).
4. Umleitung bei Wechsel: wenn sich die Aufgabe ändert (Bewegung → Speichern), wähle den neu relevanten Skill aus und lies ihn, anstatt alles Geladene zu behalten.

Gib bekannt, was du lädst und warum, z. B.: „Godot erkannt (project.godot). Lade godot-2d-movement für den Controller und platformer für das Sprunggefühl; werde die feel-tuning.md-Referenz des Plattformer-Skills öffnen, wenn du Coyote-Time/Pufferung wünschst.“

5. Kompositionsregeln

• Ein Engine-Set, additive Konzepte. Genau ein Engine-Skill-Set; füge die Disziplinen hinzu, die die Aufgabe benötigt, und normalerweise höchstens ein Genre. Workflows hängen unabhängig an.
• Reihenfolge: Engine-Grundlagen → Disziplin-Konzept → Genre-Orchestrierung → Workflow.
• Zuständigkeit bei Überlappung: Der Engine-Skill besitzt die API/Syntax; der Disziplin-Skill besitzt das portable Konzept/den Algorithmus und delegiert für den Code an den Engine-Skill; der Genre-Skill besitzt die Struktur/den Kleber und verlinkt nach außen, anstatt eine Primitive neu zu lehren.
• Übergaben: Wenn das composes eines Genres einen Slot wie *-2d-movement nennt, binde ihn an die erkannte Engine. Wenn dieser Engine der genaue Skill fehlt, siehe §6 und references/routing-table.md („Bindungslücken“).

6. Fallback bei unbekannter Engine und keinem Skill

Engine unbekannt (kein Fingerabdruck, kein Engine-Name genannt):

1. Prüfe die Anfrage auf eine reine Text-Engine-Nennung („in Unity“, „mit Phaser“). Wenn gefunden, übernimm sie.
2. Wenn die Aufgabe eine reine Konzept-/Genre-/Workflow-Frage ist, leite direkt zum engineunabhängigen Disziplin-/Genre-/Workflow-Skill – keine Engine nötig („Was ist ein gutes Speicherformat?“ → save-systems).
3. Nur wenn die Engine-Wahl die Antwort tatsächlich blockiert, stelle eine gezielte Frage („Welche Engine – Godot, Unity, Unreal oder eine Web-/andere Engine?“). Wenn der Nutzer keine Präferenz hat und eine benötigt wird, Standard auf Godot (die am umfassendsten abgedeckte Engine hier) und sage dies.
4. Erfinde niemals eine Engine oder lade einen Engine-Skill auf eine Vermutung hin.

Engine bekannt, aber kein Skill deckt die Unteraufgabe ab: Lade den nächstgelegenen Engine-Skill plus die relevante Disziplin und benenne die Lücke klar (z. B. „kein spezieller Unity-2D-Bewegungs-Skill; verwende unity-csharp-scripting + unity-physics“). Erfinde niemals einen Skill-Namen.

Konfliktierende/mehrere Genres: Wähle das dominante Genre aus der Formulierung; erwähne das sekundäre und biete an, es zu laden, wenn der Nutzer es bestätigt.

Durchgearbeitete Beispiele

Anfrage	Erkannte Engine	Geladene Skills (in Reihenfolge)
„Füge meinem Godot-Spieler einen Doppelsprung hinzu“	Godot (project.godot)	godot-2d-movement → platformer
„Erstelle ein Inventar für mein Unity-RPG“	Unity (Assets/+ProjectSettings/)	unity-scriptableobjects → rpg → save-systems
„Prozeduraler Dungeon-Roguelike in Godot“	Godot	godot-tilemap → procedural-gen → roguelike
„Verzweigter Dialog aus einer .yarn-Datei“	(keine erforderlich)	dialogue-systems (+ Engine-UI-Skill, wenn eine Engine erkannt wird)
„Wie entwerfe ich Speicherplätze mit Migration?“	(keine)	save-systems nur
„Veröffentliche mein Spiel auf Itch mit Butler“	(beliebig/keine)	itch-publish nur
„Ich will ein Spiel machen, weiß aber nicht, was ich verwenden soll“	unbekannt → fragen, Standard Godot	Router fragt einmal; dann z. B. godot-nodes-scenes
„Mach Treffer in meinem Godot-Spiel knallig“	Godot (project.godot)	game-feel (+ camera-systems für Wackeln)
„Die Kamera soll meinem Spieler sanft folgen“	(erkannte Engine)	camera-systems (+ Engine-Bewegungs-Skill)
„Mein Unity-Spiel fällt auf 30 FPS, optimiere es“	Unity (Assets/+ProjectSettings/)	performance-optimization (zuerst profilieren) → Engine-Skill

Referenzen

• Vollständige Engine-Fingerabdrücke, sekundäre Signale und Disambiguierung: references/engine-detection.md.
• Erschöpfende pro-Skill-Trigger-Wörter, Engine-Bindungen und Bindungs-Lücken: references/routing-table.md.