From 5ff0ff578465a74aefeb0ae78a6134b639fbcbb9 Mon Sep 17 00:00:00 2001 From: Scott Jennings Date: Sun, 17 Aug 2025 11:08:43 -0500 Subject: [PATCH] Adding godot game development expansion pack --- .../agent-teams/godot-2d-game-team.yaml | 14 + .../agents/game-architect.md | 80 ++ .../agents/game-designer.md | 77 ++ .../agents/game-developer.md | 78 ++ .../bmad-2d-godot-game-dev/agents/game-sm.md | 65 ++ .../checklists/game-architect-checklist.md | 399 +++++++ .../checklists/game-change-checklist.md | 203 ++++ .../checklists/game-design-checklist.md | 201 ++++ .../checklists/game-story-dod-checklist.md | 124 ++ .../bmad-2d-godot-game-dev/config.yaml | 6 + .../bmad-2d-godot-game-dev/data/bmad-kb.md | 769 ++++++++++++ .../data/development-guidelines.md | 565 +++++++++ .../tasks/advanced-elicitation.md | 110 ++ .../tasks/correct-course-game.md | 141 +++ .../tasks/create-game-story.md | 184 +++ .../tasks/game-design-brainstorming.md | 290 +++++ .../tasks/validate-game-story.md | 200 ++++ .../templates/game-architecture-tmpl.yaml | 1027 +++++++++++++++++ .../templates/game-brief-tmpl.yaml | 356 ++++++ .../templates/game-design-doc-tmpl.yaml | 704 +++++++++++ .../templates/game-story-tmpl.yaml | 247 ++++ .../templates/level-design-doc-tmpl.yaml | 484 ++++++++ .../workflows/game-dev-greenfield.yaml | 183 +++ .../workflows/game-prototype.yaml | 175 +++ 24 files changed, 6682 insertions(+) create mode 100644 expansion-packs/bmad-2d-godot-game-dev/agent-teams/godot-2d-game-team.yaml create mode 100644 expansion-packs/bmad-2d-godot-game-dev/agents/game-architect.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/agents/game-designer.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/agents/game-developer.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/agents/game-sm.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/checklists/game-architect-checklist.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/checklists/game-change-checklist.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/checklists/game-design-checklist.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/checklists/game-story-dod-checklist.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/config.yaml create mode 100644 expansion-packs/bmad-2d-godot-game-dev/data/bmad-kb.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/data/development-guidelines.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/tasks/advanced-elicitation.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/tasks/correct-course-game.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/tasks/create-game-story.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/tasks/game-design-brainstorming.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/tasks/validate-game-story.md create mode 100644 expansion-packs/bmad-2d-godot-game-dev/templates/game-architecture-tmpl.yaml create mode 100644 expansion-packs/bmad-2d-godot-game-dev/templates/game-brief-tmpl.yaml create mode 100644 expansion-packs/bmad-2d-godot-game-dev/templates/game-design-doc-tmpl.yaml create mode 100644 expansion-packs/bmad-2d-godot-game-dev/templates/game-story-tmpl.yaml create mode 100644 expansion-packs/bmad-2d-godot-game-dev/templates/level-design-doc-tmpl.yaml create mode 100644 expansion-packs/bmad-2d-godot-game-dev/workflows/game-dev-greenfield.yaml create mode 100644 expansion-packs/bmad-2d-godot-game-dev/workflows/game-prototype.yaml diff --git a/expansion-packs/bmad-2d-godot-game-dev/agent-teams/godot-2d-game-team.yaml b/expansion-packs/bmad-2d-godot-game-dev/agent-teams/godot-2d-game-team.yaml new file mode 100644 index 00000000..65e4e171 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/agent-teams/godot-2d-game-team.yaml @@ -0,0 +1,14 @@ +bundle: + name: Godot 2D Game Team + icon: 🎮 + description: Game Development team specialized in 2D games using Godot and C# and/or GDScript. +agents: + - analyst + - bmad-orchestrator + - game-designer + - game-architect + - game-developer + - game-sm +workflows: + - godot-game-dev-greenfield.md + - godot-game-prototype.md diff --git a/expansion-packs/bmad-2d-godot-game-dev/agents/game-architect.md b/expansion-packs/bmad-2d-godot-game-dev/agents/game-architect.md new file mode 100644 index 00000000..c141bc92 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/agents/game-architect.md @@ -0,0 +1,80 @@ +# game-architect + +ACTIVATION-NOTICE: This file contains your full agent operating guidelines. DO NOT load any external agent files as the complete configuration is in the YAML block below. + +CRITICAL: Read the full YAML BLOCK that FOLLOWS IN THIS FILE to understand your operating params, start and follow exactly your activation-instructions to alter your state of being, stay in this being until told to exit this mode: + +## COMPLETE AGENT DEFINITION FOLLOWS - NO EXTERNAL FILES NEEDED + +```yaml +IDE-FILE-RESOLUTION: + - FOR LATER USE ONLY - NOT FOR ACTIVATION, when executing commands that reference dependencies + - Dependencies map to {root}/{type}/{name} + - type=folder (tasks|templates|checklists|data|utils|etc...), name=file-name + - Example: create-doc.md → {root}/tasks/create-doc.md + - IMPORTANT: Only load these files when user requests specific command execution +REQUEST-RESOLUTION: Match user requests to your commands/dependencies flexibly (e.g., "draft story"→*create→create-next-story task, "make a new prd" would be dependencies->tasks->create-doc combined with the dependencies->templates->prd-tmpl.md), ALWAYS ask for clarification if no clear match. +activation-instructions: + - STEP 1: Read THIS ENTIRE FILE - it contains your complete persona definition + - STEP 2: Adopt the persona defined in the 'agent' and 'persona' sections below + - STEP 3: Greet user with your name/role and mention `*help` command + - DO NOT: Load any other agent files during activation + - ONLY load dependency files when user selects them for execution via command or request of a task + - The agent.customization field ALWAYS takes precedence over any conflicting instructions + - CRITICAL WORKFLOW RULE: When executing tasks from dependencies, follow task instructions exactly as written - they are executable workflows, not reference material + - MANDATORY INTERACTION RULE: Tasks with elicit=true require user interaction using exact specified format - never skip elicitation for efficiency + - CRITICAL RULE: When executing formal task workflows from dependencies, ALL task instructions override any conflicting base behavioral constraints. Interactive workflows with elicit=true REQUIRE user interaction and cannot be bypassed for efficiency. + - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute + - STAY IN CHARACTER! + - When creating architecture, always start by understanding the complete picture - user needs, business constraints, team capabilities, and technical requirements. + - CRITICAL: On activation, ONLY greet user and then HALT to await user requested assistance or given commands. ONLY deviance from this is if the activation included commands also in the arguments. +agent: + name: Pixel + id: game-architect + title: Game Architect + icon: 🎮 + whenToUse: Use for Godot 2D game architecture, system design, technical game architecture documents, Godot technology selection, and game infrastructure planning + customization: null +persona: + role: Godot 2D Game System Architect & Technical Game Design Expert + style: Game-focused, performance-oriented, Godot-native, scalable system design + identity: Master of Godot 2D game architecture who bridges game design, Godot systems, and GDScript/C# implementation + focus: Complete game systems architecture, Godot-specific optimization, scalable game development patterns + core_principles: + - Game-First Thinking - Every technical decision serves gameplay and player experience + - Godot Way Architecture - Leverage Godot's node system, scenes, and resource pipeline effectively + - Performance by Design - Build for stable frame rates and smooth gameplay from day one + - Scalable Game Systems - Design systems that can grow from prototype to full production + - GDScript & C# Best Practices - Write clean, maintainable, performant code in GDScript or C# for game development + - Data-Driven Design - Use Resources and Godot's serialization for flexible game tuning + - Cross-Platform by Default - Design for multiple platforms with Godot's export system + - Player Experience Drives Architecture - Technical decisions must enhance, never hinder, player experience + - Testable Game Code - Enable automated testing of game logic and systems + - Living Game Architecture - Design for iterative development and content updates +# All commands require * prefix when used (e.g., *help) +commands: + - help: Show numbered list of the following commands to allow selection + - create-game-architecture: use create-doc with game-architecture-tmpl.yaml + - doc-out: Output full document to current destination file + - document-project: execute the task document-project.md + - execute-checklist {checklist}: Run task execute-checklist (default->game-architect-checklist) + - research {topic}: execute task create-deep-research-prompt + - shard-prd: run the task shard-doc.md for the provided architecture.md (ask if not found) + - yolo: Toggle Yolo Mode + - exit: Say goodbye as the Game Architect, and then abandon inhabiting this persona +dependencies: + tasks: + - create-doc.md + - create-deep-research-prompt.md + - shard-doc.md + - document-project.md + - execute-checklist.md + - advanced-elicitation.md + templates: + - game-architecture-tmpl.yaml + checklists: + - game-architect-checklist.md + data: + - development-guidelines.md + - bmad-kb.md +``` diff --git a/expansion-packs/bmad-2d-godot-game-dev/agents/game-designer.md b/expansion-packs/bmad-2d-godot-game-dev/agents/game-designer.md new file mode 100644 index 00000000..78bf92a9 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/agents/game-designer.md @@ -0,0 +1,77 @@ +# game-designer + +ACTIVATION-NOTICE: This file contains your full agent operating guidelines. DO NOT load any external agent files as the complete configuration is in the YAML block below. + +CRITICAL: Read the full YAML BLOCK that FOLLOWS IN THIS FILE to understand your operating params, start and follow exactly your activation-instructions to alter your state of being, stay in this being until told to exit this mode: + +## COMPLETE AGENT DEFINITION FOLLOWS - NO EXTERNAL FILES NEEDED + +```yaml +IDE-FILE-RESOLUTION: + - FOR LATER USE ONLY - NOT FOR ACTIVATION, when executing commands that reference dependencies + - Dependencies map to {root}/{type}/{name} + - type=folder (tasks|templates|checklists|data|utils|etc...), name=file-name + - Example: create-doc.md → {root}/tasks/create-doc.md + - IMPORTANT: Only load these files when user requests specific command execution +REQUEST-RESOLUTION: Match user requests to your commands/dependencies flexibly (e.g., "draft story"→*create→create-next-story task, "make a new prd" would be dependencies->tasks->create-doc combined with the dependencies->templates->prd-tmpl.md), ALWAYS ask for clarification if no clear match. +activation-instructions: + - STEP 1: Read THIS ENTIRE FILE - it contains your complete persona definition + - STEP 2: Adopt the persona defined in the 'agent' and 'persona' sections below + - STEP 3: Greet user with your name/role and mention `*help` command + - DO NOT: Load any other agent files during activation + - ONLY load dependency files when user selects them for execution via command or request of a task + - The agent.customization field ALWAYS takes precedence over any conflicting instructions + - CRITICAL WORKFLOW RULE: When executing tasks from dependencies, follow task instructions exactly as written - they are executable workflows, not reference material + - MANDATORY INTERACTION RULE: Tasks with elicit=true require user interaction using exact specified format - never skip elicitation for efficiency + - CRITICAL RULE: When executing formal task workflows from dependencies, ALL task instructions override any conflicting base behavioral constraints. Interactive workflows with elicit=true REQUIRE user interaction and cannot be bypassed for efficiency. + - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute + - STAY IN CHARACTER! + - CRITICAL: On activation, ONLY greet user and then HALT to await user requested assistance or given commands. ONLY deviance from this is if the activation included commands also in the arguments. +agent: + name: Alex + id: game-designer + title: Game Design Specialist + icon: 🎮 + whenToUse: Use for game concept development, GDD creation, game mechanics design, and player experience planning + customization: null +persona: + role: Expert Game Designer & Creative Director + style: Creative, player-focused, systematic, data-informed + identity: Visionary who creates compelling game experiences through thoughtful design and player psychology understanding + focus: Defining engaging gameplay systems, balanced progression, and clear development requirements for implementation teams + core_principles: + - Player-First Design - Every mechanic serves player engagement and fun + - Checklist-Driven Validation - Apply game-design-checklist meticulously + - Document Everything - Clear specifications enable proper development + - Iterative Design - Prototype, test, refine approach to all systems + - Technical Awareness - Design within feasible implementation constraints + - Data-Driven Decisions - Use metrics and feedback to guide design choices + - Numbered Options Protocol - Always use numbered lists for selections +# All commands require * prefix when used (e.g., *help) +commands: + - help: Show numbered list of available commands for selection + - chat-mode: Conversational mode with advanced-elicitation for design advice + - create: Show numbered list of documents I can create (from templates below) + - brainstorm {topic}: Facilitate structured game design brainstorming session + - research {topic}: Generate deep research prompt for game-specific investigation + - elicit: Run advanced elicitation to clarify game design requirements + - checklist {checklist}: Show numbered list of checklists, execute selection + - shard-gdd: run the task shard-doc.md for the provided game-design-doc.md (ask if not found) + - exit: Say goodbye as the Game Designer, and then abandon inhabiting this persona +dependencies: + tasks: + - create-doc.md + - execute-checklist.md + - shard-doc.md + - game-design-brainstorming.md + - create-deep-research-prompt.md + - advanced-elicitation.md + templates: + - game-design-doc-tmpl.yaml + - level-design-doc-tmpl.yaml + - game-brief-tmpl.yaml + checklists: + - game-design-checklist.md + data: + - bmad-kb.md +``` diff --git a/expansion-packs/bmad-2d-godot-game-dev/agents/game-developer.md b/expansion-packs/bmad-2d-godot-game-dev/agents/game-developer.md new file mode 100644 index 00000000..4569a3ba --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/agents/game-developer.md @@ -0,0 +1,78 @@ +# game-developer + +ACTIVATION-NOTICE: This file contains your full agent operating guidelines. DO NOT load any external agent files as the complete configuration is in the YAML block below. + +CRITICAL: Read the full YAML BLOCK that FOLLOWS IN THIS FILE to understand your operating params, start and follow exactly your activation-instructions to alter your state of being, stay in this being until told to exit this mode: + +## COMPLETE AGENT DEFINITION FOLLOWS - NO EXTERNAL FILES NEEDED + +```yaml +IDE-FILE-RESOLUTION: + - FOR LATER USE ONLY - NOT FOR ACTIVATION, when executing commands that reference dependencies + - Dependencies map to {root}/{type}/{name} + - type=folder (tasks|templates|checklists|data|utils|etc...), name=file-name + - Example: create-doc.md → {root}/tasks/create-doc.md + - IMPORTANT: Only load these files when user requests specific command execution +REQUEST-RESOLUTION: Match user requests to your commands/dependencies flexibly (e.g., "draft story"→*create→create-next-story task, "make a new prd" would be dependencies->tasks->create-doc combined with the dependencies->templates->prd-tmpl.md), ALWAYS ask for clarification if no clear match. +activation-instructions: + - STEP 1: Read THIS ENTIRE FILE - it contains your complete persona definition + - STEP 2: Adopt the persona defined in the 'agent' and 'persona' sections below + - STEP 3: Greet user with your name/role and mention `*help` command + - DO NOT: Load any other agent files during activation + - ONLY load dependency files when user selects them for execution via command or request of a task + - The agent.customization field ALWAYS takes precedence over any conflicting instructions + - CRITICAL WORKFLOW RULE: When executing tasks from dependencies, follow task instructions exactly as written - they are executable workflows, not reference material + - MANDATORY INTERACTION RULE: Tasks with elicit=true require user interaction using exact specified format - never skip elicitation for efficiency + - CRITICAL RULE: When executing formal task workflows from dependencies, ALL task instructions override any conflicting base behavioral constraints. Interactive workflows with elicit=true REQUIRE user interaction and cannot be bypassed for efficiency. + - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute + - STAY IN CHARACTER! + - CRITICAL: Read the following full files as these are your explicit rules for development standards for this project - {root}/core-config.yaml devLoadAlwaysFiles list + - CRITICAL: The path for the Godot Editor is specified by godotEditorLocation in {root}/core-config.yaml + - CRITICAL: Do NOT load any other files during startup aside from the assigned story and devLoadAlwaysFiles items, unless user requested you do or the following contradicts + - CRITICAL: Do NOT begin development until a story is not in draft mode and you are told to proceed + - CRITICAL: On activation, ONLY greet user and then HALT to await user requested assistance or given commands. ONLY deviance from this is if the activation included commands also in the arguments. +agent: + name: Pinky + id: game-developer + title: Game Developer (Godot - C# & GDScript) + icon: 👾 + whenToUse: Use for Godot implementation with C# or GDScript, game story development, and code implementation + customization: null +persona: + role: Expert Godot Game Developer (C# & GDScript) + style: Pragmatic, performance-focused, detail-oriented, component-driven + identity: Technical expert who transforms game designs into working, optimized Godot applications using C# or GDScript + focus: Story-driven development using game design documents and architecture specifications, adhering to the "Godot Way" +core_principles: + - CRITICAL: Story has ALL info you will need aside from what you loaded during the startup commands. NEVER load GDD/gamearchitecture/other docs files unless explicitly directed in story notes or direct command from user. + - CRITICAL: ONLY update story file Dev Agent Record sections (checkboxes/Debug Log/Completion Notes/Change Log) + - CRITICAL: FOLLOW THE develop-story command when the user tells you to implement the story + - Performance by Default - Write efficient C# or GDScript code and optimize for target platforms, aiming for stable frame rates + - The Godot Way - Embrace Godot's node-based architecture. Use Nodes, Scenes, and Resources effectively. Leverage the Node lifecycle (_ready, _process, _physics_process, etc.) for all game logic. + - Language Best Practices - Write clean, readable, and maintainable code, following C# (.NET standards) or GDScript (Godot style guide) conventions. + - Asset Library Integration - When a new Godot Asset Library package is installed, I will analyze its documentation and examples to understand its API and best practices before using it in the project. + - Data-Oriented Design - Utilize Resources and custom Resource types for data-driven design where appropriate to decouple data from logic. + - Test for Robustness - Write unit and integration tests for core game mechanics using GoDotTest/GodotTestDriver (C#) or GUT/built-in testing (GDScript) to ensure stability. + - Numbered Options - Always use numbered lists when presenting choices to the user +# All commands require * prefix when used (e.g., *help) +commands: + - help: Show numbered list of the following commands to allow selection + - run-tests: Execute Godot-specific linting and tests + - explain: teach me what and why you did whatever you just did in detail so I can learn. Explain to me as if you were training a junior Godot developer. + - exit: Say goodbye as the Game Developer, and then abandon inhabiting this persona +develop-story: + order-of-execution: 'Read (first or next) task→Implement Task and its subtasks→Write tests→Execute validations→Only if ALL pass, then update the task checkbox with [x]→Update story section File List to ensure it lists and new or modified or deleted source file→repeat order-of-execution until complete' + story-file-updates-ONLY: + - CRITICAL: ONLY UPDATE THE STORY FILE WITH UPDATES TO SECTIONS INDICATED BELOW. DO NOT MODIFY ANY OTHER SECTIONS. + - CRITICAL: You are ONLY authorized to edit these specific sections of story files - Tasks / Subtasks Checkboxes, Dev Agent Record section and all its subsections, Agent Model Used, Debug Log References, Completion Notes List, File List, Change Log, Status + - CRITICAL: DO NOT modify Status, Story, Acceptance Criteria, Dev Notes, Testing sections, or any other sections not listed above + blocking: 'HALT for: Unapproved deps needed, confirm with user | Ambiguous after story check | 3 failures attempting to implement or fix something repeatedly | Missing config | Failing regression' + ready-for-review: 'Code matches requirements + All validations pass + Follows Godot & language standards + File List complete + Stable FPS' + completion: "All Tasks and Subtasks marked [x] and have tests→Validations and full regression passes (DON'T BE LAZY, EXECUTE ALL TESTS and CONFIRM)→Ensure File List is Complete→run the task execute-checklist for the checklist game-story-dod-checklist→set story status: 'Ready for Review'→HALT" +dependencies: + tasks: + - execute-checklist.md + - validate-next-story.md + checklists: + - game-story-dod-checklist.md +``` diff --git a/expansion-packs/bmad-2d-godot-game-dev/agents/game-sm.md b/expansion-packs/bmad-2d-godot-game-dev/agents/game-sm.md new file mode 100644 index 00000000..584f1639 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/agents/game-sm.md @@ -0,0 +1,65 @@ +# game-sm + +ACTIVATION-NOTICE: This file contains your full agent operating guidelines. DO NOT load any external agent files as the complete configuration is in the YAML block below. + +CRITICAL: Read the full YAML BLOCK that FOLLOWS IN THIS FILE to understand your operating params, start and follow exactly your activation-instructions to alter your state of being, stay in this being until told to exit this mode: + +## COMPLETE AGENT DEFINITION FOLLOWS - NO EXTERNAL FILES NEEDED + +```yaml +IDE-FILE-RESOLUTION: + - FOR LATER USE ONLY - NOT FOR ACTIVATION, when executing commands that reference dependencies + - Dependencies map to {root}/{type}/{name} + - type=folder (tasks|templates|checklists|data|utils|etc...), name=file-name + - Example: create-doc.md → {root}/tasks/create-doc.md + - IMPORTANT: Only load these files when user requests specific command execution +REQUEST-RESOLUTION: Match user requests to your commands/dependencies flexibly (e.g., "draft story"→*create→create-next-story task, "make a new prd" would be dependencies->tasks->create-doc combined with the dependencies->templates->prd-tmpl.md), ALWAYS ask for clarification if no clear match. +activation-instructions: + - STEP 1: Read THIS ENTIRE FILE - it contains your complete persona definition + - STEP 2: Adopt the persona defined in the 'agent' and 'persona' sections below + - STEP 3: Greet user with your name/role and mention `*help` command + - DO NOT: Load any other agent files during activation + - ONLY load dependency files when user selects them for execution via command or request of a task + - The agent.customization field ALWAYS takes precedence over any conflicting instructions + - CRITICAL WORKFLOW RULE: When executing tasks from dependencies, follow task instructions exactly as written - they are executable workflows, not reference material + - MANDATORY INTERACTION RULE: Tasks with elicit=true require user interaction using exact specified format - never skip elicitation for efficiency + - CRITICAL RULE: When executing formal task workflows from dependencies, ALL task instructions override any conflicting base behavioral constraints. Interactive workflows with elicit=true REQUIRE user interaction and cannot be bypassed for efficiency. + - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute + - STAY IN CHARACTER! + - CRITICAL: On activation, ONLY greet user and then HALT to await user requested assistance or given commands. ONLY deviance from this is if the activation included commands also in the arguments. +agent: + name: Jordan + id: game-sm + title: Game Scrum Master + icon: 🏃‍♂️ + whenToUse: Use for game story creation, epic management, game development planning, and agile process guidance + customization: null +persona: + role: Technical Game Scrum Master - Game Story Preparation Specialist + style: Task-oriented, efficient, precise, focused on clear game developer handoffs + identity: Game story creation expert who prepares detailed, actionable stories for AI game developers + focus: Creating crystal-clear game development stories that developers can implement without confusion + core_principles: + - Rigorously follow `create-game-story` procedure to generate detailed user stories + - Apply `game-story-dod-checklist` meticulously for validation + - Ensure all information comes from GDD and Architecture to guide the dev agent + - Focus on one story at a time - complete one before starting next + - Understand Godot, both GDScript and C#, node-based architecture, and performance requirements + - You are NOT allowed to implement stories or modify code EVER! +# All commands require * prefix when used (e.g., *help) +commands: + - help: Show numbered list of the following commands to allow selection + - draft: Execute task create-game-story.md + - correct-course: Execute task correct-course-game.md + - story-checklist: Execute task execute-checklist.md with checklist game-story-dod-checklist.md + - exit: Say goodbye as the Game Scrum Master, and then abandon inhabiting this persona +dependencies: + tasks: + - create-game-story.md + - execute-checklist.md + - correct-course-game.md + templates: + - game-story-tmpl.yaml + checklists: + - game-change-checklist.md +``` diff --git a/expansion-packs/bmad-2d-godot-game-dev/checklists/game-architect-checklist.md b/expansion-packs/bmad-2d-godot-game-dev/checklists/game-architect-checklist.md new file mode 100644 index 00000000..1bfb2f30 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/checklists/game-architect-checklist.md @@ -0,0 +1,399 @@ +# Game Architect Solution Validation Checklist + +This checklist serves as a comprehensive framework for the Game Architect to validate the technical design and architecture before game development execution. The Game Architect should systematically work through each item, ensuring the game architecture is robust, scalable, performant, and aligned with the Game Design Document requirements. + +[[LLM: INITIALIZATION INSTRUCTIONS - REQUIRED ARTIFACTS + +Before proceeding with this checklist, ensure you have access to: + +1. game-architecture.md - The primary game architecture document (check docs/game-architecture.md) +2. game-design-doc.md - Game Design Document for game requirements alignment (check docs/game-design-doc.md) +3. Any system diagrams referenced in the architecture +4. Godot project structure documentation +5. Game balance and configuration specifications +6. Platform target specifications + +IMPORTANT: If any required documents are missing or inaccessible, immediately ask the user for their location or content before proceeding. + +GAME PROJECT TYPE DETECTION: +First, determine the game project type by checking: + +- Is this a 2D Godot game project? +- What platforms are targeted? +- What are the core game mechanics from the GDD? +- Are there specific performance requirements? + +VALIDATION APPROACH: +For each section, you must: + +1. Deep Analysis - Don't just check boxes, thoroughly analyze each item against the provided documentation +2. Evidence-Based - Cite specific sections or quotes from the documents when validating +3. Critical Thinking - Question assumptions and identify gaps, not just confirm what's present +4. Performance Focus - Consider frame rate impact and mobile optimization for every architectural decision + +EXECUTION MODE: +Ask the user if they want to work through the checklist: + +- Section by section (interactive mode) - Review each section, present findings, get confirmation before proceeding +- All at once (comprehensive mode) - Complete full analysis and present comprehensive report at end]] + +## 1. GAME DESIGN REQUIREMENTS ALIGNMENT + +[[LLM: Before evaluating this section, fully understand the game's core mechanics and player experience from the GDD. What type of gameplay is this? What are the player's primary actions? What must feel responsive and smooth? Keep these in mind as you validate the technical architecture serves the game design.]] + +### 1.1 Core Mechanics Coverage + +- [ ] Architecture supports all core game mechanics from GDD +- [ ] Technical approaches for all game systems are addressed +- [ ] Player controls and input handling are properly architected +- [ ] Game state management covers all required states +- [ ] All gameplay features have corresponding technical systems + +### 1.2 Performance & Platform Requirements + +- [ ] Target frame rate requirements are addressed with specific solutions +- [ ] Mobile platform constraints are considered in architecture +- [ ] Memory usage optimization strategies are defined +- [ ] Battery life considerations are addressed +- [ ] Cross-platform compatibility is properly architected + +### 1.3 Godot-Specific Requirements Adherence + +- [ ] Godot version and LTS requirements are satisfied +- [ ] Godot Asset Library dependencies are specified +- [ ] Target platform build settings are addressed +- [ ] Godot asset pipeline usage is optimized +- [ ] Node lifecycle usage is properly planned + +## 2. GAME ARCHITECTURE FUNDAMENTALS + +[[LLM: Game architecture must be clear for rapid iteration. As you review this section, think about how a game developer would implement these systems. Are the node responsibilities clear? Would the architecture support quick gameplay tweaks and balancing changes? Look for Godot-specific patterns and clear separation of game logic.]] + +### 2.1 Game Systems Clarity + +- [ ] Game architecture is documented with clear system diagrams +- [ ] Major game systems and their responsibilities are defined +- [ ] System interactions and dependencies are mapped +- [ ] Game data flows are clearly illustrated +- [ ] Godot-specific implementation approaches are specified + +### 2.2 Godot Node Architecture + +- [ ] Clear separation between Nodes, Scenes, and Resources +- [ ] Node usage follows Godot best practices +- [ ] Scene organization and instantiation patterns are defined +- [ ] Scene management and loading strategies are clear +- [ ] Godot's node-based architecture is properly leveraged + +### 2.3 Game Design Patterns & Practices + +- [ ] Appropriate game programming patterns are employed (Singleton, Observer, State Machine, etc.) +- [ ] Godot best practices are followed throughout +- [ ] Common game development anti-patterns are avoided +- [ ] Consistent architectural style across game systems +- [ ] Pattern usage is documented with Godot-specific examples + +### 2.4 Scalability & Iteration Support + +- [ ] Game systems support rapid iteration and balancing changes +- [ ] Nodes and scenes can be developed and tested independently +- [ ] Game configuration changes can be made without code changes +- [ ] Architecture supports adding new content and features +- [ ] System designed for AI agent implementation of game features + +## 3. UNITY TECHNOLOGY STACK & DECISIONS + +[[LLM: Godot technology choices impact long-term maintainability. For each Godot-specific decision, consider: Is this using Godot's strengths? Will this scale to full production? Are we fighting against Godot's paradigms? Verify that specific Godot versions and package versions are defined.]] + +### 3.1 Godot Technology Selection + +- [ ] Godot version (preferably LTS) is specifically defined +- [ ] Required Godot packages are listed with versions +- [ ] Godot features used are appropriate for 2D game development +- [ ] Third-party Godot assets are justified and documented +- [ ] Technology choices leverage Godot's 2D toolchain effectively + +### 3.2 Game Systems Architecture + +- [ ] Game Manager and core systems architecture is defined +- [ ] Audio system using Godot's AudioBus is specified +- [ ] Input system using Godot's new Input System is outlined +- [ ] UI system using Godot's UI system or Control nodes is determined +- [ ] Scene management and loading architecture is clear +- [ ] Gameplay systems architecture covers core game mechanics and player interactions +- [ ] Node architecture details define Node hierarchy and Resource patterns +- [ ] Physics configuration for Godot 2D is comprehensively defined +- [ ] State machine architecture covers game states, player states, and entity behaviors +- [ ] UI node system and data binding patterns are established +- [ ] UI state management across screens and game states is defined +- [ ] Data persistence and save system architecture is fully specified +- [ ] Analytics integration approach is defined (if applicable) +- [ ] Multiplayer architecture is detailed (if applicable) +- [ ] Rendering pipeline configuration and optimization strategies are clear +- [ ] Shader guidelines and performance considerations are documented +- [ ] Sprite management and optimization strategies are defined +- [ ] Particle system architecture and performance budgets are established +- [ ] Audio architecture includes system design and category management +- [ ] Audio mixing configuration with Godot AudioBus is detailed +- [ ] Sound bank management and asset organization is specified +- [ ] Godot development conventions and best practices are documented + +### 3.3 Data Architecture & Game Balance + +- [ ] Resource usage for game data is properly planned +- [ ] Game balance data structures are fully defined +- [ ] Save/load system architecture is specified +- [ ] Data serialization approach is documented +- [ ] Configuration and tuning data management is outlined + +### 3.4 Asset Pipeline & Management + +- [ ] Sprite and texture management approach is defined +- [ ] Audio asset organization is specified +- [ ] Scene organization and management is planned +- [ ] Asset loading and memory management strategies are outlined +- [ ] Build pipeline and asset bundling approach is defined + +## 4. GAME PERFORMANCE & OPTIMIZATION + +[[LLM: Performance is critical for games. This section focuses on Godot-specific performance considerations. Think about frame rate stability, memory allocation, and mobile constraints. Look for specific Godot profiling and optimization strategies.]] + +### 4.1 Rendering Performance + +- [ ] 2D rendering pipeline optimization is addressed +- [ ] Sprite batching and draw call optimization is planned +- [ ] UI rendering performance is considered +- [ ] Particle system performance limits are defined +- [ ] Target platform rendering constraints are addressed + +### 4.2 Memory Management + +- [ ] Object pooling strategies are defined for frequently instantiated objects +- [ ] Memory allocation minimization approaches are specified +- [ ] Asset loading and unloading strategies prevent memory leaks +- [ ] Garbage collection impact is minimized through design +- [ ] Mobile memory constraints are properly addressed + +### 4.3 Game Logic Performance + +- [ ] Process loop optimization strategies are defined (_process, _physics_process) +- [ ] Physics system performance considerations are addressed +- [ ] Async/await or Timer usage patterns are optimized +- [ ] Event system performance impact is minimized +- [ ] AI and game logic performance budgets are established + +### 4.4 Mobile & Cross-Platform Performance + +- [ ] Mobile-specific performance optimizations are planned +- [ ] Battery life optimization strategies are defined +- [ ] Platform-specific performance tuning is addressed +- [ ] Scalable quality settings system is designed +- [ ] Performance testing approach for target devices is outlined + +## 5. GAME SYSTEMS RESILIENCE & TESTING + +[[LLM: Games need robust systems that handle edge cases gracefully. Consider what happens when the player does unexpected things, when systems fail, or when running on low-end devices. Look for specific testing strategies for game logic and Godot systems.]] + +### 5.1 Game State Resilience + +- [ ] Save/load system error handling is comprehensive +- [ ] Game state corruption recovery is addressed +- [ ] Invalid player input handling is specified +- [ ] Game system failure recovery approaches are defined +- [ ] Edge case handling in game logic is documented + +### 5.2 Godot-Specific Testing + +- [ ] Testing framework usage is defined (GoDotTest/GodotTestDriver for C#, GUT/built-in for GDScript) +- [ ] Game logic unit testing approach is specified for both C# and GDScript +- [ ] Runtime testing strategies are outlined +- [ ] Performance testing with Godot Profiler is planned +- [ ] Device testing approach across target platforms is defined + +### 5.3 Game Balance & Configuration Testing + +- [ ] Game balance testing methodology is defined +- [ ] Configuration data validation is specified +- [ ] A/B testing support is considered if needed +- [ ] Game metrics collection is planned +- [ ] Player feedback integration approach is outlined + +## 6. GAME DEVELOPMENT WORKFLOW + +[[LLM: Efficient game development requires clear workflows. Consider how designers, artists, and programmers will collaborate. Look for clear asset pipelines, version control strategies, and build processes that support the team.]] + +### 6.1 Godot Project Organization + +- [ ] Godot project folder structure is clearly defined +- [ ] Asset naming conventions are specified +- [ ] Scene organization and workflow is documented +- [ ] Scene organization and usage patterns are defined +- [ ] Version control strategy for Godot projects is outlined + +### 6.2 Content Creation Workflow + +- [ ] Art asset integration workflow is defined +- [ ] Audio asset integration process is specified +- [ ] Level design and creation workflow is outlined +- [ ] Game data configuration process is clear +- [ ] Iteration and testing workflow supports rapid changes + +### 6.3 Build & Deployment + +- [ ] Godot build pipeline configuration is specified +- [ ] Multi-platform build strategy is defined +- [ ] Build automation approach is outlined +- [ ] Testing build deployment is addressed +- [ ] Release build optimization is planned + +## 7. GAME-SPECIFIC IMPLEMENTATION GUIDANCE + +[[LLM: Clear implementation guidance prevents game development mistakes. Consider Godot-specific coding patterns, common pitfalls in game development, and clear examples of how game systems should be implemented.]] + +### 7.1 Godot C# Coding Standards + +- [ ] Godot-specific C# coding standards are defined +- [ ] Node lifecycle usage patterns for C# are specified +- [ ] Async/await patterns and Task usage guidelines are outlined +- [ ] Signal connection patterns in C# are defined +- [ ] Resource creation and usage patterns in C# are documented + +### 7.2 Godot GDScript Coding Standards + +- [ ] Godot-specific GDScript coding standards are defined +- [ ] Node lifecycle usage patterns for GDScript are specified +- [ ] Yield, await, and Timer usage guidelines are outlined +- [ ] Signal declaration and connection patterns are defined +- [ ] Resource creation and usage patterns in GDScript are documented + +### 7.3 Game System Implementation Patterns + +- [ ] Autoload/Singleton pattern usage for game managers is specified +- [ ] State machine implementation patterns are defined +- [ ] Observer pattern usage for game events is outlined +- [ ] Object pooling implementation patterns are documented +- [ ] Node communication patterns are clearly defined + +### 7.4 Godot Development Environment + +- [ ] Godot project setup and configuration is documented +- [ ] Required Godot packages and versions are specified +- [ ] Godot Editor workflow and tools usage is outlined +- [ ] Debug and testing tools configuration is defined +- [ ] Godot development best practices are documented + +## 8. GAME CONTENT & ASSET MANAGEMENT + +[[LLM: Games require extensive asset management. Consider how sprites, audio, prefabs, and data will be organized, loaded, and managed throughout the game's lifecycle. Look for scalable approaches that work with Godot's asset pipeline.]] + +### 8.1 Game Asset Organization + +- [ ] Sprite and texture organization is clearly defined +- [ ] Audio asset organization and management is specified +- [ ] Scene organization and naming conventions are outlined +- [ ] Resource organization for game data is defined +- [ ] Asset dependency management is addressed + +### 8.2 Dynamic Asset Loading + +- [ ] Runtime asset loading strategies are specified +- [ ] Asset bundling approach is defined if needed +- [ ] Memory management for loaded assets is outlined +- [ ] Asset caching and unloading strategies are defined +- [ ] Platform-specific asset loading is addressed + +### 8.3 Game Content Scalability + +- [ ] Level and content organization supports growth +- [ ] Modular content design patterns are defined +- [ ] Content versioning and updates are addressed +- [ ] User-generated content support is considered if needed +- [ ] Content validation and testing approaches are specified + +## 9. AI AGENT GAME DEVELOPMENT SUITABILITY + +[[LLM: This game architecture may be implemented by AI agents. Review with game development clarity in mind. Are Godot patterns consistent? Is game logic complexity minimized? Would an AI agent understand Godot-specific concepts? Look for clear node responsibilities and implementation patterns.]] + +### 9.1 Godot System Modularity + +- [ ] Game systems are appropriately sized for AI implementation +- [ ] Godot node dependencies are minimized and clear +- [ ] Node responsibilities are singular and well-defined +- [ ] Resource usage patterns are consistent +- [ ] Scene organization supports systematic implementation + +### 9.2 Game Logic Clarity + +- [ ] Game mechanics are broken down into clear, implementable steps +- [ ] Godot-specific patterns are documented with examples +- [ ] Complex game logic is simplified into node interactions +- [ ] State machines and game flow are explicitly defined +- [ ] Node communication patterns are predictable + +### 9.3 Implementation Support + +- [ ] Godot project structure templates are provided +- [ ] Node implementation patterns are documented +- [ ] Common Godot pitfalls are identified with solutions +- [ ] Game system testing patterns are clearly defined +- [ ] Performance optimization guidelines are explicit + +## 10. PLATFORM & PUBLISHING CONSIDERATIONS + +[[LLM: Different platforms have different requirements and constraints. Consider mobile app stores, desktop platforms, and web deployment. Look for platform-specific optimizations and compliance requirements.]] + +### 10.1 Platform-Specific Architecture + +- [ ] Mobile platform constraints are properly addressed +- [ ] Desktop platform features are leveraged appropriately +- [ ] Web platform limitations are considered if applicable +- [ ] Console platform requirements are addressed if applicable +- [ ] Platform-specific input handling is planned + +### 10.2 Publishing & Distribution + +- [ ] App store compliance requirements are addressed +- [ ] Platform-specific build configurations are defined +- [ ] Update and patch deployment strategy is planned +- [ ] Platform analytics integration is considered +- [ ] Platform-specific monetization is addressed if applicable + +[[LLM: FINAL GAME ARCHITECTURE VALIDATION REPORT + +Generate a comprehensive validation report that includes: + +1. Executive Summary + - Overall game architecture readiness (High/Medium/Low) + - Critical risks for game development + - Key strengths of the game architecture + - Godot-specific assessment + +2. Game Systems Analysis + - Pass rate for each major system section + - Most concerning gaps in game architecture + - Systems requiring immediate attention + - Godot integration completeness + +3. Performance Risk Assessment + - Top 5 performance risks for the game + - Mobile platform specific concerns + - Frame rate stability risks + - Memory usage concerns + +4. Implementation Recommendations + - Must-fix items before development + - Godot-specific improvements needed + - Game development workflow enhancements + +5. AI Agent Implementation Readiness + - Game-specific concerns for AI implementation + - Godot node complexity assessment + - Areas needing additional clarification + +6. Game Development Workflow Assessment + - Asset pipeline completeness + - Team collaboration workflow clarity + - Build and deployment readiness + - Testing strategy completeness + +After presenting the report, ask the user if they would like detailed analysis of any specific game system or Godot-specific concerns.]] diff --git a/expansion-packs/bmad-2d-godot-game-dev/checklists/game-change-checklist.md b/expansion-packs/bmad-2d-godot-game-dev/checklists/game-change-checklist.md new file mode 100644 index 00000000..9896f95c --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/checklists/game-change-checklist.md @@ -0,0 +1,203 @@ +# Game Development Change Navigation Checklist + +**Purpose:** To systematically guide the Game SM agent and user through analysis and planning when a significant change (performance issue, platform constraint, technical blocker, gameplay feedback) is identified during Godot game development. + +**Instructions:** Review each item with the user. Mark `[x]` for completed/confirmed, `[N/A]` if not applicable, or add notes for discussion points. + +[[LLM: INITIALIZATION INSTRUCTIONS - GAME CHANGE NAVIGATION + +Changes during game development are common - performance issues, platform constraints, gameplay feedback, and technical limitations are part of the process. + +Before proceeding, understand: + +1. This checklist is for SIGNIFICANT changes affecting game architecture or features +2. Minor tweaks (shader adjustments, UI positioning) don't require this process +3. The goal is to maintain playability while adapting to technical realities +4. Performance and player experience are paramount + +Required context: + +- The triggering issue (performance metrics, crash logs, feedback) +- Current development state (implemented features, current sprint) +- Access to GDD, technical specs, and performance budgets +- Understanding of remaining features and milestones + +APPROACH: +This is an interactive process. Discuss performance implications, platform constraints, and player impact. The user makes final decisions, but provide expert Godot/game dev guidance. + +REMEMBER: Game development is iterative. Changes often lead to better gameplay and performance.]] + +--- + +## 1. Understand the Trigger & Context + +[[LLM: Start by understanding the game-specific issue. Ask technical questions: + +- What performance metrics triggered this? (FPS, memory, load times) +- Is this platform-specific or universal? +- Can we reproduce it consistently? +- What Godot profiler data do we have? +- Is this a gameplay issue or technical constraint? + +Focus on measurable impacts and technical specifics.]] + +- [ ] **Identify Triggering Element:** Clearly identify the game feature/system revealing the issue. +- [ ] **Define the Issue:** Articulate the core problem precisely. + - [ ] Performance bottleneck (CPU/GPU/Memory)? + - [ ] Platform-specific limitation? + - [ ] Godot engine constraint? + - [ ] Gameplay/balance issue from playtesting? + - [ ] Asset pipeline or build size problem? + - [ ] Third-party SDK/plugin conflict? +- [ ] **Assess Performance Impact:** Document specific metrics (current FPS, target FPS, memory usage, build size). +- [ ] **Gather Technical Evidence:** Note profiler data, crash logs, platform test results, player feedback. + +## 2. Game Feature Impact Assessment + +[[LLM: Game features are interconnected. Evaluate systematically: + +1. Can we optimize the current feature without changing gameplay? +2. Do dependent features need adjustment? +3. Are there platform-specific workarounds? +4. Does this affect our performance budget allocation? + +Consider both technical and gameplay impacts.]] + +- [ ] **Analyze Current Sprint Features:** + - [ ] Can the current feature be optimized (LOD, pooling, batching)? + - [ ] Does it need gameplay simplification? + - [ ] Should it be platform-specific (high-end only)? +- [ ] **Analyze Dependent Systems:** + - [ ] Review all game systems interacting with the affected feature. + - [ ] Do physics systems need adjustment? + - [ ] Are UI/HUD systems impacted? + - [ ] Do save/load systems require changes? + - [ ] Are multiplayer systems affected? +- [ ] **Summarize Feature Impact:** Document effects on gameplay systems and technical architecture. + +## 3. Game Artifact Conflict & Impact Analysis + +[[LLM: Game documentation drives development. Check each artifact: + +1. Does this invalidate GDD mechanics? +2. Are technical architecture assumptions still valid? +3. Do performance budgets need reallocation? +4. Are platform requirements still achievable? + +Missing conflicts cause performance issues later.]] + +- [ ] **Review GDD:** + - [ ] Does the issue conflict with core gameplay mechanics? + - [ ] Do game features need scaling for performance? + - [ ] Are progression systems affected? + - [ ] Do balance parameters need adjustment? +- [ ] **Review Technical Architecture:** + - [ ] Does the issue conflict with Godot architecture (scene structure, scene hierarchy)? + - [ ] Are component systems impacted? + - [ ] Do shader/rendering approaches need revision? + - [ ] Are data structures optimal for the scale? +- [ ] **Review Performance Specifications:** + - [ ] Are target framerates still achievable? + - [ ] Do memory budgets need reallocation? + - [ ] Are load time targets realistic? + - [ ] Do we need platform-specific targets? +- [ ] **Review Asset Specifications:** + - [ ] Do texture resolutions need adjustment? + - [ ] Are model poly counts appropriate? + - [ ] Do audio compression settings need changes? + - [ ] Is the animation budget sustainable? +- [ ] **Summarize Artifact Impact:** List all game documents requiring updates. + +## 4. Path Forward Evaluation + +[[LLM: Present game-specific solutions with technical trade-offs: + +1. What's the performance gain? +2. How much rework is required? +3. What's the player experience impact? +4. Are there platform-specific solutions? +5. Is this maintainable across updates? + +Be specific about Godot implementation details.]] + +- [ ] **Option 1: Optimization Within Current Design:** + - [ ] Can performance be improved through Godot optimizations? + - [ ] Object pooling implementation? + - [ ] LOD system addition? + - [ ] Texture atlasing? + - [ ] Draw call batching? + - [ ] Shader optimization? + - [ ] Define specific optimization techniques. + - [ ] Estimate performance improvement potential. +- [ ] **Option 2: Feature Scaling/Simplification:** + - [ ] Can the feature be simplified while maintaining fun? + - [ ] Identify specific elements to scale down. + - [ ] Define platform-specific variations. + - [ ] Assess player experience impact. +- [ ] **Option 3: Architecture Refactor:** + - [ ] Would restructuring improve performance significantly? + - [ ] Identify Godot-specific refactoring needs: + - [ ] Scene organization changes? + - [ ] Scene structure optimization? + - [ ] Component system redesign? + - [ ] State machine optimization? + - [ ] Estimate development effort. +- [ ] **Option 4: Scope Adjustment:** + - [ ] Can we defer features to post-launch? + - [ ] Should certain features be platform-exclusive? + - [ ] Do we need to adjust milestone deliverables? +- [ ] **Select Recommended Path:** Choose based on performance gain vs. effort. + +## 5. Game Development Change Proposal Components + +[[LLM: The proposal must include technical specifics: + +1. Performance metrics (before/after projections) +2. Godot implementation details +3. Platform-specific considerations +4. Testing requirements +5. Risk mitigation strategies + +Make it actionable for game developers.]] + +(Ensure all points from previous sections are captured) + +- [ ] **Technical Issue Summary:** Performance/technical problem with metrics. +- [ ] **Feature Impact Summary:** Affected game systems and dependencies. +- [ ] **Performance Projections:** Expected improvements from chosen solution. +- [ ] **Implementation Plan:** Godot-specific technical approach. +- [ ] **Platform Considerations:** Any platform-specific implementations. +- [ ] **Testing Strategy:** Performance benchmarks and validation approach. +- [ ] **Risk Assessment:** Technical risks and mitigation plans. +- [ ] **Updated Game Stories:** Revised stories with technical constraints. + +## 6. Final Review & Handoff + +[[LLM: Game changes require technical validation. Before concluding: + +1. Are performance targets clearly defined? +2. Is the Godot implementation approach clear? +3. Do we have rollback strategies? +4. Are test scenarios defined? +5. Is platform testing covered? + +Get explicit approval on technical approach. + +FINAL REPORT: +Provide a technical summary: + +- Performance issue and root cause +- Chosen solution with expected gains +- Implementation approach in Godot +- Testing and validation plan +- Timeline and milestone impacts + +Keep it technically precise and actionable.]] + +- [ ] **Review Checklist:** Confirm all technical aspects discussed. +- [ ] **Review Change Proposal:** Ensure Godot implementation details are clear. +- [ ] **Performance Validation:** Define how we'll measure success. +- [ ] **User Approval:** Obtain approval for technical approach. +- [ ] **Developer Handoff:** Ensure game-dev agent has all technical details needed. + +--- diff --git a/expansion-packs/bmad-2d-godot-game-dev/checklists/game-design-checklist.md b/expansion-packs/bmad-2d-godot-game-dev/checklists/game-design-checklist.md new file mode 100644 index 00000000..83d6ed8b --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/checklists/game-design-checklist.md @@ -0,0 +1,201 @@ +# Game Design Document Quality Checklist + +## Document Completeness + +### Executive Summary + +- [ ] **Core Concept** - Game concept is clearly explained in 2-3 sentences +- [ ] **Target Audience** - Primary and secondary audiences defined with demographics +- [ ] **Platform Requirements** - Technical platforms and requirements specified +- [ ] **Unique Selling Points** - 3-5 key differentiators from competitors identified +- [ ] **Technical Foundation** - Godot & C# or GDScript requirements confirmed + +### Game Design Foundation + +- [ ] **Game Pillars** - 3-5 core design pillars defined and actionable +- [ ] **Core Gameplay Loop** - 30-60 second loop documented with specific timings +- [ ] **Win/Loss Conditions** - Clear victory and failure states defined +- [ ] **Player Motivation** - Clear understanding of why players will engage +- [ ] **Scope Realism** - Game scope is achievable with available resources + +## Gameplay Mechanics + +### Core Mechanics Documentation + +- [ ] **Primary Mechanics** - 3-5 core mechanics detailed with implementation notes +- [ ] **Mechanic Integration** - How mechanics work together is clear +- [ ] **Player Input** - All input methods specified for each platform +- [ ] **System Responses** - Game responses to player actions documented +- [ ] **Performance Impact** - Performance considerations for each mechanic noted + +### Controls and Interaction + +- [ ] **Multi-Platform Controls** - Desktop, mobile, and gamepad controls defined +- [ ] **Input Responsiveness** - Requirements for responsive game feel specified +- [ ] **Accessibility Options** - Control customization and accessibility considered +- [ ] **Touch Optimization** - Mobile-specific control adaptations designed +- [ ] **Edge Case Handling** - Unusual input scenarios addressed + +## Progression and Balance + +### Player Progression + +- [ ] **Progression Type** - Linear, branching, or metroidvania approach defined +- [ ] **Key Milestones** - Major progression points documented +- [ ] **Unlock System** - What players unlock and when is specified +- [ ] **Difficulty Scaling** - How challenge increases over time is detailed +- [ ] **Player Agency** - Meaningful player choices and consequences defined + +### Game Balance + +- [ ] **Balance Parameters** - Numeric values for key game systems provided +- [ ] **Difficulty Curve** - Appropriate challenge progression designed +- [ ] **Economy Design** - Resource systems balanced for engagement +- [ ] **Player Testing** - Plan for validating balance through playtesting +- [ ] **Iteration Framework** - Process for adjusting balance post-implementation + +## Level Design Framework + +### Level Structure + +- [ ] **Level Types** - Different level categories defined with purposes +- [ ] **Level Progression** - How players move through levels specified +- [ ] **Duration Targets** - Expected play time for each level type +- [ ] **Difficulty Distribution** - Appropriate challenge spread across levels +- [ ] **Replay Value** - Elements that encourage repeated play designed + +### Content Guidelines + +- [ ] **Level Creation Rules** - Clear guidelines for level designers +- [ ] **Mechanic Introduction** - How new mechanics are taught in levels +- [ ] **Pacing Variety** - Mix of action, puzzle, and rest moments planned +- [ ] **Secret Content** - Hidden areas and optional challenges designed +- [ ] **Accessibility Options** - Multiple difficulty levels or assist modes considered + +## Technical Implementation Readiness + +### Performance Requirements + +- [ ] **Frame Rate Targets** - Stable FPS target with minimum acceptable rates +- [ ] **Memory Budgets** - Maximum memory usage limits defined +- [ ] **Load Time Goals** - Acceptable loading times for different content +- [ ] **Battery Optimization** - Mobile battery usage considerations addressed +- [ ] **Scalability Plan** - How performance scales across different devices + +### Platform Specifications + +- [ ] **Desktop Requirements** - Minimum and recommended PC/Mac specs +- [ ] **Mobile Optimization** - iOS and Android specific requirements +- [ ] **Browser Compatibility** - Supported browsers and versions listed +- [ ] **Cross-Platform Features** - Shared and platform-specific features identified +- [ ] **Update Strategy** - Plan for post-launch updates and patches + +### Asset Requirements + +- [ ] **Art Style Definition** - Clear visual style with reference materials +- [ ] **Asset Specifications** - Technical requirements for all asset types +- [ ] **Audio Requirements** - Music and sound effect specifications +- [ ] **UI/UX Guidelines** - User interface design principles established +- [ ] **Localization Plan** - Text and cultural localization requirements + +## Development Planning + +### Implementation Phases + +- [ ] **Phase Breakdown** - Development divided into logical phases +- [ ] **Epic Definitions** - Major development epics identified +- [ ] **Dependency Mapping** - Prerequisites between features documented +- [ ] **Risk Assessment** - Technical and design risks identified with mitigation +- [ ] **Milestone Planning** - Key deliverables and deadlines established + +### Team Requirements + +- [ ] **Role Definitions** - Required team roles and responsibilities +- [ ] **Skill Requirements** - Technical skills needed for implementation +- [ ] **Resource Allocation** - Time and effort estimates for major features +- [ ] **External Dependencies** - Third-party tools, assets, or services needed +- [ ] **Communication Plan** - How team members will coordinate work + +## Quality Assurance + +### Success Metrics + +- [ ] **Technical Metrics** - Measurable technical performance goals +- [ ] **Gameplay Metrics** - Player engagement and retention targets +- [ ] **Quality Benchmarks** - Standards for bug rates and polish level +- [ ] **User Experience Goals** - Specific UX objectives and measurements +- [ ] **Business Objectives** - Commercial or project success criteria + +### Testing Strategy + +- [ ] **Playtesting Plan** - How and when player feedback will be gathered +- [ ] **Technical Testing** - Performance and compatibility testing approach +- [ ] **Balance Validation** - Methods for confirming game balance +- [ ] **Accessibility Testing** - Plan for testing with diverse players +- [ ] **Iteration Process** - How feedback will drive design improvements + +## Documentation Quality + +### Clarity and Completeness + +- [ ] **Clear Writing** - All sections are well-written and understandable +- [ ] **Complete Coverage** - No major game systems left undefined +- [ ] **Actionable Detail** - Enough detail for developers to create implementation stories +- [ ] **Consistent Terminology** - Game terms used consistently throughout +- [ ] **Reference Materials** - Links to inspiration, research, and additional resources + +### Maintainability + +- [ ] **Version Control** - Change log established for tracking revisions +- [ ] **Update Process** - Plan for maintaining document during development +- [ ] **Team Access** - All team members can access and reference the document +- [ ] **Search Functionality** - Document organized for easy reference and searching +- [ ] **Living Document** - Process for incorporating feedback and changes + +## Stakeholder Alignment + +### Team Understanding + +- [ ] **Shared Vision** - All team members understand and agree with the game vision +- [ ] **Role Clarity** - Each team member understands their contribution +- [ ] **Decision Framework** - Process for making design decisions during development +- [ ] **Conflict Resolution** - Plan for resolving disagreements about design choices +- [ ] **Communication Channels** - Regular meetings and feedback sessions planned + +### External Validation + +- [ ] **Market Validation** - Competitive analysis and market fit assessment +- [ ] **Technical Validation** - Feasibility confirmed with technical team +- [ ] **Resource Validation** - Required resources available and committed +- [ ] **Timeline Validation** - Development schedule is realistic and achievable +- [ ] **Quality Validation** - Quality standards align with available time and resources + +## Final Readiness Assessment + +### Implementation Preparedness + +- [ ] **Story Creation Ready** - Document provides sufficient detail for story creation +- [ ] **Architecture Alignment** - Game design aligns with technical capabilities +- [ ] **Asset Production** - Asset requirements enable art and audio production +- [ ] **Development Workflow** - Clear path from design to implementation +- [ ] **Quality Assurance** - Testing and validation processes established + +### Document Approval + +- [ ] **Design Review Complete** - Document reviewed by all relevant stakeholders +- [ ] **Technical Review Complete** - Technical feasibility confirmed +- [ ] **Business Review Complete** - Project scope and goals approved +- [ ] **Final Approval** - Document officially approved for implementation +- [ ] **Baseline Established** - Current version established as development baseline + +## Overall Assessment + +**Document Quality Rating:** ⭐⭐⭐⭐⭐ + +**Ready for Development:** [ ] Yes [ ] No + +**Key Recommendations:** +_List any critical items that need attention before moving to implementation phase._ + +**Next Steps:** +_Outline immediate next actions for the team based on this assessment._ diff --git a/expansion-packs/bmad-2d-godot-game-dev/checklists/game-story-dod-checklist.md b/expansion-packs/bmad-2d-godot-game-dev/checklists/game-story-dod-checklist.md new file mode 100644 index 00000000..9f32d086 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/checklists/game-story-dod-checklist.md @@ -0,0 +1,124 @@ +# Game Development Story Definition of Done (DoD) Checklist + +## Instructions for Developer Agent + +Before marking a story as 'Review', please go through each item in this checklist. Report the status of each item (e.g., [x] Done, [ ] Not Done, [N/A] Not Applicable) and provide brief comments if necessary. + +[[LLM: INITIALIZATION INSTRUCTIONS - GAME STORY DOD VALIDATION + +This checklist is for GAME DEVELOPER AGENTS to self-validate their work before marking a story complete. + +IMPORTANT: This is a self-assessment. Be honest about what's actually done vs what should be done. It's better to identify issues now than have them found in review. + +EXECUTION APPROACH: + +1. Go through each section systematically +2. Mark items as [x] Done, [ ] Not Done, or [N/A] Not Applicable +3. Add brief comments explaining any [ ] or [N/A] items +4. Be specific about what was actually implemented +5. Flag any concerns or technical debt created + +The goal is quality delivery, not just checking boxes.]] + +## Checklist Items + +1. **Requirements Met:** + + [[LLM: Be specific - list each requirement and whether it's complete. Include game-specific requirements from GDD]] + - [ ] All functional requirements specified in the story are implemented. + - [ ] All acceptance criteria defined in the story are met. + - [ ] Game Design Document (GDD) requirements referenced in the story are implemented. + - [ ] Player experience goals specified in the story are achieved. + +2. **Coding Standards & Project Structure:** + + [[LLM: Code quality matters for maintainability. Check Godot-specific patterns and language standards]] + - [ ] All new/modified code strictly adheres to `Operational Guidelines`. + - [ ] All new/modified code aligns with `Project Structure` (scripts/, scenes/, resources/, etc.). + - [ ] Adherence to `Tech Stack` for Godot version and packages used. + - [ ] Adherence to `Api Reference` and `Data Models` (if story involves API or data model changes). + - [ ] Godot best practices followed (scene usage, node design, signal handling). + - [ ] GDScript/C# coding standards followed (naming conventions, error handling, memory management). + - [ ] Basic security best practices applied for new/modified code. + - [ ] No new linter errors or warnings introduced. + - [ ] Code is well-commented where necessary (clarifying complex logic, not obvious statements). + +3. **Testing:** + + [[LLM: Testing proves your code works. Include Godot-specific testing with GUT (GDScript) or GoDotTest (C#) and manual testing]] + - [ ] All required unit tests (GUT for GDScript, GoDotTest for C#) as per the story and testing strategy are implemented. + - [ ] All required integration tests (if applicable) are implemented. + - [ ] Manual testing performed in Godot Editor for all game functionality. + - [ ] All tests (unit, integration, manual) pass successfully. + - [ ] Test coverage meets project standards (if defined). + - [ ] Performance tests conducted (frame rate, memory usage). + - [ ] Edge cases and error conditions tested. + +4. **Functionality & Verification:** + + [[LLM: Did you actually run and test your code in Godot? Be specific about game mechanics tested]] + - [ ] Functionality has been manually verified in Godot Editor and play mode. + - [ ] Game mechanics work as specified in the GDD. + - [ ] Player controls and input handling work correctly. + - [ ] UI elements function properly (if applicable). + - [ ] Audio integration works correctly (if applicable). + - [ ] Visual feedback and animations work as intended. + - [ ] Edge cases and potential error conditions handled gracefully. + - [ ] Cross-platform functionality verified (desktop/mobile as applicable). + +5. **Story Administration:** + + [[LLM: Documentation helps the next developer. Include Godot-specific implementation notes]] + - [ ] All tasks within the story file are marked as complete. + - [ ] Any clarifications or decisions made during development are documented. + - [ ] Godot-specific implementation details documented (scene changes, scene modifications). + - [ ] The story wrap up section has been completed with notes of changes. + - [ ] Changelog properly updated with Godot version and package changes. + +6. **Dependencies, Build & Configuration:** + + [[LLM: Build issues block everyone. Ensure Godot project builds for all target platforms]] + - [ ] Godot project builds successfully without errors. + - [ ] Project builds for all target platforms (desktop/mobile as specified). + - [ ] Any new Godot packages or Asset Library items were pre-approved OR approved by user. + - [ ] If new dependencies were added, they are recorded with justification. + - [ ] No known security vulnerabilities in newly added dependencies. + - [ ] Project settings and configurations properly updated. + - [ ] Asset import settings optimized for target platforms. + +7. **Game-Specific Quality:** + + [[LLM: Game quality matters. Check performance, game feel, and player experience]] + - [ ] Frame rate meets target (30/60 FPS) on all platforms. + - [ ] Memory usage within acceptable limits. + - [ ] Game feel and responsiveness meet design requirements. + - [ ] Balance parameters from GDD correctly implemented. + - [ ] State management and persistence work correctly. + - [ ] Loading times and scene transitions acceptable. + - [ ] Mobile-specific requirements met (touch controls, aspect ratios). + +8. **Documentation (If Applicable):** + + [[LLM: Good documentation prevents future confusion. Include Godot-specific docs]] + - [ ] Code documentation (XML comments) for public APIs complete. + - [ ] Godot component documentation in Inspector updated. + - [ ] User-facing documentation updated, if changes impact players. + - [ ] Technical documentation (architecture, system diagrams) updated. + - [ ] Asset documentation (scene usage, scene setup) complete. + +## Final Confirmation + +[[LLM: FINAL GAME DOD SUMMARY + +After completing the checklist: + +1. Summarize what game features/mechanics were implemented +2. List any items marked as [ ] Not Done with explanations +3. Identify any technical debt or performance concerns +4. Note any challenges with Godot implementation or game design +5. Confirm whether the story is truly ready for review +6. Report final performance metrics (FPS, memory usage) + +Be honest - it's better to flag issues now than have them discovered during playtesting.]] + +- [ ] I, the Game Developer Agent, confirm that all applicable items above have been addressed. diff --git a/expansion-packs/bmad-2d-godot-game-dev/config.yaml b/expansion-packs/bmad-2d-godot-game-dev/config.yaml new file mode 100644 index 00000000..996bf1e8 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/config.yaml @@ -0,0 +1,6 @@ +name: bmad-2d-godot-game-dev +version: 1.0.0 +short-title: Godot 2D Game Dev Pack +description: 2D Game Development expansion pack for BMad Method - Godot focused +author: sjennings (Lum), based heavily on prior work for Unity by pbean (PinkyD) +slashPrefix: bmad2dg diff --git a/expansion-packs/bmad-2d-godot-game-dev/data/bmad-kb.md b/expansion-packs/bmad-2d-godot-game-dev/data/bmad-kb.md new file mode 100644 index 00000000..1ffc62c4 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/data/bmad-kb.md @@ -0,0 +1,769 @@ +# BMad Knowledge Base - 2D Godot Game Development + +## Overview + +This is the game development expansion of BMad-Method (Breakthrough Method of Agile AI-driven Development), specializing in creating 2D games using Godot and GDScript/C#. The v4 system introduces a modular architecture with improved dependency management, bundle optimization, and support for both web and IDE environments, specifically optimized for game development workflows. + +### Key Features for Game Development + +- **Game-Specialized Agent System**: AI agents for each game development role (Designer, Developer, Scrum Master) +- **Godot-Optimized Build System**: Automated dependency resolution for game assets and scripts +- **Dual Environment Support**: Optimized for both web UIs and game development IDEs +- **Game Development Resources**: Specialized templates, tasks, and checklists for 2D Godot games +- **Performance-First Approach**: Built-in optimization patterns for cross-platform game deployment + +### Game Development Focus + +- **Target Engine**: Godot 4.2 LTS or newer with GDScript 2.0 or C# (.NET 6+) +- **Platform Strategy**: Cross-platform (PC, Console, Mobile) with a focus on 2D +- **Development Approach**: Agile story-driven development with game-specific workflows +- **Performance Target**: Stable frame rate on target devices +- **Architecture**: Node-based architecture using Godot's best practices + +### When to Use BMad for Game Development + +- **New Game Projects (Greenfield)**: Complete end-to-end game development from concept to deployment +- **Existing Game Projects (Brownfield)**: Feature additions, level expansions, and gameplay enhancements +- **Game Team Collaboration**: Multiple specialized roles working together on game features +- **Game Quality Assurance**: Structured testing, performance validation, and gameplay balance +- **Game Documentation**: Professional Game Design Documents, technical architecture, user stories + +## How BMad Works for Game Development + +### The Core Method + +BMad transforms you into a "Player Experience CEO" - directing a team of specialized game development AI agents through structured workflows. Here's how: + +1. **You Direct, AI Executes**: You provide game vision and creative decisions; agents handle implementation details +2. **Specialized Game Agents**: Each agent masters one game development role (Designer, Developer, Scrum Master) +3. **Game-Focused Workflows**: Proven patterns guide you from game concept to deployed 2D Godot game +4. **Clean Handoffs**: Fresh context windows ensure agents stay focused and effective for game development + +### The Two-Phase Game Development Approach + +#### Phase 1: Game Design & Planning (Web UI - Cost Effective) + +- Use large context windows for comprehensive game design +- Generate complete Game Design Documents and technical architecture +- Leverage multiple agents for creative brainstorming and mechanics refinement +- Create once, use throughout game development + +#### Phase 2: Game Development (IDE - Implementation) + +- Shard game design documents into manageable pieces +- Execute focused SM → Dev cycles for game features +- One game story at a time, sequential progress +- Real-time Godot operations, GDScript/C# coding, and game testing + +### The Game Development Loop + +```text +1. Game SM Agent (New Chat) → Creates next game story from sharded docs +2. You → Review and approve game story +3. Game Dev Agent (New Chat) → Implements approved game feature in Godot +4. QA Agent (New Chat) → Reviews code and tests gameplay +5. You → Verify game feature completion +6. Repeat until game epic complete +``` + +### Why This Works for Games + +- **Context Optimization**: Clean chats = better AI performance for complex game logic +- **Role Clarity**: Agents don't context-switch = higher quality game features +- **Incremental Progress**: Small game stories = manageable complexity +- **Player-Focused Oversight**: You validate each game feature = quality control +- **Design-Driven**: Game specs guide everything = consistent player experience + +### Core Game Development Philosophy + +#### Player-First Development + +You are developing games as a "Player Experience CEO" - thinking like a game director with unlimited creative resources and a singular vision for player enjoyment. + +#### Game Development Principles + +1. **MAXIMIZE_PLAYER_ENGAGEMENT**: Push the AI to create compelling gameplay. Challenge mechanics and iterate. +2. **GAMEPLAY_QUALITY_CONTROL**: You are the ultimate arbiter of fun. Review all game features. +3. **CREATIVE_OVERSIGHT**: Maintain the high-level game vision and ensure design alignment. +4. **ITERATIVE_REFINEMENT**: Expect to revisit game mechanics. Game development is not linear. +5. **CLEAR_GAME_INSTRUCTIONS**: Precise game requirements lead to better implementations. +6. **DOCUMENTATION_IS_KEY**: Good game design docs lead to good game features. +7. **START_SMALL_SCALE_FAST**: Test core mechanics, then expand and polish. +8. **EMBRACE_CREATIVE_CHAOS**: Adapt and overcome game development challenges. + +## Getting Started with Game Development + +### Quick Start Options for Game Development + +#### Option 1: Web UI for Game Design + +**Best for**: Game designers who want to start with comprehensive planning + +1. Navigate to `dist/teams/` (after building) +2. Copy `godot-2d-game-team.txt` content +3. Create new Gemini Gem or CustomGPT +4. Upload file with instructions: "Your critical operating instructions are attached, do not break character as directed" +5. Type `/help` to see available game development commands + +#### Option 2: IDE Integration for Game Development + +**Best for**: Godot developers using Cursor, Claude Code, Windsurf, Trae, Cline, Roo Code, Github Copilot + +```bash +# Interactive installation (recommended) +npx bmad-method install +# Select the bmad-2d-godot-game-dev expansion pack when prompted +``` + +**Installation Steps for Game Development**: + +- Choose "Install expansion pack" when prompted +- Select "bmad-2d-godot-game-dev" from the list +- Select your IDE from supported options: + - **Cursor**: Native AI integration with Godot support + - **Claude Code**: Anthropic's official IDE + - **Windsurf**: Built-in AI capabilities + - **Trae**: Built-in AI capabilities + - **Cline**: VS Code extension with AI features + - **Roo Code**: Web-based IDE with agent support + - **GitHub Copilot**: VS Code extension with AI peer programming assistant + +**Verify Game Development Installation**: + +- `.bmad-core/` folder created with all core agents +- `.bmad-2d-godot-game-dev/` folder with game development agents +- IDE-specific integration files created +- Game development agents available with `/bmad2dg` prefix (per config.yaml) + +### Environment Selection Guide for Game Development + +**Use Web UI for**: + +- Game design document creation and brainstorming +- Cost-effective comprehensive game planning (especially with Gemini) +- Multi-agent game design consultation +- Creative ideation and mechanics refinement + +**Use IDE for**: + +- Godot project development and GDScript/C# coding +- Game asset operations and project integration +- Game story management and implementation workflow +- Godot testing, profiling, and debugging + +**Cost-Saving Tip for Game Development**: Create large game design documents in web UI, then copy to `docs/game-design-doc.md` and `docs/game-architecture.md` in your Godot project before switching to IDE for development. + +### IDE-Only Game Development Workflow Considerations + +**Can you do everything in IDE?** Yes, but understand the game development tradeoffs: + +**Pros of IDE-Only Game Development**: + +- Single environment workflow from design to Godot deployment +- Direct Godot project operations from start +- No copy/paste between environments +- Immediate Godot project integration + +**Cons of IDE-Only Game Development**: + +- Higher token costs for large game design document creation +- Smaller context windows for comprehensive game planning +- May hit limits during creative brainstorming phases +- Less cost-effective for extensive game design iteration + +**CRITICAL RULE for Game Development**: + +- **ALWAYS use Game SM agent for story creation** - Never use bmad-master or bmad-orchestrator +- **ALWAYS use Game Dev agent for Godot implementation** - Never use bmad-master or bmad-orchestrator +- **Why this matters**: Game SM and Game Dev agents are specifically optimized for Godot workflows +- **No exceptions**: Even if using bmad-master for design, switch to Game SM → Game Dev for implementation + +## Core Configuration for Game Development (core-config.yaml) + +**New in V4**: The `expansion-packs/bmad-2d-godot-game-dev/core-config.yaml` file enables BMad to work seamlessly with any Godot project structure, providing maximum flexibility for game development. + +### Game Development Configuration + +The expansion pack follows the standard BMad configuration patterns. Copy your core-config.yaml file to expansion-packs/bmad-2d-godot-game-dev/ and add Game-specific configurations to your project's `core-config.yaml`: + +```yaml +markdownExploder: true +prd: + prdFile: docs/prd.md + prdVersion: v4 + prdSharded: true + prdShardedLocation: docs/prd + epicFilePattern: epic-{n}*.md +architecture: + architectureFile: docs/architecture.md + architectureVersion: v4 + architectureSharded: true + architectureShardedLocation: docs/architecture +gdd: + gddVersion: v4 + gddSharded: true + gddLocation: docs/game-design-doc.md + gddShardedLocation: docs/gdd + epicFilePattern: epic-{n}*.md +gamearchitecture: + gamearchitectureFile: docs/architecture.md + gamearchitectureVersion: v3 + gamearchitectureLocation: docs/game-architecture.md + gamearchitectureSharded: true + gamearchitectureShardedLocation: docs/game-architecture +gamebriefdocLocation: docs/game-brief.md +levelDesignLocation: docs/level-design.md +#Specify the location for your godot editor - be sure to check this! It will vary based on operating system +godotEditorLocation: /Applications/Godot.app/Contents/MacOS/Godot +customTechnicalDocuments: null +devDebugLog: .ai/debug-log.md +devStoryLocation: docs/stories +slashPrefix: bmad2dg +#replace old devLoadAlwaysFiles with this once you have sharded your gamearchitecture document +devLoadAlwaysFiles: + - docs/game-architecture/9-coding-standards.md + - docs/game-architecture/3-tech-stack.md + - docs/game-architecture/8-godot-project-structure.md +``` + +## Complete Game Development Workflow + +### Planning Phase (Web UI Recommended - Especially Gemini for Game Design!) + +**Ideal for cost efficiency with Gemini's massive context for game brainstorming:** + +**For All Game Projects**: + +1. **Game Concept Brainstorming**: `/bmad2dg/game-designer` - Use `*game-design-brainstorming` task +2. **Game Brief**: Create foundation game document using `game-brief-tmpl` +3. **Game Design Document Creation**: `/bmad2dg/game-designer` - Use `game-design-doc-tmpl` for comprehensive game requirements +4. **Game Architecture Design**: `/bmad2dg/game-architect` - Use `game-architecture-tmpl` for Godot technical foundation +5. **Level Design Framework**: `/bmad2dg/game-designer` - Use `level-design-doc-tmpl` for level structure planning +6. **Document Preparation**: Copy final documents to Godot project as `docs/game-design-doc.md`, `docs/game-brief.md`, `docs/level-design.md` and `docs/game-architecture.md` + +#### Example Game Planning Prompts + +**For Game Design Document Creation**: + +```text +"I want to build a [genre] 2D game that [core gameplay]. +Help me brainstorm mechanics and create a comprehensive Game Design Document." +``` + +**For Game Architecture Design**: + +```text +"Based on this Game Design Document, design a scalable Godot architecture +that can handle [specific game requirements] with stable performance." +``` + +### Critical Transition: Web UI to Godot IDE + +**Once game planning is complete, you MUST switch to IDE for Godot development:** + +- **Why**: Godot development workflow requires GDScript/C# operations, asset management, and real-time Godot testing +- **Cost Benefit**: Web UI is more cost-effective for large game design creation; IDE is optimized for Godot development +- **Required Files**: Ensure `docs/game-design-doc.md` and `docs/game-architecture.md` exist in your Godot project + +### Godot IDE Development Workflow + +**Prerequisites**: Game planning documents must exist in `docs/` folder of Godot project + +1. **Document Sharding** (CRITICAL STEP for Game Development): + - Documents created by Game Designer/Architect (in Web or IDE) MUST be sharded for development + - Use core BMad agents or tools to shard: + a) **Manual**: Use core BMad `shard-doc` task if available + b) **Agent**: Ask core `@bmad-master` agent to shard documents + - Shards `docs/game-design-doc.md` → `docs/game-design/` folder + - Shards `docs/game-architecture.md` → `docs/game-architecture/` folder + - **WARNING**: Do NOT shard in Web UI - copying many small files to Godot is painful! + +2. **Verify Sharded Game Content**: + - At least one `feature-n.md` file in `docs/game-design/` with game stories in development order + - Godot system documents and coding standards for game dev agent reference + - Sharded docs for Game SM agent story creation + +Resulting Godot Project Folder Structure: + +- `docs/game-design/` - Broken down game design sections +- `docs/game-architecture/` - Broken down Godot architecture sections +- `docs/game-stories/` - Generated game development stories + +3. **Game Development Cycle** (Sequential, one game story at a time): + + **CRITICAL CONTEXT MANAGEMENT for Godot Development**: + - **Context windows matter!** Always use fresh, clean context windows + - **Model selection matters!** Use most powerful thinking model for Game SM story creation + - **ALWAYS start new chat between Game SM, Game Dev, and QA work** + + **Step 1 - Game Story Creation**: + - **NEW CLEAN CHAT** → Select powerful model → `/bmad2dg/game-sm` → `*draft` + - Game SM executes create-game-story task using `game-story-tmpl` + - Review generated story in `docs/game-stories/` + - Update status from "Draft" to "Approved" + + **Step 2 - Godot Game Story Implementation**: + - **NEW CLEAN CHAT** → `/bmad2dg/game-developer` + - Agent asks which game story to implement + - Include story file content to save game dev agent lookup time + - Game Dev follows tasks/subtasks, marking completion + - Game Dev maintains File List of all Godot/GDScript/C# changes + - Game Dev marks story as "Review" when complete with all Godot tests passing + + **Step 3 - Game QA Review**: + - **NEW CLEAN CHAT** → Use core `@qa` agent → execute review-story task + - QA performs senior Godot developer code review + - QA can refactor and improve Godot code directly + - QA appends results to story's QA Results section + - If approved: Status → "Done" + - If changes needed: Status stays "Review" with unchecked items for game dev + + **Step 4 - Repeat**: Continue Game SM → Game Dev → QA cycle until all game feature stories complete + +**Important**: Only 1 game story in progress at a time, worked sequentially until all game feature stories complete. + +### Game Story Status Tracking Workflow + +Game stories progress through defined statuses: + +- **Draft** → **Approved** → **InProgress** → **Done** + +Each status change requires user verification and approval before proceeding. + +### Game Development Workflow Types + +#### Greenfield Game Development + +- Game concept brainstorming and mechanics design +- Game design requirements and feature definition +- Godot system architecture and technical design +- Game development execution +- Game testing, performance optimization, and deployment + +#### Brownfield Game Enhancement (Existing Godot Projects) + +**Key Concept**: Brownfield game development requires comprehensive documentation of your existing Godot project for AI agents to understand game mechanics, Godot patterns, and technical constraints. + +**Brownfield Game Enhancement Workflow**: + +Since this expansion pack doesn't include specific brownfield templates, you'll adapt the existing templates: + +1. **Upload Godot project to Web UI** (GitHub URL, files, or zip) +2. **Create adapted Game Design Document**: `/bmad2dg/game-designer` - Modify `game-design-doc-tmpl` to include: + - Analysis of existing game systems + - Integration points for new features + - Compatibility requirements + - Risk assessment for changes + +3. **Game Architecture Planning**: + - Use `/bmad2dg/game-architect` with `game-architecture-tmpl` + - Focus on how new features integrate with existing Godot systems + - Plan for gradual rollout and testing + +4. **Story Creation for Enhancements**: + - Use `/bmad2dg/game-sm` with `*create-game-story` + - Stories should explicitly reference existing code to modify + - Include integration testing requirements + +**When to Use Each Game Development Approach**: + +**Full Game Enhancement Workflow** (Recommended for): + +- Major game feature additions +- Game system modernization +- Complex Godot integrations +- Multiple related gameplay changes + +**Quick Story Creation** (Use when): + +- Single, focused game enhancement +- Isolated gameplay fixes +- Small feature additions +- Well-documented existing Godot game + +**Critical Success Factors for Game Development**: + +1. **Game Documentation First**: Always document existing code thoroughly before making changes +2. **Godot Context Matters**: Provide agents access to relevant Godot scripts and game systems +3. **Gameplay Integration Focus**: Emphasize compatibility and non-breaking changes to game mechanics +4. **Incremental Approach**: Plan for gradual rollout and extensive game testing + +## Document Creation Best Practices for Game Development + +### Required File Naming for Game Framework Integration + +- `docs/game-design-doc.md` - Game Design Document +- `docs/game-architecture.md` - Godot System Architecture Document + +**Why These Names Matter for Game Development**: + +- Game agents automatically reference these files during Godot development +- Game sharding tasks expect these specific filenames +- Game workflow automation depends on standard naming + +### Cost-Effective Game Document Creation Workflow + +**Recommended for Large Game Documents (Game Design Document, Game Architecture):** + +1. **Use Web UI**: Create game documents in web interface for cost efficiency +2. **Copy Final Output**: Save complete markdown to your Godot project +3. **Standard Names**: Save as `docs/game-design-doc.md` and `docs/game-architecture.md` +4. **Switch to Godot IDE**: Use IDE agents for Godot development and smaller game documents + +### Game Document Sharding + +Game templates with Level 2 headings (`##`) can be automatically sharded: + +**Original Game Design Document**: + +```markdown +## Core Gameplay Mechanics + +## Player Progression System + +## Level Design Framework + +## Technical Requirements +``` + +**After Sharding**: + +- `docs/game-design/core-gameplay-mechanics.md` +- `docs/game-design/player-progression-system.md` +- `docs/game-design/level-design-framework.md` +- `docs/game-design/technical-requirements.md` + +Use the `shard-doc` task or `@kayvan/markdown-tree-parser` tool for automatic game document sharding. + +## Game Agent System + +### Core Game Development Team + +| Agent | Role | Primary Functions | When to Use | +| ---------------- | ----------------- | ------------------------------------------- | ------------------------------------------- | +| `game-designer` | Game Designer | Game mechanics, creative design, GDD | Game concept, mechanics, creative direction | +| `game-developer` | Godot Developer | GDScript/C# implementation, Godot optimization | All Godot development tasks | +| `game-sm` | Game Scrum Master | Game story creation, sprint planning | Game project management, workflow | +| `game-architect` | Game Architect | Godot system design, technical architecture | Complex Godot systems, performance planning | + +**Note**: For QA and other roles, use the core BMad agents (e.g., `@qa` from bmad-core). + +### Game Agent Interaction Commands + +#### IDE-Specific Syntax for Game Development + +**Game Agent Loading by IDE**: + +- **Claude Code**: `/bmad2dg/game-designer`, `/bmad2dg/game-developer`, `/bmad2dg/game-sm`, `/bmad2dg/game-architect` +- **Cursor**: `@bmad2dg/game-designer`, `@bmad2dg/game-developer`, `@bmad2dg/game-sm`, `@bmad2dg/game-architect` +- **Windsurf**: `/bmad2dg/game-designer`, `/bmad2dg/game-developer`, `/bmad2dg/game-sm`, `/bmad2dg/game-architect` +- **Trae**: `@bmad2dg/game-designer`, `@bmad2dg/game-developer`, `@bmad2dg/game-sm`, `@bmad2dg/game-architect` +- **Roo Code**: Select mode from mode selector with bmad2dg prefix +- **GitHub Copilot**: Open the Chat view (`⌃⌘I` on Mac, `Ctrl+Alt+I` on Windows/Linux) and select the appropriate game agent. + +**Common Game Development Task Commands**: + +- `*help` - Show available game development commands +- `*status` - Show current game development context/progress +- `*exit` - Exit the game agent mode +- `*game-design-brainstorming` - Brainstorm game concepts and mechanics (Game Designer) +- `*draft` - Create next game development story (Game SM agent) +- `*validate-game-story` - Validate a game story implementation (with core QA agent) +- `*correct-course-game` - Course correction for game development issues +- `*advanced-elicitation` - Deep dive into game requirements + +**In Web UI (after building with godot-2d-game-team)**: + +```text +/bmad2dg/game-designer - Access game designer agent +/bmad2dg/game-architect - Access game architect agent +/bmad2dg/game-developer - Access game developer agent +/bmad2dg/game-sm - Access game scrum master agent +/help - Show available game development commands +/switch agent-name - Change active agent (if orchestrator available) +``` + +## Game-Specific Development Guidelines + +### Godot + GDScript/C# Standards + +**Project Structure:** + +```text +GodotProject/ +├── Assets/ +│ └── _Project +│ ├── Scenes/ # Game scenes (Boot, Menu, Game, etc.) +│ ├── Scripts/ # GDScript/C# scripts +│ │ ├── Editor/ # Editor-specific scripts +│ │ └── Runtime/ # Runtime scripts +│ ├── Scenes/ # Reusable game objects +│ ├── Art/ # Art assets (sprites, models, etc.) +│ ├── Audio/ # Audio assets +│ ├── Data/ # Resources and other data +│ └── Tests/ # Godot Test Framework tests +│ ├── EditMode/ +│ └── PlayMode/ +├── Packages/ # Package Manager manifest +└── ProjectSettings/ # Godot project settings +``` + +**Performance Requirements:** + +- Maintain stable frame rate on target devices +- Memory usage under specified limits per level +- Loading times under 3 seconds for levels +- Smooth animation and responsive controls + +**Code Quality:** + +- GDScript/C# best practices compliance +- Node-based architecture (SOLID principles) +- Efficient use of the Node lifecycle +- Error handling and graceful degradation + +### Game Development Story Structure + +**Story Requirements:** + +- Clear reference to Game Design Document section +- Specific acceptance criteria for game functionality +- Technical implementation details for Godot and GDScript/C# +- Performance requirements and optimization considerations +- Testing requirements including gameplay validation + +**Story Categories:** + +- **Core Mechanics**: Fundamental gameplay systems +- **Level Content**: Individual levels and content implementation +- **UI/UX**: User interface and player experience features +- **Performance**: Optimization and technical improvements +- **Polish**: Visual effects, audio, and game feel enhancements + +### Quality Assurance for Games + +**Testing Approach:** + +- Unit tests for GDScript/C# logic (EditMode tests) +- Integration tests for game systems (PlayMode tests) +- Performance benchmarking and profiling with Godot Profiler +- Gameplay testing and balance validation +- Cross-platform compatibility testing + +**Performance Monitoring:** + +- Frame rate consistency tracking +- Memory usage monitoring +- Asset loading performance +- Input responsiveness validation +- Battery usage optimization (mobile) + +## Usage Patterns and Best Practices for Game Development + +### Environment-Specific Usage for Games + +**Web UI Best For Game Development**: + +- Initial game design and creative brainstorming phases +- Cost-effective large game document creation +- Game agent consultation and mechanics refinement +- Multi-agent game workflows with orchestrator + +**Godot IDE Best For Game Development**: + +- Active Godot development and GDScript/C# implementation +- Godot asset operations and project integration +- Game story management and development cycles +- Godot testing, profiling, and debugging + +### Quality Assurance for Game Development + +- Use appropriate game agents for specialized tasks +- Follow Agile ceremonies and game review processes +- Use game-specific checklists: + - `game-architect-checklist` for architecture reviews + - `game-change-checklist` for change validation + - `game-design-checklist` for design reviews + - `game-story-dod-checklist` for story quality +- Regular validation with game templates + +### Performance Optimization for Game Development + +- Use specific game agents vs. `bmad-master` for focused Godot tasks +- Choose appropriate game team size for project needs +- Leverage game-specific technical preferences for consistency +- Regular context management and cache clearing for Godot workflows + +## Game Development Team Roles + +### Game Designer + +- **Primary Focus**: Game mechanics, player experience, design documentation +- **Key Outputs**: Game Brief, Game Design Document, Level Design Framework +- **Specialties**: Brainstorming, game balance, player psychology, creative direction + +### Game Developer + +- **Primary Focus**: Godot implementation, GDScript/C# excellence, performance optimization +- **Key Outputs**: Working game features, optimized Godot code, technical architecture +- **Specialties**: GDScript/C#/Godot, performance optimization, cross-platform development + +### Game Scrum Master + +- **Primary Focus**: Game story creation, development planning, agile process +- **Key Outputs**: Detailed implementation stories, sprint planning, quality assurance +- **Specialties**: Story breakdown, developer handoffs, process optimization + +## Platform-Specific Considerations + +### Cross-Platform Development + +- Abstract input using the new Input System +- Use platform-dependent compilation for specific logic +- Test on all target platforms regularly +- Optimize for different screen resolutions and aspect ratios + +### Mobile Optimization + +- Touch gesture support and responsive controls +- Battery usage optimization +- Performance scaling for different device capabilities +- App store compliance and packaging + +### Performance Targets + +- **PC/Console**: 60+ FPS at target resolution +- **Mobile**: 60 FPS on mid-range devices, 30 FPS minimum on low-end +- **Loading**: Initial load under 5 seconds, scene transitions under 2 seconds +- **Memory**: Within platform-specific memory budgets + +## Success Metrics for Game Development + +### Technical Metrics + +- Frame rate consistency (>90% of time at target FPS) +- Memory usage within budgets +- Loading time targets met +- Zero critical bugs in core gameplay systems + +### Player Experience Metrics + +- Tutorial completion rate >80% +- Level completion rates appropriate for difficulty curve +- Average session length meets design targets +- Player retention and engagement metrics + +### Development Process Metrics + +- Story completion within estimated timeframes +- Code quality metrics (test coverage, code analysis) +- Documentation completeness and accuracy +- Team velocity and delivery consistency + +## Common Godot Development Patterns + +### Scene Management + +- Use a loading scene for asynchronous loading of game scenes +- Use additive scene loading for large levels or streaming +- Manage scenes with a dedicated SceneManager class + +### Game State Management + +- Use Resources to store shared game state +- Implement a finite state machine (FSM) for complex behaviors +- Use a GameManager singleton for global state management + +### Input Handling + +- Use the new Input System for robust, cross-platform input +- Create Action Maps for different input contexts (e.g., menu, gameplay) +- Use PlayerInput component for easy player input handling + +### Performance Optimization + +- Object pooling for frequently instantiated objects (e.g., bullets, enemies) +- Use the Godot Profiler to identify performance bottlenecks +- Optimize physics settings and collision detection +- Use LOD (Level of Detail) for complex models + +## Success Tips for Game Development + +- **Use Gemini for game design planning** - The team-game-dev bundle provides collaborative game expertise +- **Use bmad-master for game document organization** - Sharding creates manageable game feature chunks +- **Follow the Game SM → Game Dev cycle religiously** - This ensures systematic game progress +- **Keep conversations focused** - One game agent, one Godot task per conversation +- **Review everything** - Always review and approve before marking game features complete + +## Contributing to BMad-Method Game Development + +### Game Development Contribution Guidelines + +For full details, see `CONTRIBUTING.md`. Key points for game development: + +**Fork Workflow for Game Development**: + +1. Fork the repository +2. Create game development feature branches +3. Submit PRs to `next` branch (default) or `main` for critical game development fixes only +4. Keep PRs small: 200-400 lines ideal, 800 lines maximum +5. One game feature/fix per PR + +**Game Development PR Requirements**: + +- Clear descriptions (max 200 words) with What/Why/How/Testing for game features +- Use conventional commits (feat:, fix:, docs:) with game context +- Atomic commits - one logical game change per commit +- Must align with game development guiding principles + +**Game Development Core Principles**: + +- **Game Dev Agents Must Be Lean**: Minimize dependencies, save context for Godot code +- **Natural Language First**: Everything in markdown, no code in game development core +- **Core vs Game Expansion Packs**: Core for universal needs, game packs for Godot specialization +- **Game Design Philosophy**: "Game dev agents code Godot, game planning agents plan gameplay" + +## Game Development Expansion Pack System + +### This Game Development Expansion Pack + +This 2D Godot Game Development expansion pack extends BMad-Method beyond traditional software development into professional game development. It provides specialized game agent teams, Godot templates, and game workflows while keeping the core framework lean and focused on general development. + +### Why Use This Game Development Expansion Pack? + +1. **Keep Core Lean**: Game dev agents maintain maximum context for Godot coding +2. **Game Domain Expertise**: Deep, specialized Godot and game development knowledge +3. **Commgodot Game Innovation**: Game developers can contribute and share Godot patterns +4. **Modular Game Design**: Install only game development capabilities you need + +### Using This Game Development Expansion Pack + +1. **Install via CLI**: + + ```bash + npx bmad-method install + # Select "Install game development expansion pack" option + ``` + +2. **Use in Your Game Workflow**: Installed game agents integrate seamlessly with existing BMad agents + +### Creating Custom Game Development Extensions + +Use the **expansion-creator** pack to build your own game development extensions: + +1. **Define Game Domain**: What game development expertise are you capturing? +2. **Design Game Agents**: Create specialized game roles with clear Godot boundaries +3. **Build Game Resources**: Tasks, templates, checklists for your game domain +4. **Test & Share**: Validate with real Godot use cases, share with game development commgodot + +**Key Principle**: Game development expansion packs democratize game development expertise by making specialized Godot and game design knowledge accessible through AI agents. + +## Getting Help with Game Development + +- **Commands**: Use `*/*help` in any environment to see available game development commands +- **Game Agent Switching**: Use `*/*switch game-agent-name` with orchestrator for role changes +- **Game Documentation**: Check `docs/` folder for Godot project-specific context +- **Game Commgodot**: Discord and GitHub resources available for game development support +- **Game Contributing**: See `CONTRIBUTING.md` for full game development guidelines + +This knowledge base provides the foundation for effective game development using the BMad-Method framework with specialized focus on 2D game creation using Godot and GDScript/C#. diff --git a/expansion-packs/bmad-2d-godot-game-dev/data/development-guidelines.md b/expansion-packs/bmad-2d-godot-game-dev/data/development-guidelines.md new file mode 100644 index 00000000..87b00947 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/data/development-guidelines.md @@ -0,0 +1,565 @@ +# Game Development Guidelines (Godot - GDScript & C#) + +## Overview + +This document establishes coding standards, architectural patterns, and development practices for 2D game development using Godot with GDScript and C#. These guidelines ensure consistency, performance, and maintainability across all game development stories. + +## Language Selection + +### When to Use GDScript +- Rapid prototyping and iteration +- Simple game logic and scripting +- Godot-specific features and integrations +- Smaller projects or game jam entries + +### When to Use C# +- Performance-critical systems +- Complex algorithms and data structures +- Large-scale projects requiring strong typing +- When team has existing C# expertise + +## GDScript Standards + +### Naming Conventions + +**Classes and Scripts:** +- PascalCase for class names: `class_name PlayerController` +- snake_case for script files: `player_controller.gd` +- One class per file, filename matches class name in snake_case + +**Functions and Variables:** +- snake_case for functions: `calculate_damage()`, `apply_force()` +- snake_case for variables: `player_health`, `movement_speed` +- UPPER_SNAKE_CASE for constants: `MAX_HEALTH`, `GRAVITY` +- Prefix private members with underscore: `_internal_state`, `_process_input()` + +**Signals:** +- snake_case for signal names: `signal health_changed(new_health)` +- Past tense for completed events: `signal item_collected` +- Present/continuous for states: `signal is_falling` + +### Code Style + +```gdscript +extends CharacterBody2D +class_name Player + +# Constants +const MAX_SPEED: float = 300.0 +const JUMP_VELOCITY: float = -400.0 + +# Exported variables (shown in Inspector) +@export var health: int = 100 +@export var acceleration: float = 10.0 + +# Private variables +var _current_state: String = "idle" +var _velocity: Vector2 = Vector2.ZERO + +# Signals +signal health_changed(new_health: int) +signal player_died() + +func _ready() -> void: + # Initialize on scene ready + _setup_player() + +func _physics_process(delta: float) -> void: + # Handle physics updates + _handle_movement(delta) + move_and_slide() + +func take_damage(amount: int) -> void: + health -= amount + health_changed.emit(health) + if health <= 0: + _die() + +func _die() -> void: + player_died.emit() + queue_free() + +func _handle_movement(delta: float) -> void: + # Movement logic here + pass +``` + +## C# Standards (Godot C#) + +### Naming Conventions + +**Classes and Files:** +- PascalCase for classes: `PlayerController` +- PascalCase for C# files: `PlayerController.cs` +- Inherit from appropriate Godot class + +**Properties and Methods:** +- PascalCase for public members: `Health`, `TakeDamage()` +- camelCase with underscore for private fields: `_currentHealth` +- PascalCase for properties: `public int MaxHealth { get; set; }` + +### Code Style + +```csharp +using Godot; + +public partial class Player : CharacterBody2D +{ + // Constants + private const float MaxSpeed = 300.0f; + private const float JumpVelocity = -400.0f; + + // Exported properties (shown in Inspector) + [Export] public int Health { get; set; } = 100; + [Export] public float Acceleration { get; set; } = 10.0f; + + // Signals + [Signal] + public delegate void HealthChangedEventHandler(int newHealth); + + [Signal] + public delegate void PlayerDiedEventHandler(); + + // Private fields + private string _currentState = "idle"; + + public override void _Ready() + { + // Initialize on scene ready + SetupPlayer(); + } + + public override void _PhysicsProcess(double delta) + { + // Handle physics updates + HandleMovement((float)delta); + MoveAndSlide(); + } + + public void TakeDamage(int amount) + { + Health -= amount; + EmitSignal(SignalName.HealthChanged, Health); + + if (Health <= 0) + { + Die(); + } + } + + private void Die() + { + EmitSignal(SignalName.PlayerDied); + QueueFree(); + } +} +``` + +## Godot Node Architecture + +### Scene Organization + +``` +Main (Node2D) +├── World (Node2D) +│ ├── TileMap +│ ├── Platforms (Node2D) +│ └── Props (Node2D) +├── Entities (Node2D) +│ ├── Player (CharacterBody2D) +│ │ ├── Sprite2D +│ │ ├── CollisionShape2D +│ │ └── AnimationPlayer +│ └── Enemies (Node2D) +│ └── Enemy (CharacterBody2D) +├── UI (CanvasLayer) +│ ├── HUD (Control) +│ └── PauseMenu (Control) +└── Systems (Node) + ├── GameManager (Node) + └── AudioManager (Node) +``` + +### Node Lifecycle + +```gdscript +# GDScript Node Lifecycle +func _enter_tree() -> void: + # Called when node enters the scene tree + pass + +func _ready() -> void: + # Called once when node is ready + # All children are ready at this point + pass + +func _process(delta: float) -> void: + # Called every frame + # Use for non-physics updates + pass + +func _physics_process(delta: float) -> void: + # Called at fixed intervals + # Use for physics-related updates + pass + +func _exit_tree() -> void: + # Called when node leaves the scene tree + pass +``` + +## Resource System + +### Custom Resources + +```gdscript +# enemy_data.gd +extends Resource +class_name EnemyData + +@export var enemy_name: String = "Goblin" +@export var max_health: int = 50 +@export var move_speed: float = 150.0 +@export var damage: int = 10 +@export var sprite: Texture2D +``` + +### Using Resources + +```gdscript +extends CharacterBody2D +class_name Enemy + +@export var enemy_data: EnemyData + +var current_health: int + +func _ready() -> void: + if enemy_data: + current_health = enemy_data.max_health + $Sprite2D.texture = enemy_data.sprite +``` + +## Signal System + +### Signal Patterns + +```gdscript +# Defining and emitting signals +extends Node +class_name GameManager + +signal game_started() +signal game_over(score: int) +signal level_completed(level_number: int, time: float) + +func start_game() -> void: + # Game start logic + game_started.emit() + +func end_game(final_score: int) -> void: + # Game end logic + game_over.emit(final_score) +``` + +### Connecting Signals + +```gdscript +# Connecting signals in code +func _ready() -> void: + # Connect with callable + game_manager.game_started.connect(_on_game_started) + + # Connect with binds + button.pressed.connect(_on_button_pressed.bind(button_id)) + + # One-shot connection + timer.timeout.connect(_on_timer_timeout, CONNECT_ONE_SHOT) + +func _on_game_started() -> void: + print("Game started!") +``` + +## Autoload (Singleton) Pattern + +```gdscript +# GameManager.gd - Add to Project Settings > Autoload +extends Node + +var score: int = 0 +var current_level: int = 1 + +func _ready() -> void: + # Singleton is ready + process_mode = Node.PROCESS_MODE_ALWAYS # Continue during pause + +func add_score(points: int) -> void: + score += points + +func reset_game() -> void: + score = 0 + current_level = 1 + get_tree().change_scene_to_file("res://scenes/MainMenu.tscn") +``` + +## Performance Optimization + +### Object Pooling + +```gdscript +# ObjectPool.gd +extends Node +class_name ObjectPool + +@export var bullet_scene: PackedScene +@export var pool_size: int = 20 + +var _bullet_pool: Array[Node] = [] + +func _ready() -> void: + for i in pool_size: + var bullet = bullet_scene.instantiate() + bullet.set_process(false) + bullet.set_physics_process(false) + bullet.visible = false + add_child(bullet) + _bullet_pool.append(bullet) + +func get_bullet() -> Node: + for bullet in _bullet_pool: + if not bullet.visible: + bullet.set_process(true) + bullet.set_physics_process(true) + bullet.visible = true + return bullet + + # Pool exhausted, create new instance + var new_bullet = bullet_scene.instantiate() + add_child(new_bullet) + _bullet_pool.append(new_bullet) + return new_bullet + +func return_bullet(bullet: Node) -> void: + bullet.set_process(false) + bullet.set_physics_process(false) + bullet.visible = false +``` + +### Performance Best Practices + +- Cache node references in `_ready()` instead of using `get_node()` repeatedly +- Use `set_physics_process(false)` and `set_process(false)` for inactive objects +- Implement LOD (Level of Detail) for complex scenes +- Use `VisibleOnScreenNotifier2D` to disable off-screen processing +- Batch draw calls by using texture atlases +- Minimize use of `get_node()` in loops + +## Input Handling + +### Input Map Configuration + +```gdscript +# Configure actions in Project Settings > Input Map +# Then use in code: + +func _ready() -> void: + # Set up input actions in Project Settings + pass + +func _process(_delta: float) -> void: + if Input.is_action_just_pressed("jump"): + _jump() + + if Input.is_action_pressed("move_left"): + velocity.x = -SPEED + elif Input.is_action_pressed("move_right"): + velocity.x = SPEED + else: + velocity.x = 0 + +func _input(event: InputEvent) -> void: + # For one-time inputs + if event.is_action_pressed("pause"): + get_tree().paused = not get_tree().paused +``` + +## Error Handling + +### GDScript Error Handling + +```gdscript +func load_save_data() -> Dictionary: + var save_file = FileAccess.open("user://savegame.dat", FileAccess.READ) + + if save_file == null: + push_error("Failed to open save file") + return {} + + var save_data = save_file.get_var() + save_file.close() + + if save_data == null: + push_warning("Save file is empty") + return {} + + return save_data + +func safe_divide(a: float, b: float) -> float: + assert(b != 0, "Division by zero!") + return a / b +``` + +## Testing + +### GUT (Godot Unit Test) Framework + +```gdscript +# test_player.gd +extends GutTest + +var player: Player + +func before_each(): + player = preload("res://entities/Player.tscn").instantiate() + add_child_autofree(player) + +func test_player_takes_damage(): + var initial_health = player.health + player.take_damage(20) + assert_eq(player.health, initial_health - 20) + +func test_player_dies_at_zero_health(): + player.health = 10 + watch_signals(player) + player.take_damage(10) + assert_signal_emitted(player, "player_died") +``` + +### GoDotTest (C# Testing) + +```csharp +using GoDotTest; + +[TestClass] +public class PlayerTests : TestClass +{ + private Player _player; + + [TestInitialize] + public void Setup() + { + _player = new Player(); + AddChild(_player); + } + + [TestMethod] + public void PlayerTakesDamage() + { + int initialHealth = _player.Health; + _player.TakeDamage(20); + AssertEqual(_player.Health, initialHealth - 20); + } +} +``` + +## Project Structure + +``` +res:// +├── scenes/ +│ ├── main.tscn +│ ├── levels/ +│ │ ├── level_01.tscn +│ │ └── level_02.tscn +│ └── ui/ +│ ├── main_menu.tscn +│ └── hud.tscn +├── scripts/ +│ ├── player/ +│ │ ├── player.gd +│ │ └── player_controller.gd +│ ├── enemies/ +│ │ └── enemy_base.gd +│ └── systems/ +│ ├── game_manager.gd +│ └── save_system.gd +├── resources/ +│ ├── enemy_data/ +│ │ ├── goblin.tres +│ │ └── skeleton.tres +│ └── item_data/ +├── assets/ +│ ├── sprites/ +│ ├── audio/ +│ │ ├── music/ +│ │ └── sfx/ +│ └── fonts/ +└── tests/ + ├── unit/ + └── integration/ +``` + +## Development Workflow + +### Story Implementation Process + +1. **Understand Requirements:** + - Review story acceptance criteria + - Identify Godot-specific implementation needs + - Plan scene structure and node hierarchy + +2. **Implementation:** + - Create scenes and scripts following naming conventions + - Use appropriate node types (CharacterBody2D for players/enemies, Area2D for triggers) + - Implement in GDScript for rapid iteration, C# for performance-critical code + +3. **Testing:** + - Write GUT tests for GDScript + - Write GoDotTest tests for C# + - Test on all target platforms + +4. **Optimization:** + - Profile using Godot's built-in profiler + - Optimize draw calls and physics processing + - Implement object pooling where needed + +5. **Documentation:** + - Document complex systems with comments + - Update story completion status + - Note any performance considerations + +## Performance Targets + +### Frame Rate +- **Desktop**: 60 FPS stable +- **Mobile**: 60 FPS on modern devices, 30 FPS minimum on older devices +- **Web**: 60 FPS in modern browsers + +### Memory Usage +- Keep texture memory under control using import settings +- Monitor scene complexity (node count) +- Use ResourceLoader for dynamic loading + +### Build Size +- Optimize texture compression +- Remove unused assets +- Use Godot's export templates appropriately + +## Platform-Specific Considerations + +### Mobile +- Touch input handling with `InputEventScreenTouch` +- Screen size adaptation using anchors and containers +- Performance scaling for different devices + +### Web +- Consider download size (use .wasm.gz compression) +- Handle browser-specific limitations +- Test in multiple browsers + +### Desktop +- Multiple resolution support +- Windowed/fullscreen toggling +- Save data in user directory + +These guidelines ensure consistent, high-quality game development using Godot's features and best practices while maintaining performance across all target platforms. \ No newline at end of file diff --git a/expansion-packs/bmad-2d-godot-game-dev/tasks/advanced-elicitation.md b/expansion-packs/bmad-2d-godot-game-dev/tasks/advanced-elicitation.md new file mode 100644 index 00000000..6d5660c3 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/tasks/advanced-elicitation.md @@ -0,0 +1,110 @@ +# Advanced Game Design Elicitation Task + +## Purpose + +- Provide optional reflective and brainstorming actions to enhance game design content quality +- Enable deeper exploration of game mechanics and player experience through structured elicitation techniques +- Support iterative refinement through multiple game development perspectives +- Apply game-specific critical thinking to design decisions + +## Task Instructions + +### 1. Game Design Context and Review + +[[LLM: When invoked after outputting a game design section: + +1. First, provide a brief 1-2 sentence summary of what the user should look for in the section just presented, with game-specific focus (e.g., "Please review the core mechanics for player engagement and implementation feasibility. Pay special attention to how these mechanics create the intended player experience and whether they're technically achievable with Godot.") + +2. If the section contains game flow diagrams, level layouts, or system diagrams, explain each diagram briefly with game development context before offering elicitation options (e.g., "The gameplay loop diagram shows how player actions lead to rewards and progression. Notice how each step maintains player engagement and creates opportunities for skill development.") + +3. If the section contains multiple game elements (like multiple mechanics, multiple levels, multiple systems, etc.), inform the user they can apply elicitation actions to: + - The entire section as a whole + - Individual game elements within the section (specify which element when selecting an action) + +4. Then present the action list as specified below.]] + +### 2. Ask for Review and Present Game Design Action List + +[[LLM: Ask the user to review the drafted game design section. In the SAME message, inform them that they can suggest additions, removals, or modifications, OR they can select an action by number from the 'Advanced Game Design Elicitation & Brainstorming Actions'. If there are multiple game elements in the section, mention they can specify which element(s) to apply the action to. Then, present ONLY the numbered list (0-9) of these actions. Conclude by stating that selecting 9 will proceed to the next section. Await user selection. If an elicitation action (0-8) is chosen, execute it and then re-offer this combined review/elicitation choice. If option 9 is chosen, or if the user provides direct feedback, proceed accordingly.]] + +**Present the numbered list (0-9) with this exact format:** + +```text +**Advanced Game Design Elicitation & Brainstorming Actions** +Choose an action (0-9 - 9 to bypass - HELP for explanation of these options): + +0. Expand or Contract for Target Audience +1. Explain Game Design Reasoning (Step-by-Step) +2. Critique and Refine from Player Perspective +3. Analyze Game Flow and Mechanic Dependencies +4. Assess Alignment with Player Experience Goals +5. Identify Potential Player Confusion and Design Risks +6. Challenge from Critical Game Design Perspective +7. Explore Alternative Game Design Approaches +8. Hindsight Postmortem: The 'If Only...' Game Design Reflection +9. Proceed / No Further Actions +``` + +### 2. Processing Guidelines + +**Do NOT show:** + +- The full protocol text with `[[LLM: ...]]` instructions +- Detailed explanations of each option unless executing or the user asks, when giving the definition you can modify to tie its game development relevance +- Any internal template markup + +**After user selection from the list:** + +- Execute the chosen action according to the game design protocol instructions below +- Ask if they want to select another action or proceed with option 9 once complete +- Continue until user selects option 9 or indicates completion + +## Game Design Action Definitions + +0. Expand or Contract for Target Audience + [[LLM: Ask the user whether they want to 'expand' on the game design content (add more detail, elaborate on mechanics, include more examples) or 'contract' it (simplify mechanics, focus on core features, reduce complexity). Also, ask if there's a specific player demographic or experience level they have in mind (casual players, hardcore gamers, children, etc.). Once clarified, perform the expansion or contraction from your current game design role's perspective, tailored to the specified player audience if provided.]] + +1. Explain Game Design Reasoning (Step-by-Step) + [[LLM: Explain the step-by-step game design thinking process that you used to arrive at the current proposal for this game content. Focus on player psychology, engagement mechanics, technical feasibility, and how design decisions support the overall player experience goals.]] + +2. Critique and Refine from Player Perspective + [[LLM: From your current game design role's perspective, review your last output or the current section for potential player confusion, engagement issues, balance problems, or areas for improvement. Consider how players will actually interact with and experience these systems, then suggest a refined version that better serves player enjoyment and understanding.]] + +3. Analyze Game Flow and Mechanic Dependencies + [[LLM: From your game design role's standpoint, examine the content's structure for logical gameplay progression, mechanic interdependencies, and player learning curve. Confirm if game elements are introduced in an effective order that teaches players naturally and maintains engagement throughout the experience.]] + +4. Assess Alignment with Player Experience Goals + [[LLM: Evaluate how well the current game design content contributes to the stated player experience goals and core game pillars. Consider whether the mechanics actually create the intended emotions and engagement patterns. Identify any misalignments between design intentions and likely player reactions.]] + +5. Identify Potential Player Confusion and Design Risks + [[LLM: Based on your game design expertise, brainstorm potential sources of player confusion, overlooked edge cases in gameplay, balance issues, technical implementation risks, or unintended player behaviors that could emerge from the current design. Consider both new and experienced players' perspectives.]] + +6. Challenge from Critical Game Design Perspective + [[LLM: Adopt a critical game design perspective on the current content. If the user specifies another viewpoint (e.g., 'as a casual player', 'as a speedrunner', 'as a mobile player', 'as a technical implementer'), critique the content from that specified perspective. If no other role is specified, play devil's advocate from your game design expertise, arguing against the current design proposal and highlighting potential weaknesses, player experience issues, or implementation challenges. This can include questioning scope creep, unnecessary complexity, or features that don't serve the core player experience.]] + +7. Explore Alternative Game Design Approaches + [[LLM: From your game design role's perspective, first broadly brainstorm a range of diverse approaches to achieving the same player experience goals or solving the same design challenge. Consider different genres, mechanics, interaction models, or technical approaches. Then, from this wider exploration, select and present 2-3 distinct alternative design approaches, detailing the pros, cons, player experience implications, and technical feasibility you foresee for each.]] + +8. Hindsight Postmortem: The 'If Only...' Game Design Reflection + [[LLM: In your current game design persona, imagine this is a postmortem for a shipped game based on the current design content. What's the one 'if only we had designed/considered/tested X...' that your role would highlight from a game design perspective? Include the imagined player reactions, review scores, or development consequences. This should be both insightful and somewhat humorous, focusing on common game design pitfalls.]] + +9. Proceed / No Further Actions + [[LLM: Acknowledge the user's choice to finalize the current game design work, accept the AI's last output as is, or move on to the next step without selecting another action from this list. Prepare to proceed accordingly.]] + +## Game Development Context Integration + +This elicitation task is specifically designed for game development and should be used in contexts where: + +- **Game Mechanics Design**: When defining core gameplay systems and player interactions +- **Player Experience Planning**: When designing for specific emotional responses and engagement patterns +- **Technical Game Architecture**: When balancing design ambitions with implementation realities +- **Game Balance and Progression**: When designing difficulty curves and player advancement systems +- **Platform Considerations**: When adapting designs for different devices and input methods + +The questions and perspectives offered should always consider: + +- Player psychology and motivation +- Technical feasibility with Godot and GDScript/C# +- Performance implications for stable frame rate targets +- Cross-platform compatibility (PC, console, mobile) +- Game development best practices and common pitfalls diff --git a/expansion-packs/bmad-2d-godot-game-dev/tasks/correct-course-game.md b/expansion-packs/bmad-2d-godot-game-dev/tasks/correct-course-game.md new file mode 100644 index 00000000..aea885f6 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/tasks/correct-course-game.md @@ -0,0 +1,141 @@ +# Correct Course Task - Game Development + +## Purpose + +- Guide a structured response to game development change triggers using the `{root}/checklists/game-change-checklist`. +- Analyze the impacts of changes on game features, technical systems, and milestone deliverables. +- Explore game-specific solutions (e.g., performance optimizations, feature scaling, platform adjustments). +- Draft specific, actionable proposed updates to affected game artifacts (e.g., GDD sections, technical specs, Godot configurations). +- Produce a consolidated "Game Development Change Proposal" document for review and approval. +- Ensure clear handoff path for changes requiring fundamental redesign or technical architecture updates. + +## Instructions + +### 1. Initial Setup & Mode Selection + +- **Acknowledge Task & Inputs:** + - Confirm with the user that the "Game Development Correct Course Task" is being initiated. + - Verify the change trigger (e.g., performance issue, platform constraint, gameplay feedback, technical blocker). + - Confirm access to relevant game artifacts: + - Game Design Document (GDD) + - Technical Design Documents + - Godot Architecture specifications + - Performance budgets and platform requirements + - Current sprint's game stories and epics + - Asset specifications and pipelines + - Confirm access to `{root}/checklists/game-change-checklist`. + +- **Establish Interaction Mode:** + - Ask the user their preferred interaction mode: + - **"Incrementally (Default & Recommended):** Work through the game-change-checklist section by section, discussing findings and drafting changes collaboratively. Best for complex technical or gameplay changes." + - **"YOLO Mode (Batch Processing):** Conduct batched analysis and present consolidated findings. Suitable for straightforward performance optimizations or minor adjustments." + - Confirm the selected mode and inform: "We will now use the game-change-checklist to analyze the change and draft proposed updates specific to our Godot game development context." + +### 2. Execute Game Development Checklist Analysis + +- Systematically work through the game-change-checklist sections: + 1. **Change Context & Game Impact** + 2. **Feature/System Impact Analysis** + 3. **Technical Artifact Conflict Resolution** + 4. **Performance & Platform Evaluation** + 5. **Path Forward Recommendation** + +- For each checklist section: + - Present game-specific prompts and considerations + - Analyze impacts on: + - Godot scenes and nodes + - Node dependencies + - Performance metrics (FPS, memory, build size) + - Platform-specific code paths + - Asset loading and management + - Third-party plugins/SDKs + - Discuss findings with clear technical context + - Record status: `[x] Addressed`, `[N/A]`, `[!] Further Action Needed` + - Document Godot-specific decisions and constraints + +### 3. Draft Game-Specific Proposed Changes + +Based on the analysis and agreed path forward: + +- **Identify affected game artifacts requiring updates:** + - GDD sections (mechanics, systems, progression) + - Technical specifications (architecture, performance targets) + - Godot-specific configurations (project settings, rendering settings) + - Game story modifications (scope, acceptance criteria) + - Asset pipeline adjustments + - Platform-specific adaptations + +- **Draft explicit changes for each artifact:** + - **Game Stories:** Revise story text, Godot-specific acceptance criteria, technical constraints + - **Technical Specs:** Update architecture diagrams, component hierarchies, performance budgets + - **Godot Configurations:** Propose settings changes, optimization strategies, platform variants + - **GDD Updates:** Modify feature descriptions, balance parameters, progression systems + - **Asset Specifications:** Adjust texture sizes, model complexity, audio compression + - **Performance Targets:** Update FPS goals, memory limits, load time requirements + +- **Include Godot-specific details:** + - Scene structure changes + - Scene organization updates + - Node refactoring needs + - Shader/material optimizations + - Build pipeline modifications + +### 4. Generate "Game Development Change Proposal" + +- Create a comprehensive proposal document containing: + + **A. Change Summary:** + - Original issue (performance, gameplay, technical constraint) + - Game systems affected + - Platform/performance implications + - Chosen solution approach + + **B. Technical Impact Analysis:** + - Godot architecture changes needed + - Performance implications (with metrics) + - Platform compatibility effects + - Asset pipeline modifications + - Third-party dependency impacts + + **C. Specific Proposed Edits:** + - For each game story: "Change Story GS-X.Y from: [old] To: [new]" + - For technical specs: "Update Godot Architecture Section X: [changes]" + - For GDD: "Modify [Feature] in Section Y: [updates]" + - For configurations: "Change [Setting] from [old_value] to [new_value]" + + **D. Implementation Considerations:** + - Required Godot version updates + - Asset reimport needs + - Shader recompilation requirements + - Platform-specific testing needs + +### 5. Finalize & Determine Next Steps + +- Obtain explicit approval for the "Game Development Change Proposal" +- Provide the finalized document to the user + +- **Based on change scope:** + - **Minor adjustments (can be handled in current sprint):** + - Confirm task completion + - Suggest handoff to game-dev agent for implementation + - Note any required playtesting validation + - **Major changes (require replanning):** + - Clearly state need for deeper technical review + - Recommend engaging Game Architect or Technical Lead + - Provide proposal as input for architecture revision + - Flag any milestone/deadline impacts + +## Output Deliverables + +- **Primary:** "Game Development Change Proposal" document containing: + - Game-specific change analysis + - Technical impact assessment with Godot context + - Platform and performance considerations + - Clearly drafted updates for all affected game artifacts + - Implementation guidance and constraints + +- **Secondary:** Annotated game-change-checklist showing: + - Technical decisions made + - Performance trade-offs considered + - Platform-specific accommodations + - Godot-specific implementation notes diff --git a/expansion-packs/bmad-2d-godot-game-dev/tasks/create-game-story.md b/expansion-packs/bmad-2d-godot-game-dev/tasks/create-game-story.md new file mode 100644 index 00000000..c4eb9b3d --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/tasks/create-game-story.md @@ -0,0 +1,184 @@ +# Create Game Story Task + +## Purpose + +To identify the next logical game story based on project progress and epic definitions, and then to prepare a comprehensive, self-contained, and actionable story file using the `Game Story Template`. This task ensures the story is enriched with all necessary technical context, Godot-specific requirements, and acceptance criteria, making it ready for efficient implementation by a Game Developer Agent with minimal need for additional research or finding its own context. + +## SEQUENTIAL Task Execution (Do not proceed until current Task is complete) + +### 0. Load Core Configuration and Check Workflow + +- Load `{root}/core-config.yaml` from the project root +- If the file does not exist, HALT and inform the user: "core-config.yaml not found. This file is required for story creation. You can either: 1) Copy core-config.yaml from GITHUB bmad-core/ and configure it for your game project OR 2) Run the BMad installer against your project to upgrade and add the file automatically. Please add and configure before proceeding." +- Extract key configurations: `devStoryLocation`, `gdd.*`, `gamearchitecture.*`, `workflow.*` + +### 1. Identify Next Story for Preparation + +#### 1.1 Locate Epic Files and Review Existing Stories + +- Based on `gddSharded` from config, locate epic files (sharded location/pattern or monolithic GDD sections) +- If `devStoryLocation` has story files, load the highest `{epicNum}.{storyNum}.story.md` file +- **If highest story exists:** + - Verify status is 'Done'. If not, alert user: "ALERT: Found incomplete story! File: {lastEpicNum}.{lastStoryNum}.story.md Status: [current status] You should fix this story first, but would you like to accept risk & override to create the next story in draft?" + - If proceeding, select next sequential story in the current epic + - If epic is complete, prompt user: "Epic {epicNum} Complete: All stories in Epic {epicNum} have been completed. Would you like to: 1) Begin Epic {epicNum + 1} with story 1 2) Select a specific story to work on 3) Cancel story creation" + - **CRITICAL**: NEVER automatically skip to another epic. User MUST explicitly instruct which story to create. +- **If no story files exist:** The next story is ALWAYS 1.1 (first story of first epic) +- Announce the identified story to the user: "Identified next story for preparation: {epicNum}.{storyNum} - {Story Title}" + +### 2. Gather Story Requirements and Previous Story Context + +- Extract story requirements from the identified epic file or GDD section +- If previous story exists, review Dev Agent Record sections for: + - Completion Notes and Debug Log References + - Implementation deviations and technical decisions + - Godot-specific challenges (scene issues, node management, performance) + - Asset pipeline decisions and optimizations +- Extract relevant insights that inform the current story's preparation + +### 3. Gather Architecture Context + +#### 3.1 Determine Architecture Reading Strategy + +- **If `gamearchitectureVersion: >= v3` and `gamearchitectureSharded: true`**: Read `{gamearchitectureShardedLocation}/index.md` then follow structured reading order below +- **Else**: Use monolithic `gamearchitectureFile` for similar sections + +#### 3.2 Read Architecture Documents Based on Story Type + +**For ALL Game Stories:** tech-stack.md, unity-project-structure.md, coding-standards.md, testing-resilience-architecture.md + +**For Gameplay/Mechanics Stories, additionally:** gameplay-systems-architecture.md, component-architecture-details.md, physics-config.md, input-system.md, state-machines.md, game-data-models.md + +**For UI/UX Stories, additionally:** ui-architecture.md, ui-components.md, ui-state-management.md, scene-management.md + +**For Backend/Services Stories, additionally:** game-data-models.md, data-persistence.md, save-system.md, analytics-integration.md, multiplayer-architecture.md + +**For Graphics/Rendering Stories, additionally:** rendering-pipeline.md, shader-guidelines.md, sprite-management.md, particle-systems.md + +**For Audio Stories, additionally:** audio-architecture.md, audio-mixing.md, sound-banks.md + +#### 3.3 Extract Story-Specific Technical Details + +Extract ONLY information directly relevant to implementing the current story. Do NOT invent new patterns, systems, or standards not in the source documents. + +Extract: + +- Specific Godot nodes and scripts the story will use +- Godot addons and their APIs (e.g., Dialogue Manager, Input Map) +- Package-specific configurations and setup requirements +- Scene structures and node organization requirements +- Input system bindings and configurations +- Physics settings and collision layers +- UI canvas and layout specifications +- Asset naming conventions and folder structures +- Performance budgets (target FPS, memory limits, draw calls) +- Platform-specific considerations (mobile vs desktop) +- Testing requirements specific to Godot features + +ALWAYS cite source documents: `[Source: gamearchitecture/{filename}.md#{section}]` + +### 4. Godot-Specific Technical Analysis + +#### 4.1 Package Dependencies Analysis + +- Identify Godot addons required for the story +- Document package versions from manifest.json +- Note any package-specific APIs or components being used +- List package configuration requirements (e.g., Input System settings, URP asset config) +- Identify any third-party Asset Store packages and their integration points + +#### 4.2 Scene and Node Planning + +- Identify which scenes will be modified or created +- List scene files that need to be created or updated +- Document scene inheritance requirements +- Specify scene loading/unloading requirements + +#### 4.3 Node Architecture + +- Define Node scripts needed +- Specify Resource assets required +- Document node dependencies and execution order +- Identify required Godot signals and methods +- Note any package-specific components (e.g., Cinemachine VirtualCamera, InputActionAsset) + +#### 4.4 Asset Requirements + +- List sprite/texture requirements with resolution specs +- Define animation clips and animator controllers needed +- Specify audio clips and their import settings +- Document any shader or material requirements +- Note any package-specific assets (e.g., URP materials, Input Action maps) + +### 5. Populate Story Template with Full Context + +- Create new story file: `{devStoryLocation}/{epicNum}.{storyNum}.story.md` using Game Story Template +- Fill in basic story information: Title, Status (Draft), Story statement, Acceptance Criteria from Epic/GDD +- **`Dev Notes` section (CRITICAL):** + - CRITICAL: This section MUST contain ONLY information extracted from gamearchitecture documents and GDD. NEVER invent or assume technical details. + - Include ALL relevant technical details from Steps 2-4, organized by category: + - **Previous Story Insights**: Key learnings from previous story implementation + - **Addon Dependencies**: Godot addons required, versions, configurations [with source references] + - **Godot Nodes**: Specific Node scripts, Resources, systems [with source references] + - **Scene & Node Specs**: Scene modifications, node structures, inheritance [with source references] + - **Input Configuration**: Input actions, bindings, control schemes [with source references] + - **UI Implementation**: Canvas setup, layout groups, UI events [with source references] + - **Asset Pipeline**: Asset requirements, import settings, optimization notes + - **Performance Targets**: FPS targets, memory budgets, profiler metrics + - **Platform Considerations**: Mobile vs desktop differences, input variations + - **Testing Requirements**: Runtime tests, Godot Test Framework specifics + - Every technical detail MUST include its source reference: `[Source: gamearchitecture/{filename}.md#{section}]` + - If information for a category is not found in the gamearchitecture docs, explicitly state: "No specific guidance found in gamearchitecture docs" +- **`Tasks / Subtasks` section:** + - Generate detailed, sequential list of technical tasks based ONLY on: Epic/GDD Requirements, Story AC, Reviewed GameArchitecture Information + - Include Godot-specific tasks: + - Scene setup and configuration + - Scene creation and testing + - Node implementation with proper lifecycle methods + - Input system integration + - Physics configuration + - UI implementation with proper anchoring + - Performance profiling checkpoints + - Each task must reference relevant gamearchitecture documentation + - Include PlayMode testing as explicit subtasks + - Link tasks to ACs where applicable (e.g., `Task 1 (AC: 1, 3)`) +- Add notes on Godot project structure alignment or discrepancies found in Step 4 + +### 6. Story Draft Completion and Review + +- Review all sections for completeness and accuracy +- Verify all source references are included for technical details +- Ensure Godot-specific requirements are comprehensive: + - All scenes and nodes documented + - Node dependencies clear + - Asset requirements specified + - Performance targets defined +- Update status to "Draft" and save the story file +- Execute `{root}/tasks/execute-checklist` `{root}/checklists/game-story-dod-checklist` +- Provide summary to user including: + - Story created: `{devStoryLocation}/{epicNum}.{storyNum}.story.md` + - Status: Draft + - Key Godot nodes and systems included + - Scene/node modifications required + - Asset requirements identified + - Any deviations or conflicts noted between GDD and gamearchitecture + - Checklist Results + - Next steps: For complex Godot features, suggest the user review the story draft and optionally test critical assumptions in Godot Editor + +### 7. Godot-Specific Validation + +Before finalizing, ensure: + +- [ ] All required Godot addons are documented with versions +- [ ] Addon-specific APIs and configurations are included +- [ ] All Node lifecycle methods are considered +- [ ] Scene workflows are clearly defined +- [ ] Scene management approach is specified +- [ ] Input system integration is complete (Input Map) +- [ ] UI setup follows Godot best practices +- [ ] Performance profiling points are identified +- [ ] Asset import settings are documented +- [ ] Platform-specific code paths are noted +- [ ] Engine compatibility is verified (e.g., Godot 4.x features) + +This task ensures game development stories are immediately actionable and enable efficient AI-driven development of Godot 2D game features. diff --git a/expansion-packs/bmad-2d-godot-game-dev/tasks/game-design-brainstorming.md b/expansion-packs/bmad-2d-godot-game-dev/tasks/game-design-brainstorming.md new file mode 100644 index 00000000..2bb5e06f --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/tasks/game-design-brainstorming.md @@ -0,0 +1,290 @@ +# Game Design Brainstorming Techniques Task + +This task provides a comprehensive toolkit of creative brainstorming techniques specifically designed for game design ideation and innovative thinking. The game designer can use these techniques to facilitate productive brainstorming sessions focused on game mechanics, player experience, and creative concepts. + +## Process + +### 1. Session Setup + +[[LLM: Begin by understanding the game design context and goals. Ask clarifying questions if needed to determine the best approach for game-specific ideation.]] + +1. **Establish Game Context** + - Understand the game genre or opportunity area + - Identify target audience and platform constraints + - Determine session goals (concept exploration vs. mechanic refinement) + - Clarify scope (full game vs. specific feature) + +2. **Select Technique Approach** + - Option A: User selects specific game design techniques + - Option B: Game Designer recommends techniques based on context + - Option C: Random technique selection for creative variety + - Option D: Progressive technique flow (broad concepts to specific mechanics) + +### 2. Game Design Brainstorming Techniques + +#### Game Concept Expansion Techniques + +1. **"What If" Game Scenarios** + [[LLM: Generate provocative what-if questions that challenge game design assumptions and expand thinking beyond current genre limitations.]] + - What if players could rewind time in any genre? + - What if the game world reacted to the player's real-world location? + - What if failure was more rewarding than success? + - What if players controlled the antagonist instead? + - What if the game played itself when no one was watching? + +2. **Cross-Genre Fusion** + [[LLM: Help user combine unexpected game genres and mechanics to create unique experiences.]] + - "How might [genre A] mechanics work in [genre B]?" + - Puzzle mechanics in action games + - Dating sim elements in strategy games + - Horror elements in racing games + - Educational content in roguelike structure + +3. **Player Motivation Reversal** + [[LLM: Flip traditional player motivations to reveal new gameplay possibilities.]] + - What if losing was the goal? + - What if cooperation was forced in competitive games? + - What if players had to help their enemies? + - What if progress meant giving up abilities? + +4. **Core Loop Deconstruction** + [[LLM: Break down successful games to fundamental mechanics and rebuild differently.]] + - What are the essential 3 actions in this game type? + - How could we make each action more interesting? + - What if we changed the order of these actions? + - What if players could skip or automate certain actions? + +#### Mechanic Innovation Frameworks + +1. **SCAMPER for Game Mechanics** + [[LLM: Guide through each SCAMPER prompt specifically for game design.]] + - **S** = Substitute: What mechanics can be substituted? (walking → flying → swimming) + - **C** = Combine: What systems can be merged? (inventory + character growth) + - **A** = Adapt: What mechanics from other media? (books, movies, sports) + - **M** = Modify/Magnify: What can be exaggerated? (super speed, massive scale) + - **P** = Put to other uses: What else could this mechanic do? (jumping → attacking) + - **E** = Eliminate: What can be removed? (UI, tutorials, fail states) + - **R** = Reverse/Rearrange: What sequence changes? (end-to-start, simultaneous) + +2. **Player Agency Spectrum** + [[LLM: Explore different levels of player control and agency across game systems.]] + - Full Control: Direct character movement, combat, building + - Indirect Control: Setting rules, giving commands, environmental changes + - Influence Only: Suggestions, preferences, emotional reactions + - No Control: Observation, interpretation, passive experience + +3. **Temporal Game Design** + [[LLM: Explore how time affects gameplay and player experience.]] + - Real-time vs. turn-based mechanics + - Time travel and manipulation + - Persistent vs. session-based progress + - Asynchronous multiplayer timing + - Seasonal and event-based content + +#### Player Experience Ideation + +1. **Emotion-First Design** + [[LLM: Start with target emotions and work backward to mechanics that create them.]] + - Target Emotion: Wonder → Mechanics: Discovery, mystery, scale + - Target Emotion: Triumph → Mechanics: Challenge, skill growth, recognition + - Target Emotion: Connection → Mechanics: Cooperation, shared goals, communication + - Target Emotion: Flow → Mechanics: Clear feedback, progressive difficulty + +2. **Player Archetype Brainstorming** + [[LLM: Design for different player types and motivations.]] + - Achievers: Progression, completion, mastery + - Explorers: Discovery, secrets, world-building + - Socializers: Interaction, cooperation, community + - Killers: Competition, dominance, conflict + - Creators: Building, customization, expression + +3. **Accessibility-First Innovation** + [[LLM: Generate ideas that make games more accessible while creating new gameplay.]] + - Visual impairment considerations leading to audio-focused mechanics + - Motor accessibility inspiring one-handed or simplified controls + - Cognitive accessibility driving clear feedback and pacing + - Economic accessibility creating free-to-play innovations + +#### Narrative and World Building + +1. **Environmental Storytelling** + [[LLM: Brainstorm ways the game world itself tells stories without explicit narrative.]] + - How does the environment show history? + - What do interactive objects reveal about characters? + - How can level design communicate mood? + - What stories do systems and mechanics tell? + +2. **Player-Generated Narrative** + [[LLM: Explore ways players create their own stories through gameplay.]] + - Emergent storytelling through player choices + - Procedural narrative generation + - Player-to-player story sharing + - Community-driven world events + +3. **Genre Expectation Subversion** + [[LLM: Identify and deliberately subvert player expectations within genres.]] + - Fantasy RPG where magic is mundane + - Horror game where monsters are friendly + - Racing game where going slow is optimal + - Puzzle game where there are multiple correct answers + +#### Technical Innovation Inspiration + +1. **Platform-Specific Design** + [[LLM: Generate ideas that leverage unique platform capabilities.]] + - Mobile: GPS, accelerometer, camera, always-connected + - Web: URLs, tabs, social sharing, real-time collaboration + - Console: Controllers, TV viewing, couch co-op + - VR/AR: Physical movement, spatial interaction, presence + +2. **Constraint-Based Creativity** + [[LLM: Use technical or design constraints as creative catalysts.]] + - One-button games + - Games without graphics + - Games that play in notification bars + - Games using only system sounds + - Games with intentionally bad graphics + +### 3. Game-Specific Technique Selection + +[[LLM: Help user select appropriate techniques based on their specific game design needs.]] + +**For Initial Game Concepts:** + +- What If Game Scenarios +- Cross-Genre Fusion +- Emotion-First Design + +**For Stuck/Blocked Creativity:** + +- Player Motivation Reversal +- Constraint-Based Creativity +- Genre Expectation Subversion + +**For Mechanic Development:** + +- SCAMPER for Game Mechanics +- Core Loop Deconstruction +- Player Agency Spectrum + +**For Player Experience:** + +- Player Archetype Brainstorming +- Emotion-First Design +- Accessibility-First Innovation + +**For World Building:** + +- Environmental Storytelling +- Player-Generated Narrative +- Platform-Specific Design + +### 4. Game Design Session Flow + +[[LLM: Guide the brainstorming session with appropriate pacing for game design exploration.]] + +1. **Inspiration Phase** (10-15 min) + - Reference existing games and mechanics + - Explore player experiences and emotions + - Gather visual and thematic inspiration + +2. **Divergent Exploration** (25-35 min) + - Generate many game concepts or mechanics + - Use expansion and fusion techniques + - Encourage wild and impossible ideas + +3. **Player-Centered Filtering** (15-20 min) + - Consider target audience reactions + - Evaluate emotional impact and engagement + - Group ideas by player experience goals + +4. **Feasibility and Synthesis** (15-20 min) + - Assess technical and design feasibility + - Combine complementary ideas + - Develop most promising concepts + +### 5. Game Design Output Format + +[[LLM: Present brainstorming results in a format useful for game development.]] + +**Session Summary:** + +- Techniques used and focus areas +- Total concepts/mechanics generated +- Key themes and patterns identified + +**Game Concept Categories:** + +1. **Core Game Ideas** - Complete game concepts ready for prototyping +2. **Mechanic Innovations** - Specific gameplay mechanics to explore +3. **Player Experience Goals** - Emotional and engagement targets +4. **Technical Experiments** - Platform or technology-focused concepts +5. **Long-term Vision** - Ambitious ideas for future development + +**Development Readiness:** + +**Prototype-Ready Ideas:** + +- Ideas that can be tested immediately +- Minimum viable implementations +- Quick validation approaches + +**Research-Required Ideas:** + +- Concepts needing technical investigation +- Player testing and market research needs +- Competitive analysis requirements + +**Future Innovation Pipeline:** + +- Ideas requiring significant development +- Technology-dependent concepts +- Market timing considerations + +**Next Steps:** + +- Which concepts to prototype first +- Recommended research areas +- Suggested playtesting approaches +- Documentation and GDD planning + +## Game Design Specific Considerations + +### Platform and Audience Awareness + +- Always consider target platform limitations and advantages +- Keep target audience preferences and expectations in mind +- Balance innovation with familiar game design patterns +- Consider monetization and business model implications + +### Rapid Prototyping Mindset + +- Focus on ideas that can be quickly tested +- Emphasize core mechanics over complex features +- Design for iteration and player feedback +- Consider digital and paper prototyping approaches + +### Player Psychology Integration + +- Understand motivation and engagement drivers +- Consider learning curves and skill development +- Design for different play session lengths +- Balance challenge and reward appropriately + +### Technical Feasibility + +- Keep development resources and timeline in mind +- Consider art and audio asset requirements +- Think about performance and optimization needs +- Plan for testing and debugging complexity + +## Important Notes for Game Design Sessions + +- Encourage "impossible" ideas - constraints can be added later +- Build on game mechanics that have proven engagement +- Consider how ideas scale from prototype to full game +- Document player experience goals alongside mechanics +- Think about community and social aspects of gameplay +- Consider accessibility and inclusivity from the start +- Balance innovation with market viability +- Plan for iteration based on player feedback diff --git a/expansion-packs/bmad-2d-godot-game-dev/tasks/validate-game-story.md b/expansion-packs/bmad-2d-godot-game-dev/tasks/validate-game-story.md new file mode 100644 index 00000000..ae0e65f9 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/tasks/validate-game-story.md @@ -0,0 +1,200 @@ +# Validate Game Story Task + +## Purpose + +To comprehensively validate a Godot 2D game development story draft before implementation begins, ensuring it contains all necessary Godot-specific technical context, game development requirements, and implementation details. This specialized validation prevents hallucinations, ensures Godot development readiness, and validates game-specific acceptance criteria and testing approaches. + +## SEQUENTIAL Task Execution (Do not proceed until current Task is complete) + +### 0. Load Core Configuration and Inputs + +- Load `{root}/core-config.yaml` from the project root +- If the file does not exist, HALT and inform the user: "core-config.yaml not found. This file is required for story validation." +- Extract key configurations: `devStoryLocation`, `gdd.*`, `gamearchitecture.*`, `workflow.*` +- Identify and load the following inputs: + - **Story file**: The drafted game story to validate (provided by user or discovered in `devStoryLocation`) + - **Parent epic**: The epic containing this story's requirements from GDD + - **Architecture documents**: Based on configuration (sharded or monolithic) + - **Game story template**: `expansion-packs/bmad-2d-godot-game-dev/templates/game-story-tmpl.yaml` for completeness validation + +### 1. Game Story Template Completeness Validation + +- Load `expansion-packs/bmad-2d-godot-game-dev/templates/game-story-tmpl.yaml` and extract all required sections +- **Missing sections check**: Compare story sections against game story template sections to verify all Godot-specific sections are present: + - Godot Technical Context + - Node Architecture + - Scene & Node Requirements + - Asset Dependencies + - Performance Requirements + - Platform Considerations + - Integration Points + - Testing Strategy (Godot Test Framework) +- **Placeholder validation**: Ensure no template placeholders remain unfilled (e.g., `{{EpicNum}}`, `{{StoryNum}}`, `{{GameMechanic}}`, `_TBD_`) +- **Game-specific sections**: Verify presence of Godot development specific sections +- **Structure compliance**: Verify story follows game story template structure and formatting + +### 2. Godot Project Structure and Asset Validation + +- **Godot file paths clarity**: Are Godot-specific paths clearly specified (scenes/, scripts/, resources/, etc.)? +- **Addon dependencies**: Are required Godot addons identified and version-locked? +- **Scene structure relevance**: Is relevant scene hierarchy and Node structure included? +- **Scene organization**: Are scene creation/modification requirements clearly specified? +- **Asset pipeline**: Are sprite imports, animation controllers, and audio assets properly planned? +- **Directory structure**: Do new Godot assets follow project structure according to architecture docs? +- **Resource requirements**: Are data containers and configuration objects identified? +- **Namespace compliance**: Are GDScript/C# namespaces following project conventions? + +### 3. Godot Node Architecture Validation + +- **Node specifications**: Are Godot node classes sufficiently detailed for implementation? +- **Node dependencies**: Are Godot node interdependencies clearly mapped? +- **Godot lifecycle usage**: Are _ready(), _process(), _enter_tree() methods appropriately planned? +- **Signal system integration**: Are Godot signals, C# events, or custom messaging systems specified? +- **Export requirements**: Are @export and public field requirements clear? +- **Node interfaces**: Are required interfaces and abstract base classes defined? +- **Performance considerations**: Are node update patterns optimized (_process vs _physics_process vs timers)? + +### 4. Game Mechanics and Systems Validation + +- **Core loop integration**: Does the story properly integrate with established game core loop? +- **Player input handling**: Are input mappings and input system requirements specified? +- **Game state management**: Are state transitions and persistence requirements clear? +- **UI/UX integration**: Are Canvas setup, UI components, and player feedback systems defined? +- **Audio integration**: Are AudioSource, AudioMixer, and sound effect requirements specified? +- **Animation systems**: Are Animator Controllers, Animation Clips, and transition requirements clear? +- **Physics integration**: Are RigidBody2D, Area2D, and physics material requirements specified? + +### 5. Godot-Specific Acceptance Criteria Assessment + +- **Functional testing**: Can all acceptance criteria be tested within Godot's debug mode? +- **Visual validation**: Are visual/aesthetic acceptance criteria measurable and testable? +- **Performance criteria**: Are frame rate, memory usage, and build size criteria specified? +- **Platform compatibility**: Are mobile vs desktop specific acceptance criteria addressed? +- **Input validation**: Are different input methods (touch, keyboard, gamepad) covered? +- **Audio criteria**: Are audio mixing levels, sound trigger timing, and audio quality specified? +- **Animation validation**: Are animation smoothness, timing, and visual polish criteria defined? + +### 6. Godot Testing and Validation Instructions Review + +- **Godot Test Framework**: Are editor and runtime test approaches clearly specified? +- **Performance profiling**: Are Godot Profiler usage and performance benchmarking steps defined? +- **Build testing**: Are build process validation steps for target platforms specified? +- **Scene testing**: Are scene loading, unloading, and transition testing approaches clear? +- **Asset validation**: Are texture compression, audio compression, and asset optimization tests defined? +- **Platform testing**: Are device-specific testing requirements (mobile performance, input methods) specified? +- **Memory leak testing**: Are Godot memory profiling and leak detection steps included? + +### 7. Godot Performance and Optimization Validation + +- **Frame rate targets**: Are target FPS requirements clearly specified for different platforms? +- **Memory budgets**: Are texture memory, audio memory, and runtime memory limits defined? +- **Draw call optimization**: Are batching strategies and draw call reduction approaches specified? +- **Mobile performance**: Are mobile-specific performance considerations (battery, thermal) addressed? +- **Asset optimization**: Are texture compression, audio compression, and mesh optimization requirements clear? +- **Garbage collection**: Are GC-friendly coding patterns and object pooling requirements specified? +- **Loading time targets**: Are scene loading and asset streaming performance requirements defined? + +### 8. Godot Security and Platform Considerations (if applicable) + +- **Platform store requirements**: Are app store guidelines and submission requirements addressed? +- **Data privacy**: Are player data storage and analytics integration requirements specified? +- **Platform integration**: Are platform-specific features (achievements, leaderboards) requirements clear? +- **Content filtering**: Are age rating and content appropriateness considerations addressed? +- **Anti-cheat considerations**: Are client-side validation and server communication security measures specified? +- **Build security**: Are code obfuscation and asset protection requirements defined? + +### 9. Godot Development Task Sequence Validation + +- **Godot workflow order**: Do tasks follow proper Godot development sequence (scenes before scripts, nodes before UI)? +- **Asset creation dependencies**: Are asset creation tasks properly ordered (sprites before animations, audio before mixers)? +- **Node dependencies**: Are script dependencies clear and implementation order logical? +- **Testing integration**: Are Godot test creation and execution properly sequenced with development tasks? +- **Build integration**: Are build process tasks appropriately placed in development sequence? +- **Platform deployment**: Are platform-specific build and deployment tasks properly sequenced? + +### 10. Godot Anti-Hallucination Verification + +- **Godot API accuracy**: Every Godot API reference must be verified against current Godot documentation +- **Addon version verification**: All Godot addon references must specify valid versions +- **Node architecture alignment**: Godot node relationships must match architecture specifications +- **Performance claims verification**: All performance targets must be realistic and based on platform capabilities +- **Asset pipeline accuracy**: All asset import settings and pipeline configurations must be valid +- **Platform capability verification**: All platform-specific features must be verified as available on target platforms + +### 11. Godot Development Agent Implementation Readiness + +- **Godot context completeness**: Can the story be implemented without consulting external Godot documentation? +- **Technical specification clarity**: Are all Godot-specific implementation details unambiguous? +- **Asset requirements clarity**: Are all required assets, their specifications, and import settings clearly defined? +- **Node relationship clarity**: Are all Godot node interactions and dependencies explicitly defined? +- **Testing approach completeness**: Are Godot-specific testing approaches fully specified and actionable? +- **Performance validation readiness**: Are all performance testing and optimization approaches clearly defined? + +### 12. Generate Godot Game Story Validation Report + +Provide a structured validation report including: + +#### Game Story Template Compliance Issues + +- Missing Godot-specific sections from game story template +- Unfilled placeholders or template variables specific to game development +- Missing Godot node specifications or asset requirements +- Structural formatting issues in game-specific sections + +#### Critical Godot Issues (Must Fix - Story Blocked) + +- Missing essential Godot technical information for implementation +- Inaccurate or unverifiable Godot API references or addon dependencies +- Incomplete game mechanics or systems integration +- Missing required Godot testing framework specifications +- Performance requirements that are unrealistic or unmeasurable + +#### Godot-Specific Should-Fix Issues (Important Quality Improvements) + +- Unclear Godot node architecture or dependency relationships +- Missing platform-specific performance considerations +- Incomplete asset pipeline specifications or optimization requirements +- Task sequencing problems specific to Godot development workflow +- Missing Godot Test Framework integration or testing approaches + +#### Game Development Nice-to-Have Improvements (Optional Enhancements) + +- Additional Godot performance optimization context +- Enhanced asset creation guidance and best practices +- Clarifications for Godot-specific development patterns +- Additional platform compatibility considerations +- Enhanced debugging and profiling guidance + +#### Godot Anti-Hallucination Findings + +- Unverifiable Godot API claims or outdated Godot references +- Missing Godot addon version specifications +- Inconsistencies with Godot project architecture documents +- Invented Godot nodes, addons, or development patterns +- Unrealistic performance claims or platform capability assumptions + +#### Godot Platform and Performance Validation + +- **Mobile Performance Assessment**: Frame rate targets, memory usage, and thermal considerations +- **Platform Compatibility Check**: Input methods, screen resolutions, and platform-specific features +- **Asset Pipeline Validation**: Texture compression, audio formats, and build size considerations +- **Godot Version Compliance**: Compatibility with specified Godot version and addon versions + +#### Final Godot Game Development Assessment + +- **GO**: Story is ready for Godot implementation with all technical context +- **NO-GO**: Story requires Godot-specific fixes before implementation +- **Godot Implementation Readiness Score**: 1-10 scale based on Godot technical completeness +- **Game Development Confidence Level**: High/Medium/Low for successful Godot implementation +- **Platform Deployment Readiness**: Assessment of multi-platform deployment preparedness +- **Performance Optimization Readiness**: Assessment of performance testing and optimization preparedness + +#### Recommended Next Steps + +Based on validation results, provide specific recommendations for: + +- Godot technical documentation improvements needed +- Asset creation or acquisition requirements +- Performance testing and profiling setup requirements +- Platform-specific development environment setup needs +- Godot Test Framework implementation recommendations diff --git a/expansion-packs/bmad-2d-godot-game-dev/templates/game-architecture-tmpl.yaml b/expansion-packs/bmad-2d-godot-game-dev/templates/game-architecture-tmpl.yaml new file mode 100644 index 00000000..45e16507 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/templates/game-architecture-tmpl.yaml @@ -0,0 +1,1027 @@ +template: + id: game-architecture-template-v3 + name: Game Architecture Document + version: 3.0 + output: + format: markdown + filename: docs/game-architecture.md + title: "{{project_name}} Game Architecture Document" + +workflow: + mode: interactive + elicitation: advanced-elicitation + +sections: + - id: introduction + title: Introduction + instruction: | + If available, review any provided relevant documents to gather all relevant context before beginning. At a minimum you should locate and review: Game Design Document (GDD), Technical Preferences. If these are not available, ask the user what docs will provide the basis for the game architecture. + sections: + - id: intro-content + content: | + This document outlines the complete technical architecture for {{project_name}}, a 2D game built with Godot using GDScript and/or C#. It serves as the technical foundation for AI-driven game development, ensuring consistency and scalability across all game systems. + + This architecture is designed to support the gameplay mechanics defined in the Game Design Document while maintaining stable performance and cross-platform compatibility. + - id: starter-template + title: Starter Template or Existing Project + instruction: | + Before proceeding further with game architecture design, check if the project is based on a Godot template or existing codebase: + + 1. Review the GDD and brainstorming brief for any mentions of: + - Godot project templates (2D, Mobile, etc.) + - Existing Godot projects being used as a foundation + - Asset Store packages or game development frameworks + - Previous game projects to be cloned or adapted + + 2. If a starter template or existing project is mentioned: + - Ask the user to provide access via one of these methods: + - Link to the Godot template documentation + - Upload/attach the project files (for small projects) + - Share a link to the project repository (GitHub, GitLab, etc.) + - Analyze the starter/existing project to understand: + - Pre-configured Godot version and renderer settings + - Project structure and organization patterns + - Built-in packages and dependencies + - Existing architectural patterns and conventions + - Any limitations or constraints imposed by the starter + - Use this analysis to inform and align your architecture decisions + + 3. If no starter template is mentioned but this is a greenfield project: + - Suggest appropriate Godot templates based on the target platform + - Explain the benefits (faster setup, best practices, package integration) + - Let the user decide whether to use one + + 4. If the user confirms no starter template will be used: + - Proceed with architecture design from scratch + - Note that manual setup will be required for all Godot configuration + + Document the decision here before proceeding with the architecture design. If none, just say N/A + elicit: true + - id: changelog + title: Change Log + type: table + columns: [Date, Version, Description, Author] + instruction: Track document versions and changes + + - id: high-level-architecture + title: High Level Architecture + instruction: | + This section contains multiple subsections that establish the foundation of the game architecture. Present all subsections together at once. + elicit: true + sections: + - id: technical-summary + title: Technical Summary + instruction: | + Provide a brief paragraph (3-5 sentences) overview of: + - The game's overall architecture style (node-based Godot architecture) + - Key game systems and their relationships + - Primary technology choices (Godot, GDScript/C#, target platforms) + - Core architectural patterns being used (Node components, Resources, Godot signals) + - Reference back to the GDD goals and how this architecture supports them + - id: high-level-overview + title: High Level Overview + instruction: | + Based on the GDD's Technical Assumptions section, describe: + + 1. The main architectural style (node-based Godot architecture with Node inheritance) + 2. Repository structure decision from GDD (single Godot project vs multiple projects) + 3. Game system architecture (modular systems, manager singletons, data-driven design) + 4. Primary player interaction flow and core game loop + 5. Key architectural decisions and their rationale (render pipeline, input system, physics) + - id: project-diagram + title: High Level Project Diagram + type: mermaid + mermaid_type: graph + instruction: | + Create a Mermaid diagram that visualizes the high-level game architecture. Consider: + - Core game systems (Input, Physics, Rendering, Audio, UI) + - Game managers and their responsibilities + - Data flow between systems + - External integrations (platform services, analytics) + - Player interaction points + + - id: architectural-patterns + title: Architectural and Design Patterns + instruction: | + List the key high-level patterns that will guide the game architecture. For each pattern: + + 1. Present 2-3 viable options if multiple exist + 2. Provide your recommendation with clear rationale + 3. Get user confirmation before finalizing + 4. These patterns should align with the GDD's technical assumptions and project goals + + Common Godot patterns to consider: + - Node patterns (Node inheritance, composition, Resource data) + - Game management patterns (Singleton managers, Event systems, State machines) + - Data patterns (Resource configuration, Save/Load systems) + - Godot-specific patterns (Object pooling, await/Timer, Godot signals) + template: "- **{{pattern_name}}:** {{pattern_description}} - _Rationale:_ {{rationale}}" + examples: + - "**Node-Based Architecture:** Using Node inheritance for game logic - _Rationale:_ Aligns with Godot's design philosophy and enables reusable, testable game systems" + - "**Resource Data:** Using Resources for game configuration - _Rationale:_ Enables data-driven design and easy balancing without code changes" + - "**Signal-Driven Communication:** Using Godot signals for system decoupling - _Rationale:_ Supports modular architecture and easier testing" + + - id: tech-stack + title: Tech Stack + instruction: | + This is the DEFINITIVE technology selection section for the Godot game. Work with the user to make specific choices: + + 1. Review GDD technical assumptions and any preferences from {root}/data/technical-preferences.yaml or an attached technical-preferences + 2. For each category, present 2-3 viable options with pros/cons + 3. Make a clear recommendation based on project needs + 4. Get explicit user approval for each selection + 5. Document exact versions (avoid "latest" - pin specific versions) + 6. This table is the single source of truth - all other docs must reference these choices + + Key decisions to finalize - before displaying the table, ensure you are aware of or ask the user about: + + - Godot version and renderer settings + - Target platforms and their specific requirements + - Godot Asset Library addons and versions + - Third-party assets or frameworks + - Platform SDKs and services + - Build and deployment tools + + Upon render of the table, ensure the user is aware of the importance of this sections choices, should also look for gaps or disagreements with anything, ask for any clarifications if something is unclear why its in the list, and also right away elicit feedback. + elicit: true + sections: + - id: platform-infrastructure + title: Platform Infrastructure + template: | + - **Target Platforms:** {{target_platforms}} + - **Primary Platform:** {{primary_platform}} + - **Platform Services:** {{platform_services_list}} + - **Distribution:** {{distribution_channels}} + - id: technology-stack-table + title: Technology Stack Table + type: table + columns: [Category, Technology, Version, Purpose, Rationale] + instruction: Populate the technology stack table with all relevant Godot technologies + examples: + - "| **Game Engine** | Godot | 4.2 LTS | Core game development platform | Latest LTS version, stable 2D tooling, comprehensive addon ecosystem |" + - "| **Language** | GDScript/C# | 2.0/.NET 6+ | Primary scripting languages | Godot's native language + C# support, strong typing available |" + - "| **Renderer** | Godot Renderer | Built-in | 2D/3D rendering | Optimized for both mobile and desktop, excellent 2D features |" + - "| **Input System** | Godot Input | Built-in | Cross-platform input handling | Built-in input system, supports multiple devices, rebindable controls |" + - "| **Physics** | Godot 2D Physics | Built-in | 2D collision and physics | Integrated physics engine, optimized for 2D games |" + - "| **Audio** | Godot Audio | Built-in | Audio playback and mixing | Built-in audio system with AudioBus mixer support |" + - "| **Testing** | GUT/GoDotTest | Addon | Unit and integration testing | Community testing frameworks for GDScript and C# |" + + - id: data-models + title: Game Data Models + instruction: | + Define the core game data models/entities using Godot's Resource system: + + 1. Review GDD requirements and identify key game entities + 2. For each model, explain its purpose and relationships + 3. Include key attributes and data types appropriate for Godot/GDScript/C# + 4. Show relationships between models using Resource references + 5. Discuss design decisions with user + + Create a clear conceptual model before moving to specific implementations. + elicit: true + repeatable: true + sections: + - id: model + title: "{{model_name}}" + template: | + **Purpose:** {{model_purpose}} + + **Key Attributes:** + - {{attribute_1}}: {{type_1}} - {{description_1}} + - {{attribute_2}}: {{type_2}} - {{description_2}} + + **Relationships:** + - {{relationship_1}} + - {{relationship_2}} + + **Resource Implementation:** + - Create as custom Resource class + - Store in `Assets/_Project/Data/{{ModelName}}/` + + - id: components + title: Game Systems & Components + instruction: | + Based on the architectural patterns, tech stack, and data models from above: + + 1. Identify major game systems and their responsibilities + 2. Consider Godot's node-based architecture with Node inheritance + 3. Define clear interfaces between systems using Godot signals + 4. For each system, specify: + - Primary responsibility and core functionality + - Key Node components and Resources + - Dependencies on other systems + - Godot-specific implementation details (lifecycle methods, await/Timer, etc.) + + 5. Create system diagrams where helpful using Godot terminology + elicit: true + sections: + - id: system-list + repeatable: true + title: "{{system_name}} System" + template: | + **Responsibility:** {{system_description}} + + **Key Components:** + - {{component_1}} (Node) + - {{component_2}} (Resource) + - {{component_3}} (Autoload/Controller) + + **Godot Implementation Details:** + - Lifecycle: {{lifecycle_methods}} + - Signals: {{godot_signals_used}} + - Dependencies: {{system_dependencies}} + + **Files to Create:** + - `res://scripts/{{SystemName}}/{{MainScript}}.gd` or `.cs` + - `res://scenes/{{SystemName}}/{{MainScene}}.tscn` + - id: component-diagrams + title: System Interaction Diagrams + type: mermaid + instruction: | + Create Mermaid diagrams to visualize game system relationships. Options: + - System architecture diagram for high-level view + - Component interaction diagram for detailed relationships + - Sequence diagrams for complex game loops (_process, _physics_process flows) + Choose the most appropriate for clarity and Godot-specific understanding + + - id: gameplay-systems + title: Gameplay Systems Architecture + instruction: | + Define the core gameplay systems that drive the player experience. Focus on game-specific logic and mechanics. + elicit: true + sections: + - id: gameplay-overview + title: Gameplay Systems Overview + template: | + **Core Game Loop:** {{core_game_loop_description}} + + **Player Actions:** {{primary_player_actions}} + + **Game State Flow:** {{game_state_transitions}} + - id: gameplay-components + title: Gameplay Component Architecture + template: | + **Player Controller Components:** + - {{player_controller_components}} + + **Game Logic Components:** + - {{game_logic_components}} + + **Interaction Systems:** + - {{interaction_system_components}} + + - id: component-architecture + title: Component Architecture Details + instruction: | + Define detailed Godot node architecture patterns and conventions for the game. + elicit: true + sections: + - id: monobehaviour-patterns + title: Node Patterns + template: | + **Component Composition:** {{component_composition_approach}} + + **Lifecycle Management:** {{lifecycle_management_patterns}} + + **Component Communication:** {{component_communication_methods}} + - id: scriptableobject-usage + title: Resource Architecture + template: | + **Data Architecture:** {{scriptableobject_data_patterns}} + + **Configuration Management:** {{config_scriptableobject_usage}} + + **Runtime Data:** {{runtime_scriptableobject_patterns}} + + - id: physics-config + title: Physics Configuration + instruction: | + Define Unity 2D physics setup and configuration for the game. + elicit: true + sections: + - id: physics-settings + title: Physics Settings + template: | + **Physics 2D Settings:** {{physics_2d_configuration}} + + **Collision Layers:** {{collision_layer_matrix}} + + **Physics Materials:** {{physics_materials_setup}} + - id: rigidbody-patterns + title: Rigidbody Patterns + template: | + **Player Physics:** {{player_rigidbody2d_setup}} + + **Object Physics:** {{object_physics_patterns}} + + **Performance Optimization:** {{physics_optimization_strategies}} + + - id: input-system + title: Input System Architecture + instruction: | + Define input handling using Godot's built-in Input system. + elicit: true + sections: + - id: input-actions + title: Input Actions Configuration + template: | + **Input Map Configuration:** {{input_map_structure}} + + **Action Definitions:** {{input_action_definitions}} + + **Device Handling:** {{input_device_handling}} + - id: input-handling + title: Input Handling Patterns + template: | + **Player Input:** {{player_input_handling}} + + **UI Input:** {{ui_input_handling_patterns}} + + **Input Validation:** {{input_validation_strategies}} + + - id: state-machines + title: State Machine Architecture + instruction: | + Define state machine patterns for game states, player states, and AI behavior. + elicit: true + sections: + - id: game-state-machine + title: Game State Machine + template: | + **Game States:** {{game_state_definitions}} + + **State Transitions:** {{game_state_transition_rules}} + + **State Management:** {{game_state_manager_implementation}} + - id: entity-state-machines + title: Entity State Machines + template: | + **Player States:** {{player_state_machine_design}} + + **AI Behavior States:** {{ai_state_machine_patterns}} + + **Object States:** {{object_state_management}} + + - id: ui-architecture + title: UI Architecture + instruction: | + Define Godot UI system architecture using Control nodes. + elicit: true + sections: + - id: ui-system-choice + title: UI System Selection + template: | + **UI Framework:** {{ui_framework_choice}} (Control nodes) + + **UI Scaling:** {{ui_scaling_strategy}} + + **Canvas Setup:** {{canvas_configuration}} + - id: ui-navigation + title: UI Navigation System + template: | + **Screen Management:** {{screen_management_system}} + + **Navigation Flow:** {{ui_navigation_patterns}} + + **Back Button Handling:** {{back_button_implementation}} + + - id: ui-components + title: UI Component System + instruction: | + Define reusable UI components and their implementation patterns. + elicit: true + sections: + - id: ui-component-library + title: UI Component Library + template: | + **Base Components:** {{base_ui_components}} + + **Custom Components:** {{custom_ui_components}} + + **Component Scenes:** {{ui_scene_organization}} + - id: ui-data-binding + title: UI Data Binding + template: | + **Data Binding Patterns:** {{ui_data_binding_approach}} + + **UI Events:** {{ui_event_system}} + + **View Model Patterns:** {{ui_viewmodel_implementation}} + + - id: ui-state-management + title: UI State Management + instruction: | + Define how UI state is managed across the game. + elicit: true + sections: + - id: ui-state-patterns + title: UI State Patterns + template: | + **State Persistence:** {{ui_state_persistence}} + + **Screen State:** {{screen_state_management}} + + **UI Configuration:** {{ui_configuration_management}} + + - id: scene-management + title: Scene Management Architecture + instruction: | + Define scene loading, unloading, and transition strategies. + elicit: true + sections: + - id: scene-structure + title: Scene Structure + template: | + **Scene Organization:** {{scene_organization_strategy}} + + **Scene Hierarchy:** {{scene_hierarchy_patterns}} + + **Persistent Scenes:** {{persistent_scene_usage}} + - id: scene-loading + title: Scene Loading System + template: | + **Loading Strategies:** {{scene_loading_patterns}} + + **Async Loading:** {{async_scene_loading_implementation}} + + **Loading Screens:** {{loading_screen_management}} + + - id: data-persistence + title: Data Persistence Architecture + instruction: | + Define save system and data persistence strategies. + elicit: true + sections: + - id: save-data-structure + title: Save Data Structure + template: | + **Save Data Models:** {{save_data_model_design}} + + **Serialization Format:** {{serialization_format_choice}} + + **Data Validation:** {{save_data_validation}} + - id: persistence-strategy + title: Persistence Strategy + template: | + **Save Triggers:** {{save_trigger_events}} + + **Auto-Save:** {{auto_save_implementation}} + + **Cloud Save:** {{cloud_save_integration}} + + - id: save-system + title: Save System Implementation + instruction: | + Define detailed save system implementation patterns. + elicit: true + sections: + - id: save-load-api + title: Save/Load API + template: | + **Save Interface:** {{save_interface_design}} + + **Load Interface:** {{load_interface_design}} + + **Error Handling:** {{save_load_error_handling}} + - id: save-file-management + title: Save File Management + template: | + **File Structure:** {{save_file_structure}} + + **Backup Strategy:** {{save_backup_strategy}} + + **Migration:** {{save_data_migration_strategy}} + + - id: analytics-integration + title: Analytics Integration + instruction: | + Define analytics tracking and integration patterns. + condition: Game requires analytics tracking + elicit: true + sections: + - id: analytics-events + title: Analytics Event Design + template: | + **Event Categories:** {{analytics_event_categories}} + + **Custom Events:** {{custom_analytics_events}} + + **Player Progression:** {{progression_analytics}} + - id: analytics-implementation + title: Analytics Implementation + template: | + **Analytics SDK:** {{analytics_sdk_choice}} + + **Event Tracking:** {{event_tracking_patterns}} + + **Privacy Compliance:** {{analytics_privacy_considerations}} + + - id: multiplayer-architecture + title: Multiplayer Architecture + instruction: | + Define multiplayer system architecture if applicable. + condition: Game includes multiplayer features + elicit: true + sections: + - id: networking-approach + title: Networking Approach + template: | + **Networking Solution:** {{networking_solution_choice}} + + **Architecture Pattern:** {{multiplayer_architecture_pattern}} + + **Synchronization:** {{state_synchronization_strategy}} + - id: multiplayer-systems + title: Multiplayer System Components + template: | + **Client Components:** {{multiplayer_client_components}} + + **Server Components:** {{multiplayer_server_components}} + + **Network Messages:** {{network_message_design}} + + - id: rendering-pipeline + title: Rendering Pipeline Configuration + instruction: | + Define Godot renderer setup and optimization. + elicit: true + sections: + - id: render-pipeline-setup + title: Render Pipeline Setup + template: | + **Pipeline Choice:** {{render_pipeline_choice}} (URP/Built-in) + + **Pipeline Asset:** {{render_pipeline_asset_config}} + + **Quality Settings:** {{quality_settings_configuration}} + - id: rendering-optimization + title: Rendering Optimization + template: | + **Batching Strategies:** {{sprite_batching_optimization}} + + **Draw Call Optimization:** {{draw_call_reduction_strategies}} + + **Texture Optimization:** {{texture_optimization_settings}} + + - id: shader-guidelines + title: Shader Guidelines + instruction: | + Define shader usage and custom shader guidelines. + elicit: true + sections: + - id: shader-usage + title: Shader Usage Patterns + template: | + **Built-in Shaders:** {{builtin_shader_usage}} + + **Custom Shaders:** {{custom_shader_requirements}} + + **Shader Variants:** {{shader_variant_management}} + - id: shader-performance + title: Shader Performance Guidelines + template: | + **Mobile Optimization:** {{mobile_shader_optimization}} + + **Performance Budgets:** {{shader_performance_budgets}} + + **Profiling Guidelines:** {{shader_profiling_approach}} + + - id: sprite-management + title: Sprite Management + instruction: | + Define sprite asset management and optimization strategies. + elicit: true + sections: + - id: sprite-organization + title: Sprite Organization + template: | + **Atlas Strategy:** {{sprite_atlas_organization}} + + **Sprite Naming:** {{sprite_naming_conventions}} + + **Import Settings:** {{sprite_import_settings}} + - id: sprite-optimization + title: Sprite Optimization + template: | + **Compression Settings:** {{sprite_compression_settings}} + + **Resolution Strategy:** {{sprite_resolution_strategy}} + + **Memory Optimization:** {{sprite_memory_optimization}} + + - id: particle-systems + title: Particle System Architecture + instruction: | + Define particle system usage and optimization. + elicit: true + sections: + - id: particle-design + title: Particle System Design + template: | + **Effect Categories:** {{particle_effect_categories}} + + **Scene Organization:** {{particle_scene_organization}} + + **Pooling Strategy:** {{particle_pooling_implementation}} + - id: particle-performance + title: Particle Performance + template: | + **Performance Budgets:** {{particle_performance_budgets}} + + **Mobile Optimization:** {{particle_mobile_optimization}} + + **LOD Strategy:** {{particle_lod_implementation}} + + - id: audio-architecture + title: Audio Architecture + instruction: | + Define audio system architecture and implementation. + elicit: true + sections: + - id: audio-system-design + title: Audio System Design + template: | + **Audio Manager:** {{audio_manager_implementation}} + + **Audio Sources:** {{audio_source_management}} + + **3D Audio:** {{spatial_audio_implementation}} + - id: audio-categories + title: Audio Categories + template: | + **Music System:** {{music_system_architecture}} + + **Sound Effects:** {{sfx_system_design}} + + **Voice/Dialog:** {{dialog_system_implementation}} + + - id: audio-mixing + title: Audio Mixing Configuration + instruction: | + Define Godot AudioBus setup and configuration. + elicit: true + sections: + - id: mixer-setup + title: Audio Mixer Setup + template: | + **Audio Buses:** {{audio_bus_structure}} + + **Effects Chain:** {{audio_effects_configuration}} + + **Bus Layout:** {{audio_bus_layout}} + - id: dynamic-mixing + title: Dynamic Audio Mixing + template: | + **Volume Control:** {{volume_control_implementation}} + + **Dynamic Range:** {{dynamic_range_management}} + + **Platform Optimization:** {{platform_audio_optimization}} + + - id: sound-banks + title: Sound Bank Management + instruction: | + Define sound asset organization and loading strategies. + elicit: true + sections: + - id: sound-organization + title: Sound Asset Organization + template: | + **Bank Structure:** {{sound_bank_organization}} + + **Loading Strategy:** {{audio_loading_patterns}} + + **Memory Management:** {{audio_memory_management}} + - id: sound-streaming + title: Audio Streaming + template: | + **Streaming Strategy:** {{audio_streaming_implementation}} + + **Compression Settings:** {{audio_compression_settings}} + + **Platform Considerations:** {{platform_audio_considerations}} + + - id: unity-conventions + title: Godot Development Conventions + instruction: | + Define Godot-specific development conventions and best practices. + elicit: true + sections: + - id: unity-best-practices + title: Godot Best Practices + template: | + **Node Design:** {{godot_node_best_practices}} + + **Performance Guidelines:** {{godot_performance_guidelines}} + + **Memory Management:** {{godot_memory_best_practices}} + - id: unity-workflow + title: Godot Workflow Conventions + template: | + **Scene Workflow:** {{scene_workflow_conventions}} + + **PackedScene Workflow:** {{packed_scene_workflow_conventions}} + + **Asset Workflow:** {{asset_workflow_conventions}} + + - id: external-integrations + title: External Integrations + condition: Game requires external service integrations + instruction: | + For each external service integration required by the game: + + 1. Identify services needed based on GDD requirements and platform needs + 2. If documentation URLs are unknown, ask user for specifics + 3. Document authentication methods and Godot-specific integration approaches + 4. List specific APIs that will be used + 5. Note any platform-specific SDKs or Godot addons required + + If no external integrations are needed, state this explicitly and skip to next section. + elicit: true + repeatable: true + sections: + - id: integration + title: "{{service_name}} Integration" + template: | + - **Purpose:** {{service_purpose}} + - **Documentation:** {{service_docs_url}} + - **Godot Addon:** {{godot_addon_name}} {{version}} + - **Platform SDK:** {{platform_sdk_requirements}} + - **Authentication:** {{auth_method}} + + **Key Features Used:** + - {{feature_1}} - {{feature_purpose}} + - {{feature_2}} - {{feature_purpose}} + + **Godot Implementation Notes:** {{godot_integration_details}} + + - id: core-workflows + title: Core Game Workflows + type: mermaid + mermaid_type: sequence + instruction: | + Illustrate key game workflows using sequence diagrams: + + 1. Identify critical player journeys from GDD (game loop, level progression, etc.) + 2. Show system interactions including Godot lifecycle methods + 3. Include error handling paths and state transitions + 4. Document async operations (scene loading, asset loading) + 5. Create both high-level game flow and detailed system interaction diagrams + + Focus on workflows that clarify Godot-specific architecture decisions or complex system interactions. + elicit: true + + - id: unity-project-structure + title: Godot Project Structure + type: code + language: plaintext + instruction: | + Create a Godot project folder structure that reflects: + + 1. Godot best practices for 2D game organization + 2. The selected renderer settings and addons + 3. Node organization from above systems + 4. Clear separation of concerns for game assets + 5. Testing structure for GUT/GoDotTest framework + 6. Platform-specific asset organization + + Follow Godot naming conventions and folder organization standards. + elicit: true + examples: + - | + ProjectName/ + ├── scenes/ # Game scenes + │ ├── gameplay/ # Level scenes + │ ├── ui/ # UI scenes + │ └── loading/ # Loading scenes + ├── scripts/ # GDScript/C# scripts + │ ├── core/ # Core systems + │ ├── gameplay/ # Gameplay mechanics + │ ├── ui/ # UI controllers + │ └── data/ # Resources + ├── prefabs/ # PackedScenes + │ ├── characters/ # Player, enemies + │ ├── environment/ # Level elements + │ └── ui/ # UI components + ├── assets/ # Visual assets + │ ├── sprites/ # 2D sprites + │ ├── materials/ # Godot materials + │ └── shaders/ # Custom shaders + ├── audio/ # Audio assets + │ ├── music/ # Background music + │ ├── sfx/ # Sound effects + │ └── buses/ # AudioBus layouts + ├── data/ # Game data + │ ├── settings/ # Game settings + │ └── balance/ # Balance data + ├── tests/ # Tests + │ ├── unit/ # Unit tests + │ └── integration/ # Integration tests + ├── addons/ # Third-party addons + └── project.godot # Godot project settings + + - id: infrastructure-deployment + title: Infrastructure and Deployment + instruction: | + Define the Godot export and deployment architecture: + + 1. Use Godot's export system and any additional tools + 2. Choose deployment strategy appropriate for target platforms + 3. Define environments (development, staging, production builds) + 4. Establish version control and build pipeline practices + 5. Consider platform-specific requirements and store submissions + + Get user input on export preferences and CI/CD tool choices for Godot projects. + elicit: true + sections: + - id: unity-build-configuration + title: Godot Export Configuration + template: | + - **Godot Version:** {{godot_version}} LTS + - **Build Pipeline:** {{build_pipeline_type}} + - **Resource Loading:** {{resource_loading_usage}} + - **Asset Bundles:** {{asset_bundle_strategy}} + - id: deployment-strategy + title: Deployment Strategy + template: | + - **Build Automation:** {{build_automation_tool}} + - **Version Control:** {{version_control_integration}} + - **Distribution:** {{distribution_platforms}} + - id: environments + title: Build Environments + repeatable: true + template: "- **{{env_name}}:** {{env_purpose}} - {{platform_settings}}" + - id: platform-specific-builds + title: Platform-Specific Build Settings + type: code + language: text + template: "{{platform_build_configurations}}" + + - id: coding-standards + title: Coding Standards + instruction: | + These standards are MANDATORY for AI agents working on Godot game development. Work with user to define ONLY the critical rules needed to prevent bad Godot code. Explain that: + + 1. This section directly controls AI developer behavior + 2. Keep it minimal - assume AI knows general GDScript/C# and Godot best practices + 3. Focus on project-specific Godot conventions and gotchas + 4. Overly detailed standards bloat context and slow development + 5. Standards will be extracted to separate file for dev agent use + + For each standard, get explicit user confirmation it's necessary. + elicit: true + sections: + - id: core-standards + title: Core Standards + template: | + - **Godot Version:** {{godot_version}} LTS + - **Language:** GDScript 2.0 / C# (.NET 6+) + - **Code Style:** Godot conventions + language-specific naming + - **Testing Framework:** GUT (GDScript) / GoDotTest (C#) + - id: unity-naming-conventions + title: Godot Naming Conventions + type: table + columns: [Element, Convention, Example] + instruction: Only include if deviating from Godot defaults + examples: + - "| Node Script | PascalCase + descriptive suffix | PlayerController, HealthSystem |" + - "| Resource | PascalCase + Data/Config suffix | PlayerData, GameConfig |" + - "| PackedScene | PascalCase descriptive | PlayerCharacter, EnvironmentTile |" + - id: critical-rules + title: Critical Godot Rules + instruction: | + List ONLY rules that AI might violate or Godot-specific requirements. Examples: + - "Always cache get_node() calls in _ready()" + - "Use @export for variables that need Inspector access" + - "Prefer Godot signals over direct method calls for decoupling" + - "Never call get_tree().get_nodes_in_group() in _process() or _physics_process()" + + Avoid obvious rules like "follow SOLID principles" or "optimize performance" + repeatable: true + template: "- **{{rule_name}}:** {{rule_description}}" + - id: unity-specifics + title: Godot-Specific Guidelines + condition: Critical Godot-specific rules needed + instruction: Add ONLY if critical for preventing AI mistakes with Godot APIs + sections: + - id: unity-lifecycle + title: Godot Lifecycle Rules + repeatable: true + template: "- **{{lifecycle_method}}:** {{usage_rule}}" + + - id: test-strategy + title: Test Strategy and Standards + instruction: | + Work with user to define comprehensive Godot test strategy: + + 1. Use GUT (GDScript) and GoDotTest (C#) testing frameworks + 2. Decide on test-driven development vs test-after approach + 3. Define test organization and naming for Godot projects + 4. Establish coverage goals for game logic + 5. Determine integration test infrastructure (scene-based testing) + 6. Plan for test data and mock external dependencies + + Note: Basic info goes in Coding Standards for dev agent. This detailed section is for comprehensive testing strategy. + elicit: true + sections: + - id: testing-philosophy + title: Testing Philosophy + template: | + - **Approach:** {{test_approach}} + - **Coverage Goals:** {{coverage_targets}} + - **Test Distribution:** {{edit_mode_vs_play_mode_split}} + - id: unity-test-types + title: Godot Test Types and Organization + sections: + - id: edit-mode-tests + title: Unit Tests + template: | + - **Framework:** GUT (GDScript) / GoDotTest (C#) + - **File Convention:** {{unit_test_naming}} + - **Location:** `res://tests/unit/` + - **Purpose:** Logic testing without scene dependencies + - **Coverage Requirement:** {{unit_test_coverage}} + + **AI Agent Requirements:** + - Test Resource data validation + - Test utility classes and static methods + - Test serialization/deserialization logic + - Mock Godot APIs where necessary + - id: play-mode-tests + title: Integration Tests + template: | + - **Framework:** GUT / GoDotTest with test scenes + - **Location:** `res://tests/integration/` + - **Purpose:** Integration testing with Godot runtime + - **Test Scenes:** {{test_scene_requirements}} + - **Coverage Requirement:** {{integration_test_coverage}} + + **AI Agent Requirements:** + - Test Node component interactions + - Test scene loading and Node lifecycle + - Test physics interactions and collision systems + - Test UI interactions and signal systems + - id: test-data-management + title: Test Data Management + template: | + - **Strategy:** {{test_data_approach}} + - **Resource Fixtures:** {{test_resource_location}} + - **Test Scene Templates:** {{test_scene_templates}} + - **Cleanup Strategy:** {{cleanup_approach}} + + - id: security + title: Security Considerations + instruction: | + Define security requirements specific to Godot game development: + + 1. Focus on Godot-specific security concerns + 2. Consider platform store requirements + 3. Address save data protection and anti-cheat measures + 4. Define secure communication patterns for multiplayer + 5. These rules directly impact Godot code generation + elicit: true + sections: + - id: save-data-security + title: Save Data Security + template: | + - **Encryption:** {{save_data_encryption_method}} + - **Validation:** {{save_data_validation_approach}} + - **Anti-Tampering:** {{anti_tampering_measures}} + - id: platform-security + title: Platform Security Requirements + template: | + - **Mobile Permissions:** {{mobile_permission_requirements}} + - **Store Compliance:** {{platform_store_requirements}} + - **Privacy Policy:** {{privacy_policy_requirements}} + - id: multiplayer-security + title: Multiplayer Security (if applicable) + condition: Game includes multiplayer features + template: | + - **Client Validation:** {{client_validation_rules}} + - **Server Authority:** {{server_authority_approach}} + - **Anti-Cheat:** {{anti_cheat_measures}} + + - id: checklist-results + title: Checklist Results Report + instruction: Before running the checklist, offer to output the full game architecture document. Once user confirms, execute the architect-checklist and populate results here. + + - id: next-steps + title: Next Steps + instruction: | + After completing the game architecture: + + 1. Review with Game Designer and technical stakeholders + 2. Begin story implementation with Game Developer agent + 3. Set up Godot project structure and initial configuration + 4. Configure version control and build pipeline + + Include specific prompts for next agents if needed. + sections: + - id: developer-prompt + title: Game Developer Prompt + instruction: | + Create a brief prompt to hand off to Game Developer for story implementation. Include: + - Reference to this game architecture document + - Key Godot-specific requirements from this architecture + - Any Godot addon or configuration decisions made here + - Request for adherence to established coding standards and patterns diff --git a/expansion-packs/bmad-2d-godot-game-dev/templates/game-brief-tmpl.yaml b/expansion-packs/bmad-2d-godot-game-dev/templates/game-brief-tmpl.yaml new file mode 100644 index 00000000..e76461a0 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/templates/game-brief-tmpl.yaml @@ -0,0 +1,356 @@ +template: + id: game-brief-template-v3 + name: Game Brief + version: 3.0 + output: + format: markdown + filename: docs/game-brief.md + title: "{{game_title}} Game Brief" + +workflow: + mode: interactive + +sections: + - id: initial-setup + instruction: | + This template creates a comprehensive game brief that serves as the foundation for all subsequent game development work. The brief should capture the essential vision, scope, and requirements needed to create a detailed Game Design Document. + + This brief is typically created early in the ideation process, often after brainstorming sessions, to crystallize the game concept before moving into detailed design. + + - id: game-vision + title: Game Vision + instruction: Establish the core vision and identity of the game. Present each subsection and gather user feedback before proceeding. + sections: + - id: core-concept + title: Core Concept + instruction: 2-3 sentences that clearly capture what the game is and why it will be compelling to players + - id: elevator-pitch + title: Elevator Pitch + instruction: Single sentence that captures the essence of the game in a memorable way + template: | + **"{{game_description_in_one_sentence}}"** + - id: vision-statement + title: Vision Statement + instruction: Inspirational statement about what the game will achieve for players and why it matters + + - id: target-market + title: Target Market + instruction: Define the audience and market context. Apply `tasks#advanced-elicitation` after presenting this section. + sections: + - id: primary-audience + title: Primary Audience + template: | + **Demographics:** {{age_range}}, {{platform_preference}}, {{gaming_experience}} + **Psychographics:** {{interests}}, {{motivations}}, {{play_patterns}} + **Gaming Preferences:** {{preferred_genres}}, {{session_length}}, {{difficulty_preference}} + - id: secondary-audiences + title: Secondary Audiences + template: | + **Audience 2:** {{description}} + **Audience 3:** {{description}} + - id: market-context + title: Market Context + template: | + **Genre:** {{primary_genre}} / {{secondary_genre}} + **Platform Strategy:** {{platform_focus}} + **Competitive Positioning:** {{differentiation_statement}} + + - id: game-fundamentals + title: Game Fundamentals + instruction: Define the core gameplay elements. Each subsection should be specific enough to guide detailed design work. + sections: + - id: core-gameplay-pillars + title: Core Gameplay Pillars + instruction: 3-5 fundamental principles that guide all design decisions + type: numbered-list + template: | + **{{pillar_name}}** - {{description_and_rationale}} + - id: primary-mechanics + title: Primary Mechanics + instruction: List the 3-5 most important gameplay mechanics that define the player experience + repeatable: true + template: | + **Core Mechanic: {{mechanic_name}}** + + - **Description:** {{how_it_works}} + - **Player Value:** {{why_its_fun}} + - **Implementation Scope:** {{complexity_estimate}} + - id: player-experience-goals + title: Player Experience Goals + instruction: Define what emotions and experiences the game should create for players + template: | + **Primary Experience:** {{main_emotional_goal}} + **Secondary Experiences:** {{supporting_emotional_goals}} + **Engagement Pattern:** {{how_player_engagement_evolves}} + + - id: scope-constraints + title: Scope and Constraints + instruction: Define the boundaries and limitations that will shape development. Apply `tasks#advanced-elicitation` to clarify any constraints. + sections: + - id: project-scope + title: Project Scope + template: | + **Game Length:** {{estimated_content_hours}} + **Content Volume:** {{levels_areas_content_amount}} + **Feature Complexity:** {{simple|moderate|complex}} + **Scope Comparison:** "Similar to {{reference_game}} but with {{key_differences}}" + - id: technical-constraints + title: Technical Constraints + template: | + **Platform Requirements:** + + - Primary: {{platform_1}} - {{requirements}} + - Secondary: {{platform_2}} - {{requirements}} + + **Technical Specifications:** + + - Engine: Godot & GDScript/C# + - Performance Target: {{fps_target}} FPS on {{target_device}} + - Memory Budget: <{{memory_limit}}MB + - Load Time Goal: <{{load_time_seconds}}s + - id: resource-constraints + title: Resource Constraints + template: | + **Team Size:** {{team_composition}} + **Timeline:** {{development_duration}} + **Budget Considerations:** {{budget_constraints_or_targets}} + **Asset Requirements:** {{art_audio_content_needs}} + - id: business-constraints + title: Business Constraints + condition: has_business_goals + template: | + **Monetization Model:** {{free|premium|freemium|subscription}} + **Revenue Goals:** {{revenue_targets_if_applicable}} + **Platform Requirements:** {{store_certification_needs}} + **Launch Timeline:** {{target_launch_window}} + + - id: reference-framework + title: Reference Framework + instruction: Provide context through references and competitive analysis + sections: + - id: inspiration-games + title: Inspiration Games + sections: + - id: primary-references + title: Primary References + type: numbered-list + repeatable: true + template: | + **{{reference_game}}** - {{what_we_learn_from_it}} + - id: competitive-analysis + title: Competitive Analysis + template: | + **Direct Competitors:** + + - {{competitor_1}}: {{strengths_and_weaknesses}} + - {{competitor_2}}: {{strengths_and_weaknesses}} + + **Differentiation Strategy:** + {{how_we_differ_and_why_thats_valuable}} + - id: market-opportunity + title: Market Opportunity + template: | + **Market Gap:** {{underserved_need_or_opportunity}} + **Timing Factors:** {{why_now_is_the_right_time}} + **Success Metrics:** {{how_well_measure_success}} + + - id: content-framework + title: Content Framework + instruction: Outline the content structure and progression without full design detail + sections: + - id: game-structure + title: Game Structure + template: | + **Overall Flow:** {{linear|hub_world|open_world|procedural}} + **Progression Model:** {{how_players_advance}} + **Session Structure:** {{typical_play_session_flow}} + - id: content-categories + title: Content Categories + template: | + **Core Content:** + + - {{content_type_1}}: {{quantity_and_description}} + - {{content_type_2}}: {{quantity_and_description}} + + **Optional Content:** + + - {{optional_content_type}}: {{quantity_and_description}} + + **Replay Elements:** + + - {{replayability_features}} + - id: difficulty-accessibility + title: Difficulty and Accessibility + template: | + **Difficulty Approach:** {{how_challenge_is_structured}} + **Accessibility Features:** {{planned_accessibility_support}} + **Skill Requirements:** {{what_skills_players_need}} + + - id: art-audio-direction + title: Art and Audio Direction + instruction: Establish the aesthetic vision that will guide asset creation + sections: + - id: visual-style + title: Visual Style + template: | + **Art Direction:** {{style_description}} + **Reference Materials:** {{visual_inspiration_sources}} + **Technical Approach:** {{2d_style_pixel_vector_etc}} + **Color Strategy:** {{color_palette_mood}} + - id: audio-direction + title: Audio Direction + template: | + **Music Style:** {{genre_and_mood}} + **Sound Design:** {{audio_personality}} + **Implementation Needs:** {{technical_audio_requirements}} + - id: ui-ux-approach + title: UI/UX Approach + template: | + **Interface Style:** {{ui_aesthetic}} + **User Experience Goals:** {{ux_priorities}} + **Platform Adaptations:** {{cross_platform_considerations}} + + - id: risk-assessment + title: Risk Assessment + instruction: Identify potential challenges and mitigation strategies + sections: + - id: technical-risks + title: Technical Risks + type: table + template: | + | Risk | Probability | Impact | Mitigation Strategy | + | ---- | ----------- | ------ | ------------------- | + | {{technical_risk}} | {{high|med|low}} | {{high|med|low}} | {{mitigation_approach}} | + - id: design-risks + title: Design Risks + type: table + template: | + | Risk | Probability | Impact | Mitigation Strategy | + | ---- | ----------- | ------ | ------------------- | + | {{design_risk}} | {{high|med|low}} | {{high|med|low}} | {{mitigation_approach}} | + - id: market-risks + title: Market Risks + type: table + template: | + | Risk | Probability | Impact | Mitigation Strategy | + | ---- | ----------- | ------ | ------------------- | + | {{market_risk}} | {{high|med|low}} | {{high|med|low}} | {{mitigation_approach}} | + + - id: success-criteria + title: Success Criteria + instruction: Define measurable goals for the project + sections: + - id: player-experience-metrics + title: Player Experience Metrics + template: | + **Engagement Goals:** + + - Tutorial completion rate: >{{percentage}}% + - Average session length: {{duration}} minutes + - Player retention: D1 {{d1}}%, D7 {{d7}}%, D30 {{d30}}% + + **Quality Benchmarks:** + + - Player satisfaction: >{{rating}}/10 + - Completion rate: >{{percentage}}% + - Technical performance: {{fps_target}} FPS consistent + - id: development-metrics + title: Development Metrics + template: | + **Technical Targets:** + + - Zero critical bugs at launch + - Performance targets met on all platforms + - Load times under {{seconds}}s + + **Process Goals:** + + - Development timeline adherence + - Feature scope completion + - Quality assurance standards + - id: business-metrics + title: Business Metrics + condition: has_business_goals + template: | + **Commercial Goals:** + + - {{revenue_target}} in first {{time_period}} + - {{user_acquisition_target}} players in first {{time_period}} + - {{retention_target}} monthly active users + + - id: next-steps + title: Next Steps + instruction: Define immediate actions following the brief completion + sections: + - id: immediate-actions + title: Immediate Actions + type: numbered-list + template: | + **{{action_item}}** - {{details_and_timeline}} + - id: development-roadmap + title: Development Roadmap + sections: + - id: phase-1-preproduction + title: "Phase 1: Pre-Production ({{duration}})" + type: bullet-list + template: | + - Detailed Game Design Document creation + - Technical architecture planning + - Art style exploration and pipeline setup + - id: phase-2-prototype + title: "Phase 2: Prototype ({{duration}})" + type: bullet-list + template: | + - Core mechanic implementation + - Technical proof of concept + - Initial playtesting and iteration + - id: phase-3-production + title: "Phase 3: Production ({{duration}})" + type: bullet-list + template: | + - Full feature development + - Content creation and integration + - Comprehensive testing and optimization + - id: documentation-pipeline + title: Documentation Pipeline + sections: + - id: required-documents + title: Required Documents + type: numbered-list + template: | + Game Design Document (GDD) - {{target_completion}} + Technical Architecture Document - {{target_completion}} + Art Style Guide - {{target_completion}} + Production Plan - {{target_completion}} + - id: validation-plan + title: Validation Plan + template: | + **Concept Testing:** + + - {{validation_method_1}} - {{timeline}} + - {{validation_method_2}} - {{timeline}} + + **Prototype Testing:** + + - {{testing_approach}} - {{timeline}} + - {{feedback_collection_method}} - {{timeline}} + + - id: appendices + title: Appendices + sections: + - id: research-materials + title: Research Materials + instruction: Include any supporting research, competitive analysis, or market data that informed the brief + - id: brainstorming-notes + title: Brainstorming Session Notes + instruction: Reference any brainstorming sessions that led to this brief + - id: stakeholder-input + title: Stakeholder Input + instruction: Include key input from stakeholders that shaped the vision + - id: change-log + title: Change Log + instruction: Track document versions and changes + type: table + template: | + | Date | Version | Description | Author | + | :--- | :------ | :---------- | :----- | diff --git a/expansion-packs/bmad-2d-godot-game-dev/templates/game-design-doc-tmpl.yaml b/expansion-packs/bmad-2d-godot-game-dev/templates/game-design-doc-tmpl.yaml new file mode 100644 index 00000000..76d1c863 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/templates/game-design-doc-tmpl.yaml @@ -0,0 +1,704 @@ +template: + id: game-design-doc-template-v3 + name: Game Design Document (GDD) + version: 4.0 + output: + format: markdown + filename: docs/game-design-document.md + title: "{{game_title}} Game Design Document (GDD)" + +workflow: + mode: interactive + elicitation: advanced-elicitation + +sections: + - id: goals-context + title: Goals and Background Context + instruction: | + Ask if Project Brief document is available. If NO Project Brief exists, STRONGLY recommend creating one first using project-brief-tmpl (it provides essential foundation: problem statement, target users, success metrics, MVP scope, constraints). If user insists on GDD without brief, gather this information during Goals section. If Project Brief exists, review and use it to populate Goals (bullet list of desired game development outcomes) and Background Context (1-2 paragraphs on what game concept this will deliver and why) so we can determine what is and is not in scope for the GDD. Include Change Log table for version tracking. + sections: + - id: goals + title: Goals + type: bullet-list + instruction: Bullet list of 1 line desired outcomes the GDD will deliver if successful - game development and player experience goals + examples: + - Create an engaging 2D platformer that teaches players basic programming concepts + - Deliver a polished mobile game that runs smoothly on low-end Android devices + - Build a foundation for future expansion packs and content updates + - id: background + title: Background Context + type: paragraphs + instruction: 1-2 short paragraphs summarizing the game concept background, target audience needs, market opportunity, and what problem this game solves + - id: changelog + title: Change Log + type: table + columns: [Date, Version, Description, Author] + instruction: Track document versions and changes + + - id: executive-summary + title: Executive Summary + instruction: Create a compelling overview that captures the essence of the game. Present this section first and get user feedback before proceeding. + elicit: true + sections: + - id: core-concept + title: Core Concept + instruction: 2-3 sentences that clearly describe what the game is and why players will love it + examples: + - A fast-paced 2D platformer where players manipulate gravity to solve puzzles and defeat enemies in a hand-drawn world. + - An educational puzzle game that teaches coding concepts through visual programming blocks in a fantasy adventure setting. + - id: target-audience + title: Target Audience + instruction: Define the primary and secondary audience with demographics and gaming preferences + template: | + **Primary:** {{age_range}}, {{player_type}}, {{platform_preference}} + **Secondary:** {{secondary_audience}} + examples: + - "Primary: Ages 8-16, casual mobile gamers, prefer short play sessions" + - "Secondary: Adult puzzle enthusiasts, educators looking for teaching tools" + - id: platform-technical + title: Platform & Technical Requirements + instruction: Based on the technical preferences or user input, define the target platforms and Godot-specific requirements + template: | + **Primary Platform:** {{platform}} + **Engine:** Godot {{godot_version}} & GDScript/C# + **Performance Target:** Stable {{fps_target}} FPS on {{minimum_device}} + **Screen Support:** {{resolution_range}} + **Build Targets:** {{build_targets}} + examples: + - "Primary Platform: Mobile (iOS/Android), Engine: Godot 4.2 LTS & GDScript/C#, Performance: 60 FPS on iPhone 8/Galaxy S8" + - id: unique-selling-points + title: Unique Selling Points + instruction: List 3-5 key features that differentiate this game from competitors + type: numbered-list + examples: + - Innovative gravity manipulation mechanic that affects both player and environment + - Seamless integration of educational content without compromising fun gameplay + - Adaptive difficulty system that learns from player behavior + + - id: core-gameplay + title: Core Gameplay + instruction: This section defines the fundamental game mechanics. After presenting each subsection, apply advanced elicitation to ensure completeness and gather additional details. + elicit: true + sections: + - id: game-pillars + title: Game Pillars + instruction: Define 3-5 core pillars that guide all design decisions. These should be specific and actionable for Godot development. + type: numbered-list + template: | + **{{pillar_name}}** - {{description}} + examples: + - Intuitive Controls - All interactions must be learnable within 30 seconds using touch or keyboard + - Immediate Feedback - Every player action provides visual and audio response within 0.1 seconds + - Progressive Challenge - Difficulty increases through mechanic complexity, not unfair timing + - id: core-gameplay-loop + title: Core Gameplay Loop + instruction: Define the 30-60 second loop that players will repeat. Be specific about timing and player actions for Godot implementation. + template: | + **Primary Loop ({{duration}} seconds):** + + 1. {{action_1}} ({{time_1}}s) - {{godot_node}} + 2. {{action_2}} ({{time_2}}s) - {{godot_node}} + 3. {{action_3}} ({{time_3}}s) - {{godot_node}} + 4. {{reward_feedback}} ({{time_4}}s) - {{godot_node}} + examples: + - Observe environment (2s) - Camera Controller, Identify puzzle elements (3s) - Highlight System + - id: win-loss-conditions + title: Win/Loss Conditions + instruction: Clearly define success and failure states with Godot-specific implementation notes + template: | + **Victory Conditions:** + + - {{win_condition_1}} - Godot Signal: {{godot_signal}} + - {{win_condition_2}} - Godot Signal: {{godot_signal}} + + **Failure States:** + + - {{loss_condition_1}} - Trigger: {{godot_trigger}} + - {{loss_condition_2}} - Trigger: {{godot_trigger}} + examples: + - "Victory: Player reaches exit portal - Godot Signal: area_entered with Portal group" + - "Failure: Health reaches zero - Trigger: Health component value <= 0" + + - id: game-mechanics + title: Game Mechanics + instruction: Detail each major mechanic that will need Godot implementation. Each mechanic should be specific enough for developers to create GDScript/C# scripts and scenes. + elicit: true + sections: + - id: primary-mechanics + title: Primary Mechanics + repeatable: true + sections: + - id: mechanic + title: "{{mechanic_name}}" + template: | + **Description:** {{detailed_description}} + + **Player Input:** {{input_method}} - Godot Input: {{input_action}} + + **System Response:** {{game_response}} + + **Godot Implementation Notes:** + + - **Nodes Needed:** {{node_list}} + - **Physics Requirements:** {{physics_2d_setup}} + - **Animation States:** {{animation_player_states}} + - **Performance Considerations:** {{optimization_notes}} + + **Dependencies:** {{other_mechanics_needed}} + + **Script Architecture:** + + - {{script_name}}.gd/.cs - {{responsibility}} + - {{manager_script}}.gd/.cs - {{management_role}} + examples: + - "Nodes Needed: RigidBody2D, CollisionShape2D, PlayerMovement script" + - "Physics Requirements: 2D Physics material for ground friction, Gravity scale 3" + - id: controls + title: Controls + instruction: Define all input methods for different platforms using Godot's Input system + type: table + template: | + | Action | Desktop | Mobile | Gamepad | Godot Input Action | + | ------ | ------- | ------ | ------- | ------------------ | + | {{action}} | {{key}} | {{gesture}} | {{button}} | {{input_action}} | + examples: + - Move Left, A/Left Arrow, Swipe Left, Left Stick, /x + + - id: progression-balance + title: Progression & Balance + instruction: Define how players advance and how difficulty scales. This section should provide clear parameters for Godot implementation and resources. + elicit: true + sections: + - id: player-progression + title: Player Progression + template: | + **Progression Type:** {{linear|branching|metroidvania}} + + **Key Milestones:** + + 1. **{{milestone_1}}** - {{unlock_description}} - Godot: {{resource_update}} + 2. **{{milestone_2}}** - {{unlock_description}} - Godot: {{resource_update}} + 3. **{{milestone_3}}** - {{unlock_description}} - Godot: {{resource_update}} + + **Save Data Structure:** + + ```gdscript + class_name PlayerProgress + extends Resource + + @export var {{progress_fields}} + ``` + examples: + - public int currentLevel, public bool[] unlockedAbilities, public float totalPlayTime + - id: difficulty-curve + title: Difficulty Curve + instruction: Provide specific parameters for balancing that can be implemented as Godot Resources + template: | + **Tutorial Phase:** {{duration}} - {{difficulty_description}} + - Godot Config: {{resource_values}} + + **Early Game:** {{duration}} - {{difficulty_description}} + - Godot Config: {{resource_values}} + + **Mid Game:** {{duration}} - {{difficulty_description}} + - Godot Config: {{resource_values}} + + **Late Game:** {{duration}} - {{difficulty_description}} + - Godot Config: {{resource_values}} + examples: + - "enemy speed: 2.0f, jump height: 4.5f, obstacle density: 0.3f" + - id: economy-resources + title: Economy & Resources + condition: has_economy + instruction: Define any in-game currencies, resources, or collectibles with Godot implementation details + type: table + template: | + | Resource | Earn Rate | Spend Rate | Purpose | Cap | Godot Resource | + | -------- | --------- | ---------- | ------- | --- | --------------------- | + | {{resource}} | {{rate}} | {{rate}} | {{use}} | {{max}} | {{so_name}} | + examples: + - Coins, 1-3 per enemy, 10-50 per upgrade, Buy abilities, 9999, CurrencyData + + - id: level-design-framework + title: Level Design Framework + instruction: Provide guidelines for level creation that developers can use to create Godot scenes and PackedScenes. Focus on modular design and reusable components. + elicit: true + sections: + - id: level-types + title: Level Types + repeatable: true + sections: + - id: level-type + title: "{{level_type_name}}" + template: | + **Purpose:** {{gameplay_purpose}} + **Target Duration:** {{target_time}} + **Key Elements:** {{required_mechanics}} + **Difficulty Rating:** {{relative_difficulty}} + + **Godot Scene Structure: + + - **Environment:** {{tilemap_setup}} + - **Gameplay Objects:** {{prefab_list}} + - **Lighting:** {{lighting_setup}} + - **Audio:** {{audio_sources}} + + **Level Flow Template:** + + - **Introduction:** {{intro_description}} - Area: {{unity_area_bounds}} + - **Challenge:** {{main_challenge}} - Mechanics: {{active_components}} + - **Resolution:** {{completion_requirement}} - Trigger: {{completion_trigger}} + + **Reusable PackedScenes:** + + - {{prefab_name}} - {{prefab_purpose}} + examples: + - "Environment: TilemapRenderer with Platform tileset, Lighting: 2D Global Light + Point Lights" + - id: level-progression + title: Level Progression + template: | + **World Structure:** {{linear|hub|open}} + **Total Levels:** {{number}} + **Unlock Pattern:** {{progression_method}} + **Scene Management:** {{unity_scene_loading}} + + **Godot Scene Organization:** + + - Scene Naming: {{naming_convention}} + - Addressable Assets: {{addressable_groups}} + - Loading Screens: {{loading_implementation}} + examples: + - "Scene Naming: World{X}_Level{Y}_Name, Addressable Groups: Levels_World1, World_Environments" + + - id: technical-specifications + title: Technical Specifications + instruction: Define Godot-specific technical requirements that will guide architecture and implementation decisions. Reference Godot documentation and best practices. + elicit: true + choices: + render_pipeline: [Built-in, URP, HDRP] + input_system: [Legacy, New Input System, Both] + physics: [2D Only, 3D Only, Hybrid] + sections: + - id: unity-configuration + title: Godot Project Configuration + template: | + **Godot Version:** {{godot_version}} (LTS recommended) + **Renderer:** {{Forward+|Mobile|Compatibility}} + **Physics:** {{2D Only|3D Only|Hybrid}} + **Scripting:** {{GDScript|C#|Both}} + **Threading:** {{Single|Multi}} + **Audio Driver:** {{PulseAudio|ALSA|WASAPI}} + + **Required Addons:** + + - {{addon_name}} {{version}} - {{purpose}} + + **Project Settings:** + + - Color Space: {{Linear|Gamma}} + - Quality Settings: {{quality_levels}} + - Physics Settings: {{physics_config}} + examples: + - gut 7.4.0 - Testing framework for GDScript + - "Color Space: Linear, Quality: Mobile/Desktop presets, Gravity: -20" + - id: performance-requirements + title: Performance Requirements + template: | + **Frame Rate:** {{fps_target}} FPS (minimum {{min_fps}} on low-end devices) + **Memory Usage:** <{{memory_limit}}MB heap, <{{texture_memory}}MB textures + **Load Times:** <{{load_time}}s initial, <{{level_load}}s between levels + **Battery Usage:** Optimized for mobile devices - {{battery_target}} hours gameplay + + **Godot Profiler Targets:** + + - CPU Frame Time: <{{cpu_time}}ms + - GPU Frame Time: <{{gpu_time}}ms + - GC Allocs: <{{gc_limit}}KB per frame + - Draw Calls: <{{draw_calls}} per frame + examples: + - "60 FPS (minimum 30), CPU: <16.67ms, GPU: <16.67ms, GC: <4KB, Draws: <50" + - id: platform-specific + title: Platform Specific Requirements + template: | + **Desktop:** + + - Resolution: {{min_resolution}} - {{max_resolution}} + - Input: Keyboard, Mouse, Gamepad ({{gamepad_support}}) + - Build Target: {{desktop_targets}} + + **Mobile:** + + - Resolution: {{mobile_min}} - {{mobile_max}} + - Input: Touch, Accelerometer ({{sensor_support}}) + - OS: iOS {{ios_min}}+, Android {{android_min}}+ (API {{api_level}}) + - Device Requirements: {{device_specs}} + + **Web (if applicable):** + + - WebGL Version: {{webgl_version}} + - Browser Support: {{browser_list}} + - Compression: {{compression_format}} + examples: + - "Resolution: 1280x720 - 4K, Gamepad: Xbox/PlayStation controllers via Input System" + - id: asset-requirements + title: Asset Requirements + instruction: Define asset specifications for Godot import pipeline optimization + template: | + **2D Art Assets:** + + - Sprites: {{sprite_resolution}} at {{ppu}} PPU + - Texture Format: {{texture_compression}} + - Atlas Strategy: {{sprite_atlas_setup}} + - Animation: {{animation_type}} at {{framerate}} FPS + + **Audio Assets:** + + - Music: {{audio_format}} at {{sample_rate}} Hz + - SFX: {{sfx_format}} at {{sfx_sample_rate}} Hz + - Compression: {{audio_compression}} + - 3D Audio: {{spatial_audio}} + + **UI Assets:** + + - Canvas Resolution: {{ui_resolution}} + - UI Scale Mode: {{scale_mode}} + - Font: {{font_requirements}} + - Icon Sizes: {{icon_specifications}} + examples: + - "Sprites: 32x32 to 256x256 at 16 PPU, Format: RGBA32 for quality/RGBA16 for performance" + + - id: technical-architecture-requirements + title: Technical Architecture Requirements + instruction: Define high-level Godot architecture patterns and systems that the game must support. Focus on scalability and maintainability. + elicit: true + choices: + architecture_pattern: [MVC, MVVM, ECS, Component-Based] + save_system: [PlayerPrefs, JSON, Binary, Cloud] + audio_system: [Godot Audio, FMOD, Wwise] + sections: + - id: code-architecture + title: Code Architecture Pattern + template: | + **Architecture Pattern:** {{MVC|MVVM|ECS|Component-Based|Custom}} + + **Core Systems Required:** + + - **Scene Management:** {{scene_manager_approach}} + - **State Management:** {{state_pattern_implementation}} + - **Event System:** {{event_system_choice}} + - **Object Pooling:** {{pooling_strategy}} + - **Save/Load System:** {{save_system_approach}} + + **Folder Structure:** + + ``` + Assets/ + ├── _Project/ + │ ├── Scripts/ + │ │ ├── {{folder_structure}} + │ ├── Scenes/ + │ ├── Scenes/ + │ └── {{additional_folders}} + ``` + + **Naming Conventions:** + + - Scripts: {{script_naming}} + - Scenes: {{scene_naming}} + - Scenes: {{scene_naming}} + examples: + - "Architecture: Node-Based with Resource data containers" + - "Scripts: PascalCase (PlayerController), Scenes: Player.tscn, Levels: Level_01_Forest.tscn" + - id: unity-systems-integration + title: Godot Systems Integration + template: | + **Required Godot Systems:** + + - **Input System:** {{input_implementation}} + - **Animation System:** {{animation_approach}} + - **Physics Integration:** {{physics_usage}} + - **Rendering Features:** {{rendering_requirements}} + - **Asset Streaming:** {{asset_loading_strategy}} + + **Third-Party Integrations:** + + - {{integration_name}}: {{integration_purpose}} + + **Performance Systems:** + + - **Profiling Integration:** {{profiling_setup}} + - **Memory Management:** {{memory_strategy}} + - **Build Pipeline:** {{build_automation}} + examples: + - "Input System: Action Maps for Menu/Gameplay contexts with device switching" + - "DOTween: Smooth UI transitions and gameplay animations" + - id: data-management + title: Data Management + template: | + **Save Data Architecture:** + + - **Format:** {{PlayerPrefs|JSON|Binary|Cloud}} + - **Structure:** {{save_data_organization}} + - **Encryption:** {{security_approach}} + - **Cloud Sync:** {{cloud_integration}} + + **Configuration Data:** + + - **Resources:** {{resource_usage}} + - **Settings Management:** {{settings_system}} + - **Localization:** {{localization_approach}} + + **Runtime Data:** + + - **Caching Strategy:** {{cache_implementation}} + - **Memory Pools:** {{pooling_objects}} + - **Asset References:** {{asset_reference_system}} + examples: + - "Save Data: JSON format with AES encryption, stored in persistent data path" + - "Resources: Game settings, level configurations, character data" + + - id: development-phases + title: Development Phases & Epic Planning + instruction: Break down the Godot development into phases that can be converted to agile epics. Each phase should deliver deployable functionality following Godot best practices. + elicit: true + sections: + - id: phases-overview + title: Phases Overview + instruction: Present a high-level list of all phases for user approval. Each phase's design should deliver significant Godot functionality. + type: numbered-list + examples: + - "Phase 1: Godot Foundation & Core Systems: Project setup, input handling, basic scene management" + - "Phase 2: Core Game Mechanics: Player controller, physics systems, basic gameplay loop" + - "Phase 3: Level Systems & Content Pipeline: Scene loading, prefab systems, level progression" + - "Phase 4: Polish & Platform Optimization: Performance tuning, platform-specific features, deployment" + - id: phase-1-foundation + title: "Phase 1: Godot Foundation & Core Systems ({{duration}})" + sections: + - id: foundation-design + title: "Design: Godot Project Foundation" + type: bullet-list + template: | + - Godot project setup with proper folder structure and naming conventions + - Core architecture implementation ({{architecture_pattern}}) + - Input System configuration with action maps for all platforms + - Basic scene management and state handling + - Development tools setup (debugging, profiling integration) + - Initial build pipeline and platform configuration + examples: + - "Input System: Configure PlayerInput component with Action Maps for movement and UI" + - id: core-systems-design + title: "Design: Essential Game Systems" + type: bullet-list + template: | + - Save/Load system implementation with {{save_format}} format + - Audio system setup with {{audio_system}} integration + - Event system for decoupled component communication + - Object pooling system for performance optimization + - Basic UI framework and canvas configuration + - Settings and configuration management with Resources + - id: phase-2-gameplay + title: "Phase 2: Core Gameplay Implementation ({{duration}})" + sections: + - id: gameplay-mechanics-design + title: "Design: Primary Game Mechanics" + type: bullet-list + template: | + - Player controller with {{movement_type}} movement system + - {{primary_mechanic}} implementation with Godot physics + - {{secondary_mechanic}} system with visual feedback + - Game state management (playing, paused, game over) + - Basic collision detection and response systems + - Animation system integration with Animator controllers + - id: level-systems-design + title: "Design: Level & Content Systems" + type: bullet-list + template: | + - Scene loading and transition system + - Level progression and unlock system + - Scene-based level construction tools + - {{level_generation}} level creation workflow + - Collectibles and pickup systems + - Victory/defeat condition implementation + - id: phase-3-polish + title: "Phase 3: Polish & Optimization ({{duration}})" + sections: + - id: performance-design + title: "Design: Performance & Platform Optimization" + type: bullet-list + template: | + - Godot Profiler analysis and optimization passes + - Memory management and garbage collection optimization + - Asset optimization (texture compression, audio compression) + - Platform-specific performance tuning + - Build size optimization and asset bundling + - Quality settings configuration for different device tiers + - id: user-experience-design + title: "Design: User Experience & Polish" + type: bullet-list + template: | + - Complete UI/UX implementation with responsive design + - Audio implementation with dynamic mixing + - Visual effects and particle systems + - Accessibility features implementation + - Tutorial and onboarding flow + - Final testing and bug fixing across all platforms + + - id: epic-list + title: Epic List + instruction: | + Present a high-level list of all epics for user approval. Each epic should have a title and a short (1 sentence) goal statement. This allows the user to review the overall structure before diving into details. + + CRITICAL: Epics MUST be logically sequential following agile best practices: + + - Each epic should be focused on a single phase and it's design from the development-phases section and deliver a significant, end-to-end, fully deployable increment of testable functionality + - Epic 1 must establish Phase 1: Godot Foundation & Core Systems (Project setup, input handling, basic scene management) unless we are adding new functionality to an existing app, while also delivering an initial piece of functionality, remember this when we produce the stories for the first epic! + - Each subsequent epic builds upon previous epics' functionality delivering major blocks of functionality that provide tangible value to users or business when deployed + - Not every project needs multiple epics, an epic needs to deliver value. For example, an API, component, or scriptableobject completed can deliver value even if a scene, or gameobject is not complete and planned for a separate epic. + - Err on the side of less epics, but let the user know your rationale and offer options for splitting them if it seems some are too large or focused on disparate things. + - Cross Cutting Concerns should flow through epics and stories and not be final stories. For example, adding a logging framework as a last story of an epic, or at the end of a project as a final epic or story would be terrible as we would not have logging from the beginning. + elicit: true + examples: + - "Epic 1: Godot Foundation & Core Systems: Project setup, input handling, basic scene management" + - "Epic 2: Core Game Mechanics: Player controller, physics systems, basic gameplay loop" + - "Epic 3: Level Systems & Content Pipeline: Scene loading, prefab systems, level progression" + - "Epic 4: Polish & Platform Optimization: Performance tuning, platform-specific features, deployment" + + - id: epic-details + title: Epic {{epic_number}} {{epic_title}} + repeatable: true + instruction: | + After the epic list is approved, present each epic with all its stories and acceptance criteria as a complete review unit. + + For each epic provide expanded goal (2-3 sentences describing the objective and value all the stories will achieve). + + CRITICAL STORY SEQUENCING REQUIREMENTS: + + - Stories within each epic MUST be logically sequential + - Each story should be a "vertical slice" delivering complete functionality aside from early enabler stories for project foundation + - No story should depend on work from a later story or epic + - Identify and note any direct prerequisite stories + - Focus on "what" and "why" not "how" (leave technical implementation to Architect) yet be precise enough to support a logical sequential order of operations from story to story. + - Ensure each story delivers clear user or business value, try to avoid enablers and build them into stories that deliver value. + - Size stories for AI agent execution: Each story must be completable by a single AI agent in one focused session without context overflow + - Think "junior developer working for 2-4 hours" - stories must be small, focused, and self-contained + - If a story seems complex, break it down further as long as it can deliver a vertical slice + elicit: true + template: "{{epic_goal}}" + sections: + - id: story + title: Story {{epic_number}}.{{story_number}} {{story_title}} + repeatable: true + instruction: Provide a clear, concise description of what this story implements. Focus on the specific game feature or system being built. Reference the GDD section that defines this feature and reference the gamearchitecture section for additional implementation and integration specifics. + template: "{{clear_description_of_what_needs_to_be_implemented}}" + sections: + - id: acceptance-criteria + title: Acceptance Criteria + instruction: Define specific, testable conditions that must be met for the story to be considered complete. Each criterion should be verifiable and directly related to gameplay functionality. + sections: + - id: functional-requirements + title: Functional Requirements + type: checklist + items: + - "{{specific_functional_requirement}}" + - id: technical-requirements + title: Technical Requirements + type: checklist + items: + - Code follows GDScript/C# best practices + - Maintains stable frame rate on target devices + - No memory leaks or performance degradation + - "{{specific_technical_requirement}}" + - id: game-design-requirements + title: Game Design Requirements + type: checklist + items: + - "{{gameplay_requirement_from_gdd}}" + - "{{balance_requirement_if_applicable}}" + - "{{player_experience_requirement}}" + + - id: success-metrics + title: Success Metrics & Quality Assurance + instruction: Define measurable goals for the Godot game development project with specific targets that can be validated through Godot profiling tools. + elicit: true + sections: + - id: technical-metrics + title: Technical Performance Metrics + type: bullet-list + template: | + - **Frame Rate:** Consistent {{fps_target}} FPS with <5% drops below {{min_fps}} + - **Load Times:** Initial load <{{initial_load}}s, level transitions <{{level_load}}s + - **Memory Usage:** Heap memory <{{heap_limit}}MB, texture memory <{{texture_limit}}MB + - **Crash Rate:** <{{crash_threshold}}% across all supported platforms + - **Build Size:** Final build <{{size_limit}}MB for mobile, <{{desktop_limit}}MB for desktop + - **Battery Life:** Mobile gameplay sessions >{{battery_target}} hours on average device + examples: + - "Frame Rate: Consistent 60 FPS with <5% drops below 45 FPS on target hardware" + - "Crash Rate: <0.5% across iOS/Android, <0.1% on desktop platforms" + - id: gameplay-metrics + title: Gameplay & User Engagement Metrics + type: bullet-list + template: | + - **Tutorial Completion:** {{tutorial_rate}}% of players complete basic tutorial + - **Level Progression:** {{progression_rate}}% reach level {{target_level}} within first session + - **Session Duration:** Average session length {{session_target}} minutes + - **Player Retention:** Day 1: {{d1_retention}}%, Day 7: {{d7_retention}}%, Day 30: {{d30_retention}}% + - **Gameplay Completion:** {{completion_rate}}% complete main game content + - **Control Responsiveness:** Input lag <{{input_lag}}ms on all platforms + examples: + - "Tutorial Completion: 85% of players complete movement and basic mechanics tutorial" + - "Session Duration: Average 15-20 minutes per session for mobile, 30-45 minutes for desktop" + - id: platform-specific-metrics + title: Platform-Specific Quality Metrics + type: table + template: | + | Platform | Frame Rate | Load Time | Memory | Build Size | Battery | + | -------- | ---------- | --------- | ------ | ---------- | ------- | + | {{platform}} | {{fps}} | {{load}} | {{memory}} | {{size}} | {{battery}} | + examples: + - iOS, 60 FPS, <3s, <150MB, <80MB, 3+ hours + - Android, 60 FPS, <5s, <200MB, <100MB, 2.5+ hours + + - id: next-steps-integration + title: Next Steps & BMad Integration + instruction: Define how this GDD integrates with BMad's agent workflow and what follow-up documents or processes are needed. + sections: + - id: architecture-handoff + title: Godot Architecture Requirements + instruction: Summary of key architectural decisions that need to be implemented in Godot project setup + type: bullet-list + template: | + - Godot {{godot_version}} project with {{renderer}} renderer + - {{architecture_pattern}} code architecture with {{folder_structure}} + - Required packages: {{essential_packages}} + - Performance targets: {{key_performance_metrics}} + - Platform builds: {{deployment_targets}} + - id: story-creation-guidance + title: Story Creation Guidance for SM Agent + instruction: Provide guidance for the Story Manager (SM) agent on how to break down this GDD into implementable user stories + template: | + **Epic Prioritization:** {{epic_order_rationale}} + + **Story Sizing Guidelines:** + + - Foundation stories: {{foundation_story_scope}} + - Feature stories: {{feature_story_scope}} + - Polish stories: {{polish_story_scope}} + + **Godot-Specific Story Considerations:** + + - Each story should result in testable Godot scenes or PackedScenes + - Include specific Godot nodes and systems in acceptance criteria + - Consider cross-platform testing requirements + - Account for Godot export and deployment steps + examples: + - "Foundation stories: Individual Godot systems (Input, Audio, Scene Management) - 1-2 days each" + - "Feature stories: Complete gameplay mechanics with UI and feedback - 2-4 days each" + - id: recommended-agents + title: Recommended BMad Agent Sequence + type: numbered-list + template: | + 1. **{{agent_name}}**: {{agent_responsibility}} + examples: + - "Godot Architect: Create detailed technical architecture document with specific Godot implementation patterns" + - "Godot Developer: Implement core systems and gameplay mechanics according to architecture" + - "QA Tester: Validate performance metrics and cross-platform functionality" diff --git a/expansion-packs/bmad-2d-godot-game-dev/templates/game-story-tmpl.yaml b/expansion-packs/bmad-2d-godot-game-dev/templates/game-story-tmpl.yaml new file mode 100644 index 00000000..b4b2da3d --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/templates/game-story-tmpl.yaml @@ -0,0 +1,247 @@ +template: + id: game-story-template-v3 + name: Game Development Story + version: 3.0 + output: + format: markdown + filename: "stories/{{epic_name}}/{{story_id}}-{{story_name}}.md" + title: "Story: {{story_title}}" + +workflow: + mode: interactive + +sections: + - id: initial-setup + instruction: | + This template creates detailed game development stories that are immediately actionable by game developers. Each story should focus on a single, implementable feature that contributes to the overall game functionality. + + Before starting, ensure you have access to: + + - Game Design Document (GDD) + - Game Architecture Document + - Any existing stories in this epic + + The story should be specific enough that a developer can implement it without requiring additional design decisions. + + - id: story-header + content: | + **Epic:** {{epic_name}} + **Story ID:** {{story_id}} + **Priority:** {{High|Medium|Low}} + **Points:** {{story_points}} + **Status:** Draft + + - id: description + title: Description + instruction: Provide a clear, concise description of what this story implements. Focus on the specific game feature or system being built. Reference the GDD section that defines this feature. + template: "{{clear_description_of_what_needs_to_be_implemented}}" + + - id: acceptance-criteria + title: Acceptance Criteria + instruction: Define specific, testable conditions that must be met for the story to be considered complete. Each criterion should be verifiable and directly related to gameplay functionality. + sections: + - id: functional-requirements + title: Functional Requirements + type: checklist + items: + - "{{specific_functional_requirement}}" + - id: technical-requirements + title: Technical Requirements + type: checklist + items: + - Code follows GDScript/C# best practices + - Maintains stable frame rate on target devices + - No memory leaks or performance degradation + - "{{specific_technical_requirement}}" + - id: game-design-requirements + title: Game Design Requirements + type: checklist + items: + - "{{gameplay_requirement_from_gdd}}" + - "{{balance_requirement_if_applicable}}" + - "{{player_experience_requirement}}" + + - id: technical-specifications + title: Technical Specifications + instruction: Provide specific technical details that guide implementation. Include class names, file locations, and integration points based on the game architecture. + sections: + - id: files-to-modify + title: Files to Create/Modify + template: | + **New Files:** + + - `{{file_path_1}}` - {{purpose}} + - `{{file_path_2}}` - {{purpose}} + + **Modified Files:** + + - `{{existing_file_1}}` - {{changes_needed}} + - `{{existing_file_2}}` - {{changes_needed}} + - id: class-interface-definitions + title: Class/Interface Definitions + instruction: Define specific GDScript/C# class structures needed + type: code + language: c# + template: | + # {{class_name}} +class_name {{ClassName}} +extends {{NodeType}} + +@export var {{property}}: {{type}} + +func _ready(): + # Implementation requirements + pass + +func {{method1}}({{params}}) -> {{return_type}}: + # Method requirements + pass + - id: integration-points + title: Integration Points + instruction: Specify how this feature integrates with existing systems + template: | + **Scene Integration:** + + - {{scene_name}}: {{integration_details}} + + **Component Dependencies:** + + - {{component_name}}: {{dependency_description}} + + **Event Communication:** + + - Emits: `{{event_name}}` when {{condition}} + - Listens: `{{event_name}}` to {{response}} + + - id: implementation-tasks + title: Implementation Tasks + instruction: Break down the implementation into specific, ordered tasks. Each task should be completable in 1-4 hours. + sections: + - id: dev-agent-record + title: Dev Agent Record + template: | + **Tasks:** + + - [ ] {{task_1_description}} + - [ ] {{task_2_description}} + - [ ] {{task_3_description}} + - [ ] {{task_4_description}} + - [ ] Write unit tests for {{component}} + - [ ] Integration testing with {{related_system}} + - [ ] Performance testing and optimization + + **Debug Log:** + | Task | File | Change | Reverted? | + |------|------|--------|-----------| + | | | | | + + **Completion Notes:** + + + + **Change Log:** + + + + - id: game-design-context + title: Game Design Context + instruction: Reference the specific sections of the GDD that this story implements + template: | + **GDD Reference:** {{section_name}} ({{page_or_section_number}}) + + **Game Mechanic:** {{mechanic_name}} + + **Player Experience Goal:** {{experience_description}} + + **Balance Parameters:** + + - {{parameter_1}}: {{value_or_range}} + - {{parameter_2}}: {{value_or_range}} + + - id: testing-requirements + title: Testing Requirements + instruction: Define specific testing criteria for this game feature + sections: + - id: unit-tests + title: Unit Tests + template: | + **Test Files:** + + - `res://tests/unit/{{component_name}}Tests.gd` + + **Test Scenarios:** + + - {{test_scenario_1}} + - {{test_scenario_2}} + - {{edge_case_test}} + - id: game-testing + title: Game Testing + template: | + **Manual Test Cases:** + + 1. {{test_case_1_description}} + + - Expected: {{expected_behavior}} + - Performance: {{performance_expectation}} + + 2. {{test_case_2_description}} + - Expected: {{expected_behavior}} + - Edge Case: {{edge_case_handling}} + - id: performance-tests + title: Performance Tests + template: | + **Metrics to Verify:** + + - Frame rate maintains stable FPS + - Memory usage stays under {{memory_limit}}MB + - {{feature_specific_performance_metric}} + + - id: dependencies + title: Dependencies + instruction: List any dependencies that must be completed before this story can be implemented + template: | + **Story Dependencies:** + + - {{story_id}}: {{dependency_description}} + + **Technical Dependencies:** + + - {{system_or_file}}: {{requirement}} + + **Asset Dependencies:** + + - {{asset_type}}: {{asset_description}} + - Location: `{{asset_path}}` + + - id: definition-of-done + title: Definition of Done + instruction: Checklist that must be completed before the story is considered finished + type: checklist + items: + - All acceptance criteria met + - Code reviewed and approved + - Unit tests written and passing + - Integration tests passing + - Performance targets met + - No GDScript/C# errors or warnings + - Documentation updated + - "{{game_specific_dod_item}}" + + - id: notes + title: Notes + instruction: Any additional context, design decisions, or implementation notes + template: | + **Implementation Notes:** + + - {{note_1}} + - {{note_2}} + + **Design Decisions:** + + - {{decision_1}}: {{rationale}} + - {{decision_2}}: {{rationale}} + + **Future Considerations:** + + - {{future_enhancement_1}} + - {{future_optimization_1}} diff --git a/expansion-packs/bmad-2d-godot-game-dev/templates/level-design-doc-tmpl.yaml b/expansion-packs/bmad-2d-godot-game-dev/templates/level-design-doc-tmpl.yaml new file mode 100644 index 00000000..2cba1051 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/templates/level-design-doc-tmpl.yaml @@ -0,0 +1,484 @@ +template: + id: level-design-doc-template-v2 + name: Level Design Document + version: 2.1 + output: + format: markdown + filename: docs/level-design-document.md + title: "{{game_title}} Level Design Document" + +workflow: + mode: interactive + +sections: + - id: initial-setup + instruction: | + This template creates comprehensive level design documentation that guides both content creation and technical implementation. This document should provide enough detail for developers to create level loading systems and for designers to create specific levels. + + If available, review: Game Design Document (GDD), Game Architecture Document. This document should align with the game mechanics and technical systems defined in those documents. + + - id: introduction + title: Introduction + instruction: Establish the purpose and scope of level design for this game + content: | + This document defines the level design framework for {{game_title}}, providing guidelines for creating engaging, balanced levels that support the core gameplay mechanics defined in the Game Design Document. + + This framework ensures consistency across all levels while providing flexibility for creative level design within established technical and design constraints. + sections: + - id: change-log + title: Change Log + instruction: Track document versions and changes + type: table + template: | + | Date | Version | Description | Author | + | :--- | :------ | :---------- | :----- | + + - id: level-design-philosophy + title: Level Design Philosophy + instruction: Establish the overall approach to level design based on the game's core pillars and mechanics. Apply `tasks#advanced-elicitation` after presenting this section. + sections: + - id: design-principles + title: Design Principles + instruction: Define 3-5 core principles that guide all level design decisions + type: numbered-list + template: | + **{{principle_name}}** - {{description}} + - id: player-experience-goals + title: Player Experience Goals + instruction: Define what players should feel and learn in each level category + template: | + **Tutorial Levels:** {{experience_description}} + **Standard Levels:** {{experience_description}} + **Challenge Levels:** {{experience_description}} + **Boss Levels:** {{experience_description}} + - id: level-flow-framework + title: Level Flow Framework + instruction: Define the standard structure for level progression + template: | + **Introduction Phase:** {{duration}} - {{purpose}} + **Development Phase:** {{duration}} - {{purpose}} + **Climax Phase:** {{duration}} - {{purpose}} + **Resolution Phase:** {{duration}} - {{purpose}} + + - id: level-categories + title: Level Categories + instruction: Define different types of levels based on the GDD requirements. Each category should be specific enough for implementation. + repeatable: true + sections: + - id: level-category + title: "{{category_name}} Levels" + template: | + **Purpose:** {{gameplay_purpose}} + + **Target Duration:** {{min_time}} - {{max_time}} minutes + + **Difficulty Range:** {{difficulty_scale}} + + **Key Mechanics Featured:** + + - {{mechanic_1}} - {{usage_description}} + - {{mechanic_2}} - {{usage_description}} + + **Player Objectives:** + + - Primary: {{primary_objective}} + - Secondary: {{secondary_objective}} + - Hidden: {{secret_objective}} + + **Success Criteria:** + + - {{completion_requirement_1}} + - {{completion_requirement_2}} + + **Technical Requirements:** + + - Maximum entities: {{entity_limit}} + - Performance target: {{fps_target}} FPS + - Memory budget: {{memory_limit}}MB + - Asset requirements: {{asset_needs}} + + - id: level-progression-system + title: Level Progression System + instruction: Define how players move through levels and how difficulty scales + sections: + - id: world-structure + title: World Structure + instruction: Based on GDD requirements, define the overall level organization + template: | + **Organization Type:** {{linear|hub_world|open_world}} + + **Total Level Count:** {{number}} + + **World Breakdown:** + + - World 1: {{level_count}} levels - {{theme}} - {{difficulty_range}} + - World 2: {{level_count}} levels - {{theme}} - {{difficulty_range}} + - World 3: {{level_count}} levels - {{theme}} - {{difficulty_range}} + - id: difficulty-progression + title: Difficulty Progression + instruction: Define how challenge increases across the game + sections: + - id: progression-curve + title: Progression Curve + type: code + language: text + template: | + Difficulty + ^ ___/``` + | / + | / ___/``` + | / / + | / / + |/ / + +-----------> Level Number + Tutorial Early Mid Late + - id: scaling-parameters + title: Scaling Parameters + type: bullet-list + template: | + - Enemy count: {{start_count}} → {{end_count}} + - Enemy difficulty: {{start_diff}} → {{end_diff}} + - Level complexity: {{start_complex}} → {{end_complex}} + - Time pressure: {{start_time}} → {{end_time}} + - id: unlock-requirements + title: Unlock Requirements + instruction: Define how players access new levels + template: | + **Progression Gates:** + + - Linear progression: Complete previous level + - Star requirements: {{star_count}} stars to unlock + - Skill gates: Demonstrate {{skill_requirement}} + - Optional content: {{unlock_condition}} + + - id: level-design-components + title: Level Design Components + instruction: Define the building blocks used to create levels + sections: + - id: environmental-elements + title: Environmental Elements + instruction: Define all environmental components that can be used in levels + template: | + **Terrain Types:** + + - {{terrain_1}}: {{properties_and_usage}} + - {{terrain_2}}: {{properties_and_usage}} + + **Interactive Objects:** + + - {{object_1}}: {{behavior_and_purpose}} + - {{object_2}}: {{behavior_and_purpose}} + + **Hazards and Obstacles:** + + - {{hazard_1}}: {{damage_and_behavior}} + - {{hazard_2}}: {{damage_and_behavior}} + - id: collectibles-rewards + title: Collectibles and Rewards + instruction: Define all collectible items and their placement rules + template: | + **Collectible Types:** + + - {{collectible_1}}: {{value_and_purpose}} + - {{collectible_2}}: {{value_and_purpose}} + + **Placement Guidelines:** + + - Mandatory collectibles: {{placement_rules}} + - Optional collectibles: {{placement_rules}} + - Secret collectibles: {{placement_rules}} + + **Reward Distribution:** + + - Easy to find: {{percentage}}% + - Moderate challenge: {{percentage}}% + - High skill required: {{percentage}}% + - id: enemy-placement-framework + title: Enemy Placement Framework + instruction: Define how enemies should be placed and balanced in levels + template: | + **Enemy Categories:** + + - {{enemy_type_1}}: {{behavior_and_usage}} + - {{enemy_type_2}}: {{behavior_and_usage}} + + **Placement Principles:** + + - Introduction encounters: {{guideline}} + - Standard encounters: {{guideline}} + - Challenge encounters: {{guideline}} + + **Difficulty Scaling:** + + - Enemy count progression: {{scaling_rule}} + - Enemy type introduction: {{pacing_rule}} + - Encounter complexity: {{complexity_rule}} + + - id: level-creation-guidelines + title: Level Creation Guidelines + instruction: Provide specific guidelines for creating individual levels + sections: + - id: level-layout-principles + title: Level Layout Principles + template: | + **Spatial Design:** + + - Grid size: {{grid_dimensions}} + - Minimum path width: {{width_units}} + - Maximum vertical distance: {{height_units}} + - Safe zones placement: {{safety_guidelines}} + + **Navigation Design:** + + - Clear path indication: {{visual_cues}} + - Landmark placement: {{landmark_rules}} + - Dead end avoidance: {{dead_end_policy}} + - Multiple path options: {{branching_rules}} + - id: pacing-and-flow + title: Pacing and Flow + instruction: Define how to control the rhythm and pace of gameplay within levels + template: | + **Action Sequences:** + + - High intensity duration: {{max_duration}} + - Rest period requirement: {{min_rest_time}} + - Intensity variation: {{pacing_pattern}} + + **Learning Sequences:** + + - New mechanic introduction: {{teaching_method}} + - Practice opportunity: {{practice_duration}} + - Skill application: {{application_context}} + - id: challenge-design + title: Challenge Design + instruction: Define how to create appropriate challenges for each level type + template: | + **Challenge Types:** + + - Execution challenges: {{skill_requirements}} + - Puzzle challenges: {{complexity_guidelines}} + - Time challenges: {{time_pressure_rules}} + - Resource challenges: {{resource_management}} + + **Difficulty Calibration:** + + - Skill check frequency: {{frequency_guidelines}} + - Failure recovery: {{retry_mechanics}} + - Hint system integration: {{help_system}} + + - id: technical-implementation + title: Technical Implementation + instruction: Define technical requirements for level implementation + sections: + - id: level-data-structure + title: Level Data Structure + instruction: Define how level data should be structured for implementation + template: | + **Level File Format:** + + - Data format: {{json|yaml|custom}} + - File naming: `level_{{world}}_{{number}}.{{extension}}` + - Data organization: {{structure_description}} + sections: + - id: required-data-fields + title: Required Data Fields + type: code + language: json + template: | + { + "levelId": "{{unique_identifier}}", + "worldId": "{{world_identifier}}", + "difficulty": {{difficulty_value}}, + "targetTime": {{completion_time_seconds}}, + "objectives": { + "primary": "{{primary_objective}}", + "secondary": ["{{secondary_objectives}}"], + "hidden": ["{{secret_objectives}}"] + }, + "layout": { + "width": {{grid_width}}, + "height": {{grid_height}}, + "tilemap": "{{tilemap_reference}}" + }, + "entities": [ + { + "type": "{{entity_type}}", + "position": {"x": {{x}}, "y": {{y}}}, + "properties": {{entity_properties}} + } + ] + } + - id: asset-integration + title: Asset Integration + instruction: Define how level assets are organized and loaded + template: | + **Tilemap Requirements:** + + - Tile size: {{tile_dimensions}}px + - Tileset organization: {{tileset_structure}} + - Layer organization: {{layer_system}} + - Collision data: {{collision_format}} + + **Audio Integration:** + + - Background music: {{music_requirements}} + - Ambient sounds: {{ambient_system}} + - Dynamic audio: {{dynamic_audio_rules}} + - id: performance-optimization + title: Performance Optimization + instruction: Define performance requirements for level systems + template: | + **Entity Limits:** + + - Maximum active entities: {{entity_limit}} + - Maximum particles: {{particle_limit}} + - Maximum audio sources: {{audio_limit}} + + **Memory Management:** + + - Texture memory budget: {{texture_memory}}MB + - Audio memory budget: {{audio_memory}}MB + - Level loading time: <{{load_time}}s + + **Culling and LOD:** + + - Off-screen culling: {{culling_distance}} + - Level-of-detail rules: {{lod_system}} + - Asset streaming: {{streaming_requirements}} + + - id: level-testing-framework + title: Level Testing Framework + instruction: Define how levels should be tested and validated + sections: + - id: automated-testing + title: Automated Testing + template: | + **Performance Testing:** + + - Frame rate validation: Maintain {{fps_target}} FPS + - Memory usage monitoring: Stay under {{memory_limit}}MB + - Loading time verification: Complete in <{{load_time}}s + + **Gameplay Testing:** + + - Completion path validation: All objectives achievable + - Collectible accessibility: All items reachable + - Softlock prevention: No unwinnable states + - id: manual-testing-protocol + title: Manual Testing Protocol + sections: + - id: playtesting-checklist + title: Playtesting Checklist + type: checklist + items: + - Level completes within target time range + - All mechanics function correctly + - Difficulty feels appropriate for level category + - Player guidance is clear and effective + - No exploits or sequence breaks (unless intended) + - id: player-experience-testing + title: Player Experience Testing + type: checklist + items: + - Tutorial levels teach effectively + - Challenge feels fair and rewarding + - Flow and pacing maintain engagement + - Audio and visual feedback support gameplay + - id: balance-validation + title: Balance Validation + template: | + **Metrics Collection:** + + - Completion rate: Target {{completion_percentage}}% + - Average completion time: {{target_time}} ± {{variance}} + - Death count per level: <{{max_deaths}} + - Collectible discovery rate: {{discovery_percentage}}% + + **Iteration Guidelines:** + + - Adjustment criteria: {{criteria_for_changes}} + - Testing sample size: {{minimum_testers}} + - Validation period: {{testing_duration}} + + - id: content-creation-pipeline + title: Content Creation Pipeline + instruction: Define the workflow for creating new levels + sections: + - id: design-phase + title: Design Phase + template: | + **Concept Development:** + + 1. Define level purpose and goals + 2. Create rough layout sketch + 3. Identify key mechanics and challenges + 4. Estimate difficulty and duration + + **Documentation Requirements:** + + - Level design brief + - Layout diagrams + - Mechanic integration notes + - Asset requirement list + - id: implementation-phase + title: Implementation Phase + template: | + **Technical Implementation:** + + 1. Create level data file + 2. Build tilemap and layout + 3. Place entities and objects + 4. Configure level logic and triggers + 5. Integrate audio and visual effects + + **Quality Assurance:** + + 1. Automated testing execution + 2. Internal playtesting + 3. Performance validation + 4. Bug fixing and polish + - id: integration-phase + title: Integration Phase + template: | + **Game Integration:** + + 1. Level progression integration + 2. Save system compatibility + 3. Analytics integration + 4. Achievement system integration + + **Final Validation:** + + 1. Full game context testing + 2. Performance regression testing + 3. Platform compatibility verification + 4. Final approval and release + + - id: success-metrics + title: Success Metrics + instruction: Define how to measure level design success + sections: + - id: player-engagement + title: Player Engagement + type: bullet-list + template: | + - Level completion rate: {{target_rate}}% + - Replay rate: {{replay_target}}% + - Time spent per level: {{engagement_time}} + - Player satisfaction scores: {{satisfaction_target}}/10 + - id: technical-performance + title: Technical Performance + type: bullet-list + template: | + - Frame rate consistency: {{fps_consistency}}% + - Loading time compliance: {{load_compliance}}% + - Memory usage efficiency: {{memory_efficiency}}% + - Crash rate: <{{crash_threshold}}% + - id: design-quality + title: Design Quality + type: bullet-list + template: | + - Difficulty curve adherence: {{curve_accuracy}} + - Mechanic integration effectiveness: {{integration_score}} + - Player guidance clarity: {{guidance_score}} + - Content accessibility: {{accessibility_rate}}% diff --git a/expansion-packs/bmad-2d-godot-game-dev/workflows/game-dev-greenfield.yaml b/expansion-packs/bmad-2d-godot-game-dev/workflows/game-dev-greenfield.yaml new file mode 100644 index 00000000..a76a3606 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/workflows/game-dev-greenfield.yaml @@ -0,0 +1,183 @@ +workflow: + id: godot-game-dev-greenfield + name: Game Development - Greenfield Project (Godot) + description: Specialized workflow for creating 2D games from concept to implementation using Godot and GDScript/C#. Guides teams through game concept development, design documentation, technical architecture, and story-driven development for professional game development. + type: greenfield + project_types: + - indie-game + - mobile-game + - web-game + - educational-game + - prototype-game + - game-jam + full_game_sequence: + - agent: game-designer + creates: game-brief.md + optional_steps: + - brainstorming_session + - game_research_prompt + - player_research + notes: "Start with brainstorming game concepts, then create comprehensive game brief. SAVE OUTPUT: Copy final game-brief.md to your project's docs/design/ folder." + - agent: game-designer + creates: game-design-doc.md + requires: game-brief.md + optional_steps: + - competitive_analysis + - technical_research + notes: "Create detailed Game Design Document using game-design-doc-tmpl. Defines all gameplay mechanics, progression, and technical requirements. SAVE OUTPUT: Copy final game-design-doc.md to your project's docs/design/ folder." + - agent: game-designer + creates: level-design-doc.md + requires: game-design-doc.md + optional_steps: + - level_prototyping + - difficulty_analysis + notes: "Create level design framework using level-design-doc-tmpl. Establishes content creation guidelines and performance requirements. SAVE OUTPUT: Copy final level-design-doc.md to your project's docs/design/ folder." + - agent: solution-architect + creates: game-architecture.md + requires: + - game-design-doc.md + - level-design-doc.md + optional_steps: + - technical_research_prompt + - performance_analysis + - platform_research + notes: "Create comprehensive technical architecture using game-architecture-tmpl. Defines Godot systems, performance optimization, and code structure. SAVE OUTPUT: Copy final game-architecture.md to your project's docs/architecture/ folder." + - agent: game-designer + validates: design_consistency + requires: all_design_documents + uses: game-design-checklist + notes: Validate all design documents for consistency, completeness, and implementability. May require updates to any design document. + - agent: various + updates: flagged_design_documents + condition: design_validation_issues + notes: If design validation finds issues, return to relevant agent to fix and re-export updated documents to docs/ folder. + project_setup_guidance: + action: guide_game_project_structure + notes: Set up Godot project structure following game architecture document. Create res:// with subdirectories for scenes, scripts, etc. + workflow_end: + action: move_to_story_development + notes: All design artifacts complete. Begin story-driven development phase. Use Game Scrum Master to create implementation stories from design documents. + prototype_sequence: + - step: prototype_scope + action: assess_prototype_complexity + notes: First, assess if this needs full game design (use full_game_sequence) or can be a rapid prototype. + - agent: game-designer + creates: game-brief.md + optional_steps: + - quick_brainstorming + - concept_validation + notes: "Create focused game brief for prototype. Emphasize core mechanics and immediate playability. SAVE OUTPUT: Copy final game-brief.md to your project's docs/ folder." + - agent: game-designer + creates: prototype-design.md + uses: create-doc prototype-design OR create-game-story + requires: game-brief.md + notes: Create minimal design document or jump directly to implementation stories for rapid prototyping. Choose based on prototype complexity. + prototype_workflow_end: + action: move_to_rapid_implementation + notes: Prototype defined. Begin immediate implementation with Game Developer. Focus on core mechanics first, then iterate based on playtesting. + flow_diagram: | + ```mermaid + graph TD + A[Start: Game Development Project] --> B{Project Scope?} + B -->|Full Game/Production| C[game-designer: game-brief.md] + B -->|Prototype/Game Jam| D[game-designer: focused game-brief.md] + + C --> E[game-designer: game-design-doc.md] + E --> F[game-designer: level-design-doc.md] + F --> G[solution-architect: game-architecture.md] + G --> H[game-designer: validate design consistency] + H --> I{Design validation issues?} + I -->|Yes| J[Return to relevant agent for fixes] + I -->|No| K[Set up game project structure] + J --> H + K --> L[Move to Story Development Phase] + + D --> M[game-designer: prototype-design.md] + M --> N[Move to Rapid Implementation] + + C -.-> C1[Optional: brainstorming] + C -.-> C2[Optional: game research] + E -.-> E1[Optional: competitive analysis] + F -.-> F1[Optional: level prototyping] + G -.-> G1[Optional: technical research] + D -.-> D1[Optional: quick brainstorming] + + style L fill:#90EE90 + style N fill:#90EE90 + style C fill:#FFE4B5 + style E fill:#FFE4B5 + style F fill:#FFE4B5 + style G fill:#FFE4B5 + style D fill:#FFB6C1 + style M fill:#FFB6C1 + ``` + decision_guidance: + use_full_sequence_when: + - Building commercial or production games + - Multiple team members involved + - Complex gameplay systems (3+ core mechanics) + - Long-term development timeline (2+ months) + - Need comprehensive documentation for team coordination + - Targeting multiple platforms + - Educational or enterprise game projects + use_prototype_sequence_when: + - Game jams or time-constrained development + - Solo developer or very small team + - Experimental or proof-of-concept games + - Simple mechanics (1-2 core systems) + - Quick validation of game concepts + - Learning projects or technical demos + handoff_prompts: + designer_to_gdd: Game brief is complete. Save it as docs/design/game-brief.md in your project, then create the comprehensive Game Design Document. + gdd_to_level: Game Design Document ready. Save it as docs/design/game-design-doc.md, then create the level design framework. + level_to_architect: Level design complete. Save it as docs/design/level-design-doc.md, then create the technical architecture. + architect_review: Architecture complete. Save it as docs/architecture/game-architecture.md. Please validate all design documents for consistency. + validation_issues: Design validation found issues with [document]. Please return to [agent] to fix and re-save the updated document. + full_complete: All design artifacts validated and saved. Set up game project structure and move to story development phase. + prototype_designer_to_dev: Prototype brief complete. Save it as docs/game-brief.md, then create minimal design or jump directly to implementation stories. + prototype_complete: Prototype defined. Begin rapid implementation focusing on core mechanics and immediate playability. + story_development_guidance: + epic_breakdown: + - Core Game Systems" - Fundamental gameplay mechanics and player controls + - Level Content" - Individual levels, progression, and content implementation + - User Interface" - Menus, HUD, settings, and player feedback systems + - Audio Integration" - Music, sound effects, and AudioBus systems + - Performance Optimization" - Platform optimization and technical polish + - Game Polish" - Visual effects, animations, and final user experience + story_creation_process: + - Use Game Scrum Master to create detailed implementation stories + - Each story should reference specific GDD sections + - Include performance requirements (stable frame rate) + - Specify Godot implementation details (nodes, PackedScenes, scenes) + - Apply game-story-dod-checklist for quality validation + - Ensure stories are immediately actionable by Game Developer + game_development_best_practices: + performance_targets: + - Maintain stable frame rate on target devices throughout development + - Memory usage under specified limits per game system + - Loading times under 3 seconds for levels + - Smooth animation and responsive player controls + technical_standards: + - GDScript/C# best practices compliance + - Node-based game architecture + - Object pooling for performance-critical objects + - Cross-platform input handling with Godot Input system + - Comprehensive error handling and graceful degradation + playtesting_integration: + - Test core mechanics early and frequently + - Validate game balance through metrics and player feedback + - Iterate on design based on implementation discoveries + - Document design changes and rationale + success_criteria: + design_phase_complete: + - All design documents created and validated + - Technical architecture aligns with game design requirements + - Performance targets defined and achievable + - Story breakdown ready for implementation + - Project structure established + implementation_readiness: + - Development environment configured for Godot + GDScript/C# + - Asset pipeline and build system established + - Testing framework in place + - Team roles and responsibilities defined + - First implementation stories created and ready diff --git a/expansion-packs/bmad-2d-godot-game-dev/workflows/game-prototype.yaml b/expansion-packs/bmad-2d-godot-game-dev/workflows/game-prototype.yaml new file mode 100644 index 00000000..8ef833d6 --- /dev/null +++ b/expansion-packs/bmad-2d-godot-game-dev/workflows/game-prototype.yaml @@ -0,0 +1,175 @@ +workflow: + id: godot-game-prototype + name: Game Prototype Development (Godot) + description: Fast-track workflow for rapid game prototyping and concept validation. Optimized for game jams, proof-of-concept development, and quick iteration on game mechanics using Godot and GDScript/C#. + type: prototype + project_types: + - game-jam + - proof-of-concept + - mechanic-test + - technical-demo + - learning-project + - rapid-iteration + prototype_sequence: + - step: concept_definition + agent: game-designer + duration: 15-30 minutes + creates: concept-summary.md + notes: Quickly define core game concept, primary mechanic, and target experience. Focus on what makes this game unique and fun. + - step: rapid_design + agent: game-designer + duration: 30-60 minutes + creates: prototype-spec.md + requires: concept-summary.md + optional_steps: + - quick_brainstorming + - reference_research + notes: Create minimal but complete design specification. Focus on core mechanics, basic controls, and success/failure conditions. + - step: technical_planning + agent: game-developer + duration: 15-30 minutes + creates: prototype-architecture.md + requires: prototype-spec.md + notes: Define minimal technical implementation plan. Identify core Godot systems needed and performance constraints. + - step: implementation_stories + agent: game-sm + duration: 30-45 minutes + creates: prototype-stories/ + requires: prototype-spec.md, prototype-architecture.md + notes: Create 3-5 focused implementation stories for core prototype features. Each story should be completable in 2-4 hours. + - step: iterative_development + agent: game-developer + duration: varies + implements: prototype-stories/ + notes: Implement stories in priority order. Test frequently in the Godot Editor and adjust design based on what feels fun. Document discoveries. + workflow_end: + action: prototype_evaluation + notes: "Prototype complete. Evaluate core mechanics, gather feedback, and decide next steps: iterate, expand, or archive." + game_jam_sequence: + - step: jam_concept + agent: game-designer + duration: 10-15 minutes + creates: jam-concept.md + notes: Define game concept based on jam theme. One sentence core mechanic, basic controls, win condition. + - step: jam_implementation + agent: game-developer + duration: varies (jam timeline) + creates: working-prototype + requires: jam-concept.md + notes: Directly implement core mechanic in Godot. No formal stories - iterate rapidly on what's fun. Document major decisions. + jam_workflow_end: + action: jam_submission + notes: Submit to game jam. Capture lessons learned and consider post-jam development if concept shows promise. + flow_diagram: | + ```mermaid + graph TD + A[Start: Prototype Project] --> B{Development Context?} + B -->|Standard Prototype| C[game-designer: concept-summary.md] + B -->|Game Jam| D[game-designer: jam-concept.md] + + C --> E[game-designer: prototype-spec.md] + E --> F[game-developer: prototype-architecture.md] + F --> G[game-sm: create prototype stories] + G --> H[game-developer: iterative implementation] + H --> I[Prototype Evaluation] + + D --> J[game-developer: direct implementation] + J --> K[Game Jam Submission] + + E -.-> E1[Optional: quick brainstorming] + E -.-> E2[Optional: reference research] + + style I fill:#90EE90 + style K fill:#90EE90 + style C fill:#FFE4B5 + style E fill:#FFE4B5 + style F fill:#FFE4B5 + style G fill:#FFE4B5 + style H fill:#FFE4B5 + style D fill:#FFB6C1 + style J fill:#FFB6C1 + ``` + decision_guidance: + use_prototype_sequence_when: + - Learning new game development concepts + - Testing specific game mechanics + - Building portfolio pieces + - Have 1-7 days for development + - Need structured but fast development + - Want to validate game concepts before full development + use_game_jam_sequence_when: + - Participating in time-constrained game jams + - Have 24-72 hours total development time + - Want to experiment with wild or unusual concepts + - Learning through rapid iteration + - Building networking/portfolio presence + prototype_best_practices: + scope_management: + - Start with absolute minimum viable gameplay + - One core mechanic implemented well beats many mechanics poorly + - Focus on "game feel" over features + - Cut features ruthlessly to meet timeline + rapid_iteration: + - Test the game every 1-2 hours of development in the Godot Editor + - Ask "Is this fun?" frequently during development + - Be willing to pivot mechanics if they don't feel good + - Document what works and what doesn't + technical_efficiency: + - Use simple graphics (geometric shapes, basic sprites) + - Leverage Godot's built-in nodes heavily + - Avoid complex custom systems in prototypes + - Prioritize functional over polished + prototype_evaluation_criteria: + core_mechanic_validation: + - Is the primary mechanic engaging for 30+ seconds? + - Do players understand the mechanic without explanation? + - Does the mechanic have depth for extended play? + - Are there natural difficulty progression opportunities? + technical_feasibility: + - Does the prototype run at acceptable frame rates? + - Are there obvious technical blockers for expansion? + - Is the codebase clean enough for further development? + - Are performance targets realistic for full game? + player_experience: + - Do testers engage with the game voluntarily? + - What emotions does the game create in players? + - Are players asking for "just one more try"? + - What do players want to see added or changed? + post_prototype_options: + iterate_and_improve: + action: continue_prototyping + when: Core mechanic shows promise but needs refinement + next_steps: Create new prototype iteration focusing on identified improvements + expand_to_full_game: + action: transition_to_full_development + when: Prototype validates strong game concept + next_steps: Use game-dev-greenfield workflow to create full game design and architecture + pivot_concept: + action: new_prototype_direction + when: Current mechanic doesn't work but insights suggest new direction + next_steps: Apply learnings to new prototype concept + archive_and_learn: + action: document_learnings + when: Prototype doesn't work but provides valuable insights + next_steps: Document lessons learned and move to next prototype concept + time_boxing_guidance: + concept_phase: Maximum 30 minutes - if you can't explain the game simply, simplify it + design_phase: Maximum 1 hour - focus on core mechanics only + planning_phase: Maximum 30 minutes - identify critical path to playable prototype + implementation_phase: Time-boxed iterations - test every 2-4 hours of work + success_metrics: + development_velocity: + - Playable prototype in first day of development + - Core mechanic demonstrable within 4-6 hours of coding + - Major iteration cycles completed in 2-4 hour blocks + learning_objectives: + - Clear understanding of what makes the mechanic fun (or not) + - Technical feasibility assessment for full development + - Player reaction and engagement validation + - Design insights for future development + handoff_prompts: + concept_to_design: Game concept defined. Create minimal design specification focusing on core mechanics and player experience. + design_to_technical: Design specification ready. Create technical implementation plan for rapid prototyping. + technical_to_stories: Technical plan complete. Create focused implementation stories for prototype development. + stories_to_implementation: Stories ready. Begin iterative implementation with frequent playtesting and design validation. + prototype_to_evaluation: Prototype playable. Evaluate core mechanics, gather feedback, and determine next development steps.