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

feat: Updated last agent to new format and updated bmad-kb. bmad-kb I did my best with but im not sure of it's valid usage in the expansion pack, the AI generated more of the file then myself. I made sure to include it due to the new core-config file

This commit is contained in:
pbean 2025-07-21 23:11:31 -07:00
parent 0d20ad0000
commit 3c8cbc8c83
3 changed files with 791 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
expansion-packs/bmad-2d-unity-game-dev/agents/game-designer.md
View File

@ -39,23 +39,24 @@ persona:
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 user selections
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'
- '*exit" - Say goodbye as the Game Designer, and then abandon inhabiting this persona'
- 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
- exit: Say goodbye as the Game Designer, and then abandon inhabiting this persona
dependencies:
tasks:
- create-doc.md

641
expansion-packs/bmad-2d-unity-game-dev/data/bmad-kb.md
View File

@ -1,85 +1,474 @@
# Game Development BMad Knowledge Base
# BMad Knowledge Base - 2D Unity Game Development
## Overview
This game development expansion of BMad-Method specializes in creating 2D games using Unity and C#. It extends the core BMad framework with game-specific agents, workflows, and best practices for professional game development.
This is the game development expansion of BMad-Method (Breakthrough Method of Agile AI-driven Development), specializing in creating 2D games using Unity and 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)
- **Unity-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 Unity games
- **Performance-First Approach**: Built-in optimization patterns for cross-platform game deployment
### Game Development Focus
- **Target Engine**: Unity 2022 LTS or newer with C# 10+
- **Platform Strategy**: Cross-platform (PC, Console, Mobile) with a focus on 2D
- **Development Approach**: Agile story-driven development
- **Development Approach**: Agile story-driven development with game-specific workflows
- **Performance Target**: Stable frame rate on target devices
- **Architecture**: Component-based architecture using Unity's best practices
## Core Game Development Philosophy
### When to Use BMad for Game Development
### Player-First 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
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. Your AI agents are your specialized game development team:
## How BMad Works for Game Development
- **Direct**: Provide clear game design vision and player experience goals
- **Refine**: Iterate on gameplay mechanics until they're compelling
- **Oversee**: Maintain creative alignment across all development disciplines
- **Playfocus**: Every decision serves the player experience
### The Core Method
### Game Development Principles
BMad transforms you into a "Player Experience CEO" - directing a team of specialized game development AI agents through structured workflows. Here's how:
1. **PLAYER_EXPERIENCE_FIRST**: Every mechanic must serve player engagement and fun
2. **ITERATIVE_DESIGN**: Prototype, test, refine - games are discovered through iteration
3. **TECHNICAL_EXCELLENCE**: Stable performance and cross-platform compatibility are non-negotiable
4. **STORY_DRIVEN_DEV**: Game features are implemented through detailed development stories
5. **BALANCE_THROUGH_DATA**: Use metrics and playtesting to validate game balance
6. **DOCUMENT_EVERYTHING**: Clear specifications enable proper game implementation
7. **START_SMALL_ITERATE_FAST**: Core mechanics first, then expand and polish
8. **EMBRACE_CREATIVE_CHAOS**: Games evolve - adapt design based on what's fun
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 Unity game
4. **Clean Handoffs**: Fresh context windows ensure agents stay focused and effective for game development
## Game Development Workflow
### The Two-Phase Game Development Approach
### Phase 1: Game Concept and Design
#### Phase 1: Game Design & Planning (Web UI - Cost Effective)
1. **Game Designer**: Start with brainstorming and concept development
- 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
- Use \*brainstorm to explore game concepts and mechanics
- Create Game Brief using game-brief-tmpl
- Develop core game pillars and player experience goals
#### Phase 2: Game Development (IDE - Implementation)
2. **Game Designer**: Create comprehensive Game Design Document
- 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 Unity operations, C# coding, and game testing
- Use game-design-doc-tmpl to create detailed GDD
- Define all game mechanics, progression, and balance
- Specify technical requirements and platform targets
### The Game Development Loop
3. **Game Designer**: Develop Level Design Framework
- Create level-design-doc-tmpl for content guidelines
- Define level types, difficulty progression, and content structure
- Establish performance and technical constraints for levels
```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 Unity
4. QA Agent (New Chat) → Reviews code and tests gameplay
5. You → Verify game feature completion
6. Repeat until game epic complete
```
### Phase 2: Technical Architecture
### Why This Works for Games
4. **Solution Architect** (or Game Designer): Create Technical Architecture
- Use game-architecture-tmpl to design technical implementation
- Define Unity systems, performance optimization, and C# code structure
- Align technical architecture with game design requirements
- **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
### Phase 3: Story-Driven Development
### Core Game Development Philosophy
5. **Game Scrum Master**: Break down design into development stories
#### Player-First Development
- Use create-game-story task to create detailed implementation stories
- Each story should be immediately actionable by game developers
- Apply game-story-dod-checklist to ensure story quality
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.
6. **Game Developer**: Implement game features story by story
#### Game Development Principles
- Follow C# best practices and Unity's component-based architecture
- Maintain stable frame rate on target devices
- Use Unity Test Framework for game logic components
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.
7. **Iterative Refinement**: Continuous playtesting and improvement
- Test core mechanics early and often in the Unity Editor
- Validate game balance through metrics and player feedback
- Iterate on design based on implementation discoveries
## 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 `unity-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**: Unity developers using Cursor, Claude Code, Windsurf, Trae, Cline, Roo Code, Github Copilot
```bash
# Interactive installation (recommended)
npx bmad-method install
# Select the bmad-2d-unity-game-dev expansion pack when prompted
```
**Installation Steps for Game Development**:
- Choose "Install expansion pack" when prompted
- Select "bmad-2d-unity-game-dev" from the list
- Select your IDE from supported options:
- **Cursor**: Native AI integration with Unity 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-unity-game-dev/` folder with game development agents
- IDE-specific integration files created
- Game development agents available with `/bmad2du` 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**:
- Unity project development and C# coding
- Game asset operations and project integration
- Game story management and implementation workflow
- Unity 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 Unity 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 Unity deployment
- Direct Unity project operations from start
- No copy/paste between environments
- Immediate Unity 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 Unity implementation** - Never use bmad-master or bmad-orchestrator
- **Why this matters**: Game SM and Game Dev agents are specifically optimized for Unity 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 `bmad-core/core-config.yaml` file enables BMad to work seamlessly with any Unity project structure, providing maximum flexibility for game development.
### Game Development Configuration
The expansion pack follows the standard BMad configuration patterns. Game-specific configurations would be added to your project's `core-config.yaml`:
```yaml
# Standard BMad configurations apply
prdVersion: v4
prdSharded: true
architectureVersion: v4
architectureSharded: true
# Game-specific document locations
gameDesignDocLocation: docs/game-design-doc.md
gameBriefDocLocation: docs/game-brief.md
gameArchitectureLocation: docs/game-architecture.md
leveLDesignLocation: docs/level-design.md
# Unity-specific files to load
devLoadAlwaysFiles:
- Assets/Scripts/GameManager.cs
- Assets/Scripts/Player/PlayerController.cs
- ProjectSettings/ProjectSettings.asset
```
## 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**: `/bmad2du/game-designer` - Use `*game-design-brainstorming` task
2. **Game Brief**: Create foundation game document using `game-brief-tmpl`
3. **Game Design Document Creation**: `/bmad2du/game-designer` - Use `game-design-doc-tmpl` for comprehensive game requirements
4. **Game Architecture Design**: `/bmad2du/game-architect` - Use `game-architecture-tmpl` for Unity technical foundation
5. **Level Design Framework**: `/bmad2du/game-designer` - Use `level-design-doc-tmpl` for level structure planning
6. **Document Preparation**: Copy final documents to Unity 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 Unity architecture
that can handle [specific game requirements] with stable performance."
```
### Critical Transition: Web UI to Unity IDE
**Once game planning is complete, you MUST switch to IDE for Unity development:**
- **Why**: Unity development workflow requires C# operations, asset management, and real-time Unity testing
- **Cost Benefit**: Web UI is more cost-effective for large game design creation; IDE is optimized for Unity development
- **Required Files**: Ensure `docs/game-design-doc.md` and `docs/game-architecture.md` exist in your Unity project
### Unity IDE Development Workflow
**Prerequisites**: Game planning documents must exist in `docs/` folder of Unity 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 Unity is painful!
2. **Verify Sharded Game Content**:
- At least one `feature-n.md` file in `docs/game-design/` with game stories in development order
- Unity system documents and coding standards for game dev agent reference
- Sharded docs for Game SM agent story creation
Resulting Unity Project Folder Structure:
- `docs/game-design/` - Broken down game design sections
- `docs/game-architecture/` - Broken down Unity architecture sections
- `docs/game-stories/` - Generated game development stories
3. **Game Development Cycle** (Sequential, one game story at a time):
**CRITICAL CONTEXT MANAGEMENT for Unity 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 → `/bmad2du/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 - Unity Game Story Implementation**:
- **NEW CLEAN CHAT** → `/bmad2du/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 Unity/C# changes
- Game Dev marks story as "Review" when complete with all Unity tests passing
**Step 3 - Game QA Review**:
- **NEW CLEAN CHAT** → Use core `@qa` agent → execute review-story task
- QA performs senior Unity developer code review
- QA can refactor and improve Unity 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
- Unity system architecture and technical design
- Game development execution
- Game testing, performance optimization, and deployment
#### Brownfield Game Enhancement (Existing Unity Projects)
**Key Concept**: Brownfield game development requires comprehensive documentation of your existing Unity project for AI agents to understand game mechanics, Unity 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 Unity project to Web UI** (GitHub URL, files, or zip)
2. **Create adapted Game Design Document**: `/bmad2du/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 `/bmad2du/game-architect` with `game-architecture-tmpl`
- Focus on how new features integrate with existing Unity systems
- Plan for gradual rollout and testing
4. **Story Creation for Enhancements**:
- Use `/bmad2du/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 Unity integrations
- Multiple related gameplay changes
**Quick Story Creation** (Use when):
- Single, focused game enhancement
- Isolated gameplay fixes
- Small feature additions
- Well-documented existing Unity game
**Critical Success Factors for Game Development**:
1. **Game Documentation First**: Always document existing code thoroughly before making changes
2. **Unity Context Matters**: Provide agents access to relevant Unity 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` - Unity System Architecture Document
**Why These Names Matter for Game Development**:
- Game agents automatically reference these files during Unity 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 Unity project
3. **Standard Names**: Save as `docs/game-design-doc.md` and `docs/game-architecture.md`
4. **Switch to Unity IDE**: Use IDE agents for Unity 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` | Unity Developer | C# implementation, Unity optimization | All Unity development tasks |
| `game-sm` | Game Scrum Master | Game story creation, sprint planning | Game project management, workflow |
| `game-architect` | Game Architect | Unity system design, technical architecture | Complex Unity 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**: `/bmad2du/game-designer`, `/bmad2du/game-developer`, `/bmad2du/game-sm`, `/bmad2du/game-architect`
- **Cursor**: `@bmad2du/game-designer`, `@bmad2du/game-developer`, `@bmad2du/game-sm`, `@bmad2du/game-architect`
- **Windsurf**: `@bmad2du/game-designer`, `@bmad2du/game-developer`, `@bmad2du/game-sm`, `@bmad2du/game-architect`
- **Trae**: `@bmad2du/game-designer`, `@bmad2du/game-developer`, `@bmad2du/game-sm`, `@bmad2du/game-architect`
- **Roo Code**: Select mode from mode selector with bmad2du 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 unity-2d-game-team)**:
```text
/bmad2du/game-designer - Access game designer agent
/bmad2du/game-architect - Access game architect agent
/bmad2du/game-developer - Access game developer agent
/bmad2du/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
@ -90,17 +479,18 @@ You are developing games as a "Player Experience CEO" - thinking like a game dir
```text
UnityProject/
├── Assets/
│ ├── Scenes/ # Game scenes (Boot, Menu, Game, etc.)
│ ├── Scripts/ # C# scripts
│ │ ├── Editor/ # Editor-specific scripts
│ │ └── Runtime/ # Runtime scripts
│ ├── Prefabs/ # Reusable game objects
│ ├── Art/ # Art assets (sprites, models, etc.)
│ ├── Audio/ # Audio assets
│ ├── Data/ # ScriptableObjects and other data
│ └── Tests/ # Unity Test Framework tests
│ ├── EditMode/
│ └── PlayMode/
│ └── _Project
│ ├── Scenes/ # Game scenes (Boot, Menu, Game, etc.)
│ ├── Scripts/ # C# scripts
│ │ ├── Editor/ # Editor-specific scripts
│ │ └── Runtime/ # Runtime scripts
│ ├── Prefabs/ # Reusable game objects
│ ├── Art/ # Art assets (sprites, models, etc.)
│ ├── Audio/ # Audio assets
│ ├── Data/ # ScriptableObjects and other data
│ └── Tests/ # Unity Test Framework tests
│ ├── EditMode/
│ └── PlayMode/
├── Packages/ # Package Manager manifest
└── ProjectSettings/ # Unity project settings
```
@ -155,23 +545,59 @@ UnityProject/
- 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
**Unity IDE Best For Game Development**:
- Active Unity development and C# implementation
- Unity asset operations and project integration
- Game story management and development cycles
- Unity 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 Unity tasks
- Choose appropriate game team size for project needs
- Leverage game-specific technical preferences for consistency
- Regular context management and cache clearing for Unity workflows
## Game Development Team Roles
### Game Designer (Alex)
### 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 (Maya)
### Game Developer
- **Primary Focus**: Unity implementation, C# excellence, performance
- **Key Outputs**: Working game features, optimized code, technical architecture
- **Primary Focus**: Unity implementation, C# excellence, performance optimization
- **Key Outputs**: Working game features, optimized Unity code, technical architecture
- **Specialties**: C#/Unity, performance optimization, cross-platform development
### Game Scrum Master (Jordan)
### Game Scrum Master
- **Primary Focus**: Story creation, development planning, agile process
- **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
@ -248,4 +674,83 @@ UnityProject/
- 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 Unity 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 Unity 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 Unity specialization
- **Game Design Philosophy**: "Game dev agents code Unity, game planning agents plan gameplay"
## Game Development Expansion Pack System
### This Game Development Expansion Pack
This 2D Unity Game Development expansion pack extends BMad-Method beyond traditional software development into professional game development. It provides specialized game agent teams, Unity 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 Unity coding
2. **Game Domain Expertise**: Deep, specialized Unity and game development knowledge
3. **Community Game Innovation**: Game developers can contribute and share Unity 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 Unity boundaries
3. **Build Game Resources**: Tasks, templates, checklists for your game domain
4. **Test & Share**: Validate with real Unity use cases, share with game development community
**Key Principle**: Game development expansion packs democratize game development expertise by making specialized Unity 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 Unity project-specific context
- **Game Community**: 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 Unity and C#.

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

@ -0,0 +1,201 @@
# Validate Game Story Task
## Purpose
To comprehensively validate a Unity 2D game development story draft before implementation begins, ensuring it contains all necessary Unity-specific technical context, game development requirements, and implementation details. This specialized validation prevents hallucinations, ensures Unity 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}/game-core-config.yaml` from the project root
- If the file does not exist, check for `{root}/core-config.yaml` as fallback
- If neither exists, HALT and inform the user: "game-core-config.yaml (or core-config.yaml) not found. This file is required for story validation."
- Extract key configurations: `devStoryLocation`, `gdd.*`, `architecture.*`, `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-unity-game-dev/templates/game-story-tmpl.yaml` for completeness validation
### 1. Game Story Template Completeness Validation
- Load `expansion-packs/bmad-2d-unity-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 Unity-specific sections are present:
- Unity Technical Context
- Component Architecture
- Scene & Prefab Requirements
- Asset Dependencies
- Performance Requirements
- Platform Considerations
- Integration Points
- Testing Strategy (Unity Test Framework)
- **Placeholder validation**: Ensure no template placeholders remain unfilled (e.g., `{{EpicNum}}`, `{{StoryNum}}`, `{{GameMechanic}}`, `_TBD_`)
- **Game-specific sections**: Verify presence of Unity development specific sections
- **Structure compliance**: Verify story follows game story template structure and formatting
### 2. Unity Project Structure and Asset Validation
- **Unity file paths clarity**: Are Unity-specific paths clearly specified (Assets/, Scripts/, Prefabs/, Scenes/, etc.)?
- **Package dependencies**: Are required Unity packages identified and version-locked?
- **Scene structure relevance**: Is relevant scene hierarchy and GameObject structure included?
- **Prefab organization**: Are prefab creation/modification requirements clearly specified?
- **Asset pipeline**: Are sprite imports, animation controllers, and audio assets properly planned?
- **Directory structure**: Do new Unity assets follow project structure according to architecture docs?
- **ScriptableObject requirements**: Are data containers and configuration objects identified?
- **Namespace compliance**: Are C# namespaces following project conventions?
### 3. Unity Component Architecture Validation
- **MonoBehaviour specifications**: Are Unity component classes sufficiently detailed for implementation?
- **Component dependencies**: Are Unity component interdependencies clearly mapped?
- **Unity lifecycle usage**: Are Start(), Update(), Awake() methods appropriately planned?
- **Event system integration**: Are UnityEvents, C# events, or custom messaging systems specified?
- **Serialization requirements**: Are [SerializeField] and public field requirements clear?
- **Component interfaces**: Are required interfaces and abstract base classes defined?
- **Performance considerations**: Are component update patterns optimized (Update vs FixedUpdate vs coroutines)?
### 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, Collider2D, and physics material requirements specified?
### 5. Unity-Specific Acceptance Criteria Assessment
- **Functional testing**: Can all acceptance criteria be tested within Unity's Play 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. Unity Testing and Validation Instructions Review
- **Unity Test Framework**: Are EditMode and PlayMode test approaches clearly specified?
- **Performance profiling**: Are Unity 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 Unity memory profiling and leak detection steps included?
### 7. Unity 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. Unity 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. Unity Development Task Sequence Validation
- **Unity workflow order**: Do tasks follow proper Unity development sequence (prefabs before scenes, scripts before UI)?
- **Asset creation dependencies**: Are asset creation tasks properly ordered (sprites before animations, audio before mixers)?
- **Component dependencies**: Are script dependencies clear and implementation order logical?
- **Testing integration**: Are Unity 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. Unity Anti-Hallucination Verification
- **Unity API accuracy**: Every Unity API reference must be verified against current Unity documentation
- **Package version verification**: All Unity package references must specify valid versions
- **Component architecture alignment**: Unity component 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. Unity Development Agent Implementation Readiness
- **Unity context completeness**: Can the story be implemented without consulting external Unity documentation?
- **Technical specification clarity**: Are all Unity-specific implementation details unambiguous?
- **Asset requirements clarity**: Are all required assets, their specifications, and import settings clearly defined?
- **Component relationship clarity**: Are all Unity component interactions and dependencies explicitly defined?
- **Testing approach completeness**: Are Unity-specific testing approaches fully specified and actionable?
- **Performance validation readiness**: Are all performance testing and optimization approaches clearly defined?
### 12. Generate Unity Game Story Validation Report
Provide a structured validation report including:
#### Game Story Template Compliance Issues
- Missing Unity-specific sections from game story template
- Unfilled placeholders or template variables specific to game development
- Missing Unity component specifications or asset requirements
- Structural formatting issues in game-specific sections
#### Critical Unity Issues (Must Fix - Story Blocked)
- Missing essential Unity technical information for implementation
- Inaccurate or unverifiable Unity API references or package dependencies
- Incomplete game mechanics or systems integration
- Missing required Unity testing framework specifications
- Performance requirements that are unrealistic or unmeasurable
#### Unity-Specific Should-Fix Issues (Important Quality Improvements)
- Unclear Unity component architecture or dependency relationships
- Missing platform-specific performance considerations
- Incomplete asset pipeline specifications or optimization requirements
- Task sequencing problems specific to Unity development workflow
- Missing Unity Test Framework integration or testing approaches
#### Game Development Nice-to-Have Improvements (Optional Enhancements)
- Additional Unity performance optimization context
- Enhanced asset creation guidance and best practices
- Clarifications for Unity-specific development patterns
- Additional platform compatibility considerations
- Enhanced debugging and profiling guidance
#### Unity Anti-Hallucination Findings
- Unverifiable Unity API claims or outdated Unity references
- Missing Unity package version specifications
- Inconsistencies with Unity project architecture documents
- Invented Unity components, packages, or development patterns
- Unrealistic performance claims or platform capability assumptions
#### Unity 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
- **Unity Version Compliance**: Compatibility with specified Unity version and package versions
#### Final Unity Game Development Assessment
- **GO**: Story is ready for Unity implementation with all technical context
- **NO-GO**: Story requires Unity-specific fixes before implementation
- **Unity Implementation Readiness Score**: 1-10 scale based on Unity technical completeness
- **Game Development Confidence Level**: High/Medium/Low for successful Unity 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:
- Unity technical documentation improvements needed
- Asset creation or acquisition requirements
- Performance testing and profiling setup requirements
- Platform-specific development environment setup needs
- Unity Test Framework implementation recommendations