ldy26098
/
BMAD-METHOD
mirror of https://github.com/bmad-code-org/BMAD-METHOD.git
1
0
Fork 0
Code Packages Projects Releases Wiki Activity

Adding godot game development expansion pack

This commit is contained in:
Scott Jennings 2025-08-17 11:08:43 -05:00
parent 868ae23455
commit 5ff0ff5784
24 changed files with 6682 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
expansion-packs/bmad-2d-godot-game-dev/agent-teams/godot-2d-game-team.yaml Normal file
View File

@ -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

80
expansion-packs/bmad-2d-godot-game-dev/agents/game-architect.md Normal file
View File

@ -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
```

77
expansion-packs/bmad-2d-godot-game-dev/agents/game-designer.md Normal file
View File

@ -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
```

78
expansion-packs/bmad-2d-godot-game-dev/agents/game-developer.md Normal file
View File

@ -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
```

65
expansion-packs/bmad-2d-godot-game-dev/agents/game-sm.md Normal file
View File

@ -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
```

399
expansion-packs/bmad-2d-godot-game-dev/checklists/game-architect-checklist.md Normal file
View File

@ -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.]]

203
expansion-packs/bmad-2d-godot-game-dev/checklists/game-change-checklist.md Normal file
View File

@ -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.
---

201
expansion-packs/bmad-2d-godot-game-dev/checklists/game-design-checklist.md Normal file
View File

@ -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._

124
expansion-packs/bmad-2d-godot-game-dev/checklists/game-story-dod-checklist.md Normal file
View File

@ -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.

6
expansion-packs/bmad-2d-godot-game-dev/config.yaml Normal file
View File

@ -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

769
expansion-packs/bmad-2d-godot-game-dev/data/bmad-kb.md Normal file
View File

@ -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#.

565
expansion-packs/bmad-2d-godot-game-dev/data/development-guidelines.md Normal file
View File

@ -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.

110
expansion-packs/bmad-2d-godot-game-dev/tasks/advanced-elicitation.md Normal file
View File

@ -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

141
expansion-packs/bmad-2d-godot-game-dev/tasks/correct-course-game.md Normal file
View File

@ -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

184
expansion-packs/bmad-2d-godot-game-dev/tasks/create-game-story.md Normal file
View File

@ -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.

290
expansion-packs/bmad-2d-godot-game-dev/tasks/game-design-brainstorming.md Normal file
View File

@ -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

200
expansion-packs/bmad-2d-godot-game-dev/tasks/validate-game-story.md Normal file
View File

@ -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

1027
expansion-packs/bmad-2d-godot-game-dev/templates/game-architecture-tmpl.yaml Normal file
View File

File diff suppressed because it is too large Load Diff

356
expansion-packs/bmad-2d-godot-game-dev/templates/game-brief-tmpl.yaml Normal file
View File

@ -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 |
| :--- | :------ | :---------- | :----- |

704
expansion-packs/bmad-2d-godot-game-dev/templates/game-design-doc-tmpl.yaml Normal file
View File

@ -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, <Move>/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"

247
expansion-packs/bmad-2d-godot-game-dev/templates/game-story-tmpl.yaml Normal file
View File

@ -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:**
<!-- Only note deviations from requirements, keep under 50 words -->
**Change Log:**
<!-- Only requirement changes during implementation -->
- 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}}

484
expansion-packs/bmad-2d-godot-game-dev/templates/level-design-doc-tmpl.yaml Normal file
View File

@ -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}}%

183
expansion-packs/bmad-2d-godot-game-dev/workflows/game-dev-greenfield.yaml Normal file
View File

@ -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

175
expansion-packs/bmad-2d-godot-game-dev/workflows/game-prototype.yaml Normal file
View File

@ -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.