bmad-method 4.31.0 → 4.33.0

package/dist/expansion-packs/bmad-2d-unity-game-dev/agents/game-designer.txt

@@ -62,27 +62,29 @@ 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
 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
+  - 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
@@ -92,6 +94,8 @@ dependencies:
     - game-brief-tmpl.yaml
   checklists:
     - game-design-checklist.md
+  data:
+    - bmad-kb.md
 ```
 ==================== END: .bmad-2d-unity-game-dev/agents/game-designer.md ====================
 
@@ -295,6 +299,196 @@ The LLM will:
 - Offer to provide detailed analysis of any section, especially those with warnings or failures
 ==================== END: .bmad-2d-unity-game-dev/tasks/execute-checklist.md ====================
 
+==================== START: .bmad-2d-unity-game-dev/tasks/shard-doc.md ====================
+# Document Sharding Task
+
+## Purpose
+
+- Split a large document into multiple smaller documents based on level 2 sections
+- Create a folder structure to organize the sharded documents
+- Maintain all content integrity including code blocks, diagrams, and markdown formatting
+
+## Primary Method: Automatic with markdown-tree
+
+[[LLM: First, check if markdownExploder is set to true in .bmad-2d-unity-game-dev/core-config.yaml. If it is, attempt to run the command: `md-tree explode {input file} {output path}`.
+
+If the command succeeds, inform the user that the document has been sharded successfully and STOP - do not proceed further.
+
+If the command fails (especially with an error indicating the command is not found or not available), inform the user: "The markdownExploder setting is enabled but the md-tree command is not available. Please either:
+
+1. Install @kayvan/markdown-tree-parser globally with: `npm install -g @kayvan/markdown-tree-parser`
+2. Or set markdownExploder to false in .bmad-2d-unity-game-dev/core-config.yaml
+
+**IMPORTANT: STOP HERE - do not proceed with manual sharding until one of the above actions is taken.**"
+
+If markdownExploder is set to false, inform the user: "The markdownExploder setting is currently false. For better performance and reliability, you should:
+
+1. Set markdownExploder to true in .bmad-2d-unity-game-dev/core-config.yaml
+2. Install @kayvan/markdown-tree-parser globally with: `npm install -g @kayvan/markdown-tree-parser`
+
+I will now proceed with the manual sharding process."
+
+Then proceed with the manual method below ONLY if markdownExploder is false.]]
+
+### Installation and Usage
+
+1. **Install globally**:
+
+   ```bash
+   npm install -g @kayvan/markdown-tree-parser
+   ```
+
+2. **Use the explode command**:
+
+   ```bash
+   # For PRD
+   md-tree explode docs/prd.md docs/prd
+
+   # For Architecture
+   md-tree explode docs/architecture.md docs/architecture
+
+   # For any document
+   md-tree explode [source-document] [destination-folder]
+   ```
+
+3. **What it does**:
+   - Automatically splits the document by level 2 sections
+   - Creates properly named files
+   - Adjusts heading levels appropriately
+   - Handles all edge cases with code blocks and special markdown
+
+If the user has @kayvan/markdown-tree-parser installed, use it and skip the manual process below.
+
+---
+
+## Manual Method (if @kayvan/markdown-tree-parser is not available or user indicated manual method)
+
+### Task Instructions
+
+1. Identify Document and Target Location
+
+- Determine which document to shard (user-provided path)
+- Create a new folder under `docs/` with the same name as the document (without extension)
+- Example: `docs/prd.md` → create folder `docs/prd/`
+
+2. Parse and Extract Sections
+
+CRITICAL AEGNT SHARDING RULES:
+
+1. Read the entire document content
+2. Identify all level 2 sections (## headings)
+3. For each level 2 section:
+   - Extract the section heading and ALL content until the next level 2 section
+   - Include all subsections, code blocks, diagrams, lists, tables, etc.
+   - Be extremely careful with:
+     - Fenced code blocks (```) - ensure you capture the full block including closing backticks and account for potential misleading level 2's that are actually part of a fenced section example
+     - Mermaid diagrams - preserve the complete diagram syntax
+     - Nested markdown elements
+     - Multi-line content that might contain ## inside code blocks
+
+CRITICAL: Use proper parsing that understands markdown context. A ## inside a code block is NOT a section header.]]
+
+### 3. Create Individual Files
+
+For each extracted section:
+
+1. **Generate filename**: Convert the section heading to lowercase-dash-case
+
+   - Remove special characters
+   - Replace spaces with dashes
+   - Example: "## Tech Stack" → `tech-stack.md`
+
+2. **Adjust heading levels**:
+
+   - The level 2 heading becomes level 1 (# instead of ##) in the sharded new document
+   - All subsection levels decrease by 1:
+
+   ```txt
+     - ### → ##
+     - #### → ###
+     - ##### → ####
+     - etc.
+   ```
+
+3. **Write content**: Save the adjusted content to the new file
+
+### 4. Create Index File
+
+Create an `index.md` file in the sharded folder that:
+
+1. Contains the original level 1 heading and any content before the first level 2 section
+2. Lists all the sharded files with links:
+
+```markdown
+# Original Document Title
+
+[Original introduction content if any]
+
+## Sections
+
+- [Section Name 1](./section-name-1.md)
+- [Section Name 2](./section-name-2.md)
+- [Section Name 3](./section-name-3.md)
+  ...
+```
+
+### 5. Preserve Special Content
+
+1. **Code blocks**: Must capture complete blocks including:
+
+   ```language
+   content
+   ```
+
+2. **Mermaid diagrams**: Preserve complete syntax:
+
+   ```mermaid
+   graph TD
+   ...
+   ```
+
+3. **Tables**: Maintain proper markdown table formatting
+
+4. **Lists**: Preserve indentation and nesting
+
+5. **Inline code**: Preserve backticks
+
+6. **Links and references**: Keep all markdown links intact
+
+7. **Template markup**: If documents contain {{placeholders}} ,preserve exactly
+
+### 6. Validation
+
+After sharding:
+
+1. Verify all sections were extracted
+2. Check that no content was lost
+3. Ensure heading levels were properly adjusted
+4. Confirm all files were created successfully
+
+### 7. Report Results
+
+Provide a summary:
+
+```text
+Document sharded successfully:
+- Source: [original document path]
+- Destination: docs/[folder-name]/
+- Files created: [count]
+- Sections:
+  - section-name-1.md: "Section Title 1"
+  - section-name-2.md: "Section Title 2"
+  ...
+```
+
+## Important Notes
+
+- Never modify the actual content, only adjust heading levels
+- Preserve ALL formatting, including whitespace where significant
+- Handle edge cases like sections with code blocks containing ## symbols
+- Ensure the sharding is reversible (could reconstruct the original from shards)
+==================== END: .bmad-2d-unity-game-dev/tasks/shard-doc.md ====================
+
 ==================== START: .bmad-2d-unity-game-dev/tasks/game-design-brainstorming.md ====================
 # Game Design Brainstorming Techniques Task
 
@@ -1014,88 +1208,130 @@ The questions and perspectives offered should always consider:
 
 ==================== START: .bmad-2d-unity-game-dev/templates/game-design-doc-tmpl.yaml ====================
 template:
-  id: game-design-doc-template-v2
+  id: game-design-doc-template-v3
   name: Game Design Document (GDD)
-  version: 2.0
+  version: 4.0
   output:
     format: markdown
-    filename: "docs/{{game_name}}-game-design-document.md"
+    filename: docs/game-design-document.md
     title: "{{game_title}} Game Design Document (GDD)"
 
 workflow:
   mode: interactive
+  elicitation: advanced-elicitation
 
 sections:
-  - id: initial-setup
+  - id: goals-context
+    title: Goals and Background Context
     instruction: |
-      This template creates a comprehensive Game Design Document that will serve as the foundation for all game development work. The GDD should be detailed enough that developers can create user stories and epics from it. Focus on gameplay systems, mechanics, and technical requirements that can be broken down into implementable features.
-      
-      If available, review any provided documents or ask if any are optionally available: Project Brief, Market Research, Competitive Analysis
+      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
+        instruction: Based on the technical preferences or user input, define the target platforms and Unity-specific requirements
         template: |
           **Primary Platform:** {{platform}}
-          **Engine:** Unity & C#
-          **Performance Target:** Stable FPS on {{minimum_device}}
+          **Engine:** Unity {{unity_version}} & 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: Unity 2022.3 LTS & 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
-        template: "{{usp}}"
+        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 `tasks#advanced-elicitation` protocol to ensure completeness.
+    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.
+        instruction: Define 3-5 core pillars that guide all design decisions. These should be specific and actionable for Unity 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.
+        instruction: Define the 30-60 second loop that players will repeat. Be specific about timing and player actions for Unity implementation.
         template: |
           **Primary Loop ({{duration}} seconds):**
           
-          1. {{action_1}} ({{time_1}}s)
-          2. {{action_2}} ({{time_2}}s)
-          3. {{action_3}} ({{time_3}}s)
-          4. {{reward_feedback}} ({{time_4}}s)
+          1. {{action_1}} ({{time_1}}s) - {{unity_component}}
+          2. {{action_2}} ({{time_2}}s) - {{unity_component}}
+          3. {{action_3}} ({{time_3}}s) - {{unity_component}}
+          4. {{reward_feedback}} ({{time_4}}s) - {{unity_component}}
+        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
+        instruction: Clearly define success and failure states with Unity-specific implementation notes
         template: |
           **Victory Conditions:**
           
-          - {{win_condition_1}}
-          - {{win_condition_2}}
+          - {{win_condition_1}} - Unity Event: {{unity_event}}
+          - {{win_condition_2}} - Unity Event: {{unity_event}}
           
           **Failure States:**
           
-          - {{loss_condition_1}}
-          - {{loss_condition_2}}
+          - {{loss_condition_1}} - Trigger: {{unity_trigger}}
+          - {{loss_condition_2}} - Trigger: {{unity_trigger}}
+        examples:
+          - "Victory: Player reaches exit portal - Unity Event: OnTriggerEnter2D with Portal tag"
+          - "Failure: Health reaches zero - Trigger: Health component value <= 0"
 
   - id: game-mechanics
     title: Game Mechanics
-    instruction: Detail each major mechanic that will need to be implemented. Each mechanic should be specific enough for developers to create implementation stories.
+    instruction: Detail each major mechanic that will need Unity implementation. Each mechanic should be specific enough for developers to create C# scripts and prefabs.
+    elicit: true
     sections:
       - id: primary-mechanics
         title: Primary Mechanics
@@ -1106,29 +1342,41 @@ sections:
             template: |
               **Description:** {{detailed_description}}
               
-              **Player Input:** {{input_method}}
+              **Player Input:** {{input_method}} - Unity Input System: {{input_action}}
               
               **System Response:** {{game_response}}
               
-              **Implementation Notes:**
+              **Unity Implementation Notes:**
               
-              - {{tech_requirement_1}}
-              - {{tech_requirement_2}}
-              - {{performance_consideration}}
+              - **Components Needed:** {{component_list}}
+              - **Physics Requirements:** {{physics_2d_setup}}
+              - **Animation States:** {{animator_states}}
+              - **Performance Considerations:** {{optimization_notes}}
               
               **Dependencies:** {{other_mechanics_needed}}
+              
+              **Script Architecture:**
+              
+              - {{script_name}}.cs - {{responsibility}}
+              - {{manager_script}}.cs - {{management_role}}
+            examples:
+              - "Components Needed: Rigidbody2D, BoxCollider2D, 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
+        instruction: Define all input methods for different platforms using Unity's Input System
         type: table
         template: |
-          | Action | Desktop | Mobile | Gamepad |
-          | ------ | ------- | ------ | ------- |
-          | {{action}} | {{key}} | {{gesture}} | {{button}} |
+          | Action | Desktop | Mobile | Gamepad | Unity 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 implementation.
+    instruction: Define how players advance and how difficulty scales. This section should provide clear parameters for Unity implementation and scriptable objects.
+    elicit: true
     sections:
       - id: player-progression
         title: Player Progression
@@ -1137,30 +1385,54 @@ sections:
           
           **Key Milestones:**
           
-          1. **{{milestone_1}}** - {{unlock_description}}
-          2. **{{milestone_2}}** - {{unlock_description}}
-          3. **{{milestone_3}}** - {{unlock_description}}
+          1. **{{milestone_1}}** - {{unlock_description}} - Unity: {{scriptable_object_update}}
+          2. **{{milestone_2}}** - {{unlock_description}} - Unity: {{scriptable_object_update}}
+          3. **{{milestone_3}}** - {{unlock_description}} - Unity: {{scriptable_object_update}}
+          
+          **Save Data Structure:**
+          
+          ```csharp
+          [System.Serializable]
+          public class PlayerProgress
+          {
+              {{progress_fields}}
+          }
+          ```
+        examples:
+          - public int currentLevel, public bool[] unlockedAbilities, public float totalPlayTime
       - id: difficulty-curve
         title: Difficulty Curve
-        instruction: Provide specific parameters for balancing
+        instruction: Provide specific parameters for balancing that can be implemented as Unity ScriptableObjects
         template: |
           **Tutorial Phase:** {{duration}} - {{difficulty_description}}
+          - Unity Config: {{scriptable_object_values}}
+          
           **Early Game:** {{duration}} - {{difficulty_description}}
+          - Unity Config: {{scriptable_object_values}}
+          
           **Mid Game:** {{duration}} - {{difficulty_description}}
+          - Unity Config: {{scriptable_object_values}}
+          
           **Late Game:** {{duration}} - {{difficulty_description}}
+          - Unity Config: {{scriptable_object_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
+        instruction: Define any in-game currencies, resources, or collectibles with Unity implementation details
         type: table
         template: |
-          | Resource | Earn Rate | Spend Rate | Purpose | Cap |
-          | -------- | --------- | ---------- | ------- | --- |
-          | {{resource}} | {{rate}} | {{rate}} | {{use}} | {{max}} |
+          | Resource | Earn Rate | Spend Rate | Purpose | Cap | Unity ScriptableObject |
+          | -------- | --------- | ---------- | ------- | --- | --------------------- |
+          | {{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 level implementation stories
+    instruction: Provide guidelines for level creation that developers can use to create Unity scenes and prefabs. Focus on modular design and reusable components.
+    elicit: true
     sections:
       - id: level-types
         title: Level Types
@@ -1170,202 +1442,486 @@ sections:
             title: "{{level_type_name}}"
             template: |
               **Purpose:** {{gameplay_purpose}}
-              **Duration:** {{target_time}}
+              **Target Duration:** {{target_time}}
               **Key Elements:** {{required_mechanics}}
-              **Difficulty:** {{relative_difficulty}}
+              **Difficulty Rating:** {{relative_difficulty}}
               
-              **Structure Template:**
+              **Unity Scene Structure:**
               
-              - Introduction: {{intro_description}}
-              - Challenge: {{main_challenge}}
-              - Resolution: {{completion_requirement}}
+              - **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 Prefabs:**
+              
+              - {{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}}
+          
+          **Unity 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 technical requirements that will guide architecture and implementation decisions. Review any existing technical preferences.
+    instruction: Define Unity-specific technical requirements that will guide architecture and implementation decisions. Reference Unity 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: Unity Project Configuration
+        template: |
+          **Unity Version:** {{unity_version}} (LTS recommended)
+          **Render Pipeline:** {{Built-in|URP|HDRP}}
+          **Input System:** {{Legacy|New Input System|Both}}
+          **Physics:** {{2D Only|3D Only|Hybrid}}
+          **Scripting Backend:** {{Mono|IL2CPP}}
+          **API Compatibility:** {{.NET Standard 2.1|.NET Framework}}
+          
+          **Required Packages:**
+          
+          - {{package_name}} {{version}} - {{purpose}}
+          
+          **Project Settings:**
+          
+          - Color Space: {{Linear|Gamma}}
+          - Quality Settings: {{quality_levels}}
+          - Physics Settings: {{physics_config}}
+        examples:
+          - com.unity.addressables 1.20.5 - Asset loading and memory management
+          - "Color Space: Linear, Quality: Mobile/Desktop presets, Gravity: -20"
       - id: performance-requirements
         title: Performance Requirements
         template: |
-          **Frame Rate:** Stable FPS (minimum 30 FPS on low-end devices)
-          **Memory Usage:** <{{memory_limit}}MB
+          **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 Usage:** Optimized for mobile devices - {{battery_target}} hours gameplay
+          
+          **Unity 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
+        title: Platform Specific Requirements
         template: |
           **Desktop:**
           
           - Resolution: {{min_resolution}} - {{max_resolution}}
-          - Input: Keyboard, Mouse, Gamepad
-          - Browser: Chrome 80+, Firefox 75+, Safari 13+
+          - Input: Keyboard, Mouse, Gamepad ({{gamepad_support}})
+          - Build Target: {{desktop_targets}}
           
           **Mobile:**
           
           - Resolution: {{mobile_min}} - {{mobile_max}}
-          - Input: Touch, Tilt (optional)
-          - OS: iOS 13+, Android 8+
+          - 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 the art and audio teams
+        instruction: Define asset specifications for Unity pipeline optimization
         template: |
-          **Visual Assets:**
+          **2D Art Assets:**
           
-          - Art Style: {{style_description}}
-          - Color Palette: {{color_specification}}
-          - Animation: {{animation_requirements}}
-          - UI Resolution: {{ui_specs}}
+          - Sprites: {{sprite_resolution}} at {{ppu}} PPU
+          - Texture Format: {{texture_compression}}
+          - Atlas Strategy: {{sprite_atlas_setup}}
+          - Animation: {{animation_type}} at {{framerate}} FPS
           
           **Audio Assets:**
           
-          - Music Style: {{music_genre}}
-          - Sound Effects: {{sfx_requirements}}
-          - Voice Acting: {{voice_needs}}
+          - 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 technical requirements that the game architecture must support
+    instruction: Define high-level Unity 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: [Unity Audio, FMOD, Wwise]
     sections:
-      - id: engine-configuration
-        title: Engine Configuration
-        template: |
-          **Unity Setup:**
-
-          - C#: Latest stable version
-          - Physics: 2D Physics
-          - Renderer: 2D Renderer (URP)
-          - Input System: New Input System
       - id: code-architecture
-        title: 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}}
+          │   ├── Prefabs/
+          │   ├── Scenes/
+          │   └── {{additional_folders}}
+          ```
+          
+          **Naming Conventions:**
+          
+          - Scripts: {{script_naming}}
+          - Prefabs: {{prefab_naming}}
+          - Scenes: {{scene_naming}}
+        examples:
+          - "Architecture: Component-Based with ScriptableObject data containers"
+          - "Scripts: PascalCase (PlayerController), Prefabs: Player_Prefab, Scenes: Level_01_Forest"
+      - id: unity-systems-integration
+        title: Unity Systems Integration
         template: |
-          **Required Systems:**
+          **Required Unity 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:**
           
-          - Scene Management
-          - State Management
-          - Asset Loading
-          - Save/Load System
-          - Input Management
-          - Audio System
-          - Performance Monitoring
+          - **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:**
+          **Save Data Architecture:**
           
-          - Progress tracking
-          - Settings persistence
-          - Statistics collection
-          - {{additional_data}}
+          - **Format:** {{PlayerPrefs|JSON|Binary|Cloud}}
+          - **Structure:** {{save_data_organization}}
+          - **Encryption:** {{security_approach}}
+          - **Cloud Sync:** {{cloud_integration}}
+          
+          **Configuration Data:**
+          
+          - **ScriptableObjects:** {{scriptable_object_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"
+          - "ScriptableObjects: Game settings, level configurations, character data"
 
   - id: development-phases
-    title: Development Phases
-    instruction: Break down the development into phases that can be converted to epics
+    title: Development Phases & Epic Planning
+    instruction: Break down the Unity development into phases that can be converted to agile epics. Each phase should deliver deployable functionality following Unity best practices.
+    elicit: true
     sections:
-      - id: phase-1-core-systems
-        title: "Phase 1: Core Systems ({{duration}})"
+      - 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 Unity functionality.
+        type: numbered-list
+        examples:
+          - "Phase 1: Unity 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: Unity Foundation & Core Systems ({{duration}})"
         sections:
-          - id: foundation-epic
-            title: "Epic: Foundation"
+          - id: foundation-design
+            title: "Design: Unity Project Foundation"
             type: bullet-list
             template: |
-              - Engine setup and configuration
-              - Basic scene management
-              - Core input handling
-              - Asset loading pipeline
-          - id: core-mechanics-epic
-            title: "Epic: Core Mechanics"
+              - Unity 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: |
-              - {{primary_mechanic}} implementation
-              - Basic physics and collision
-              - Player controller
-      - id: phase-2-gameplay-features
-        title: "Phase 2: Gameplay Features ({{duration}})"
+              - 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 ScriptableObjects
+      - id: phase-2-gameplay
+        title: "Phase 2: Core Gameplay Implementation ({{duration}})"
         sections:
-          - id: game-systems-epic
-            title: "Epic: Game Systems"
+          - id: gameplay-mechanics-design
+            title: "Design: Primary Game Mechanics"
             type: bullet-list
             template: |
-              - {{mechanic_2}} implementation
-              - {{mechanic_3}} implementation
-              - Game state management
-          - id: content-creation-epic
-            title: "Epic: Content Creation"
+              - Player controller with {{movement_type}} movement system
+              - {{primary_mechanic}} implementation with Unity 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: |
-              - Level loading system
-              - First playable levels
-              - Basic UI implementation
-      - id: phase-3-polish-optimization
+              - Scene loading and transition system
+              - Level progression and unlock system
+              - Prefab-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-epic
-            title: "Epic: Performance"
+          - id: performance-design
+            title: "Design: Performance & Platform Optimization"
             type: bullet-list
             template: |
-              - Optimization and profiling
-              - Mobile platform testing
-              - Memory management
-          - id: user-experience-epic
-            title: "Epic: User Experience"
+              - Unity 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: |
-              - Audio implementation
-              - Visual effects and polish
-              - Final UI/UX refinement
+              - 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: Unity 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: Unity 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 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
-    instruction: Define measurable goals for the game
+    title: Success Metrics & Quality Assurance
+    instruction: Define measurable goals for the Unity game development project with specific targets that can be validated through Unity Analytics and profiling tools.
+    elicit: true
     sections:
       - id: technical-metrics
-        title: Technical Metrics
+        title: Technical Performance Metrics
         type: bullet-list
         template: |
-          - Frame rate: {{fps_target}}
-          - Load time: {{load_target}}
-          - Crash rate: <{{crash_threshold}}%
-          - Memory usage: <{{memory_target}}MB
+          - **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 Metrics
+        title: Gameplay & User Engagement Metrics
         type: bullet-list
         template: |
-          - Tutorial completion: {{completion_rate}}%
-          - Average session: {{session_length}} minutes
-          - Level completion: {{level_completion}}%
-          - Player retention: D1 {{d1}}%, D7 {{d7}}%
-
-  - id: appendices
-    title: Appendices
-    sections:
-      - id: change-log
-        title: Change Log
-        instruction: Track document versions and changes
+          - **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: |
-          | Date | Version | Description | Author |
-          | :--- | :------ | :---------- | :----- |
-      - id: references
-        title: References
-        instruction: List any competitive analysis, inspiration, or research sources
+          | 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: Unity Architecture Requirements
+        instruction: Summary of key architectural decisions that need to be implemented in Unity project setup
         type: bullet-list
-        template: "{{reference}}"
+        template: |
+          - Unity {{unity_version}} project with {{render_pipeline}} pipeline
+          - {{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}}
+          
+          **Unity-Specific Story Considerations:**
+          
+          - Each story should result in testable Unity scenes or prefabs
+          - Include specific Unity components and systems in acceptance criteria
+          - Consider cross-platform testing requirements
+          - Account for Unity build and deployment steps
+        examples:
+          - "Foundation stories: Individual Unity 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:
+          - "Unity Architect: Create detailed technical architecture document with specific Unity implementation patterns"
+          - "Unity Developer: Implement core systems and gameplay mechanics according to architecture"
+          - "QA Tester: Validate performance metrics and cross-platform functionality"
 ==================== END: .bmad-2d-unity-game-dev/templates/game-design-doc-tmpl.yaml ====================
 
 ==================== START: .bmad-2d-unity-game-dev/templates/level-design-doc-tmpl.yaml ====================
 template:
   id: level-design-doc-template-v2
   name: Level Design Document
-  version: 2.0
+  version: 2.1
   output:
     format: markdown
-    filename: "docs/{{game_name}}-level-design-document.md"
+    filename: docs/level-design-document.md
     title: "{{game_title}} Level Design Document"
 
 workflow:
@@ -1732,19 +2288,19 @@ sections:
             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)"
+              - 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"
+              - 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: |
@@ -1847,12 +2403,12 @@ sections:
 
 ==================== START: .bmad-2d-unity-game-dev/templates/game-brief-tmpl.yaml ====================
 template:
-  id: game-brief-template-v2
+  id: game-brief-template-v3
   name: Game Brief
-  version: 2.0
+  version: 3.0
   output:
     format: markdown
-    filename: "docs/{{game_name}}-game-brief.md"
+    filename: docs/game-brief.md
     title: "{{game_title}} Game Brief"
 
 workflow:
@@ -2383,7 +2939,7 @@ sections:
 
 - [ ] **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
+- [ ] **Asset Production** - Asset requirements enable art and audio production
 - [ ] **Development Workflow** - Clear path from design to implementation
 - [ ] **Quality Assurance** - Testing and validation processes established
 
@@ -2407,3 +2963,782 @@ _List any critical items that need attention before moving to implementation pha
 **Next Steps:**
 _Outline immediate next actions for the team based on this assessment._
 ==================== END: .bmad-2d-unity-game-dev/checklists/game-design-checklist.md ====================
+
+==================== START: .bmad-2d-unity-game-dev/data/bmad-kb.md ====================
+# BMad Knowledge Base - 2D Unity 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 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 with game-specific workflows
+- **Performance Target**: Stable frame rate on target devices
+- **Architecture**: Component-based architecture using Unity'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 Unity 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 Unity operations, 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 Unity
+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 `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 `expansion-packs/bmad-2d-unity-game-dev/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. Copy your core-config.yaml file to expansion-packs/bmad-2d-unity-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 unity editor
+unityEditorLocation: /home/USER/Unity/Hub/Editor/VERSION/Editor/Unity
+customTechnicalDocuments: null
+devDebugLog: .ai/debug-log.md
+devStoryLocation: docs/stories
+slashPrefix: bmad2du
+#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-unity-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**: `/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
+
+### Unity + C# Standards
+
+**Project Structure:**
+
+```text
+UnityProject/
+├── Assets/
+│   └── _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
+```
+
+**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:**
+
+- C# best practices compliance
+- Component-based architecture (SOLID principles)
+- Efficient use of the MonoBehaviour 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 Unity and 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 C# logic (EditMode tests)
+- Integration tests for game systems (PlayMode tests)
+- Performance benchmarking and profiling with Unity 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
+
+**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
+
+- **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**: 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
+
+- **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 Unity 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 ScriptableObjects 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 Unity 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 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#.
+==================== END: .bmad-2d-unity-game-dev/data/bmad-kb.md ====================