bmad-method 4.42.1 → 4.43.1

package/expansion-packs/bmad-godot-game-dev/templates/game-prd-tmpl.yaml

@@ -0,0 +1,209 @@
+# <!-- Powered by BMAD™ Core -->
+template:
+  id: game-prd-template-v2
+  name: Product Requirements Document
+  version: 2.0
+  output:
+    format: markdown
+    filename: docs/game-prd.md
+    title: "{{project_name}} Godot Product Requirements Document (PRD)"
+
+workflow:
+  mode: interactive
+  elicitation: advanced-elicitation
+
+sections:
+  - id: goals-context
+    title: Goals and Background Context
+    instruction: |
+      Ask if Project Brief document is available. If NO Project Brief exists, STRONGLY recommend creating one first using game-brief-tmpl (it provides essential foundation: problem statement, target users, success metrics, MVP scope, constraints). If user insists on PRD without brief, gather this information during Goals section. If Project Brief exists, review and use it to populate Goals (bullet list of desired outcomes) and Background Context (1-2 paragraphs on what this solves and why) so we can determine what is and is not in scope for PRD mvp. Either way this is critical to determine the requirements. Include Change Log table.
+    sections:
+      - id: goals
+        title: Goals
+        type: bullet-list
+        instruction: Bullet list of 1 line desired outcomes the game will deliver if successful - player experiences and gameplay goals
+      - id: background
+        title: Background Context
+        type: paragraphs
+        instruction: 1-2 short paragraphs summarizing the game concept, target audience, genre influences, what player need or desire this game fulfills, competitive landscape
+      - id: changelog
+        title: Change Log
+        type: table
+        columns: [Date, Version, Description, Author]
+        instruction: Track document versions and changes
+
+  - id: requirements
+    title: Requirements
+    instruction: Draft the list of functional and non functional requirements under the two child sections
+    elicit: true
+    sections:
+      - id: functional
+        title: Functional
+        type: numbered-list
+        prefix: FR
+        instruction: Each Requirement will be a bullet markdown and an identifier sequence starting with FR
+        examples:
+          - "FR6: The player character can double jump after collecting the Wing Boots power-up."
+          - "FR7: Enemy AI uses Godot's NavigationAgent2D to pathfind around obstacles."
+          - "FR8: The inventory system supports drag-and-drop item management."
+      - id: non-functional
+        title: Non Functional
+        type: numbered-list
+        prefix: NFR
+        instruction: Each Requirement will be a bullet markdown and an identifier sequence starting with NFR
+        examples:
+          - "NFR1: Game must maintain 60 FPS on mid-range hardware (GTX 1060 or equivalent)."
+          - "NFR2: All UI elements must be readable at 720p resolution minimum."
+          - "NFR3: Save files must be compatible across all target platforms."
+
+  - id: ui-goals
+    title: Game UI/UX Design Goals
+    condition: Game has UI/menu requirements
+    instruction: |
+      Capture high-level game UI/UX vision to guide Game Designer and inform implementation. Steps:
+
+      1. Pre-fill all subsections with educated guesses based on game genre and platform
+      2. Present the complete rendered section to user
+      3. Clearly let the user know where assumptions were made
+      4. Ask targeted questions for unclear/missing elements or areas needing more specification
+      5. This is NOT detailed UI spec - focus on player experience and game feel
+    elicit: true
+    choices:
+      accessibility: [None, Basic, Colorblind Support, Full Accessibility]
+      platforms: [PC Only, Mobile Only, PC + Mobile, PC + Console, All Platforms]
+    sections:
+      - id: ux-vision
+        title: Overall Game UX Vision
+      - id: interaction-paradigms
+        title: Control Schemes and Input Methods
+      - id: core-screens
+        title: Core Game Screens and Menus
+        instruction: From a game design perspective, what are the most critical screens, menus, and HUD elements necessary to deliver the gameplay experience? This is meant to be Conceptual High Level to Drive Rough Epic or Game Stories
+        examples:
+          - "Main Menu"
+          - "Game HUD (health, score, inventory)"
+          - "Pause Menu"
+          - "Level Select Screen"
+          - "Character Customization"
+          - "Settings/Options Menu"
+      - id: accessibility
+        title: "Accessibility: {None|Basic|Colorblind Support|Full Accessibility}"
+      - id: branding
+        title: Branding
+        instruction: Any known branding elements or style guides that must be incorporated?
+        examples:
+          - "Pixel art style inspired by 16-bit era JRPGs with modern lighting effects."
+          - "Dark fantasy aesthetic with muted colors and Gothic UI elements."
+          - "Vibrant cartoon style with thick outlines and cel-shading."
+      - id: target-platforms
+        title: "Target Platforms: {PC Only|Mobile Only|PC + Mobile|PC + Console|All Platforms}"
+        examples:
+          - "Windows, Linux, Mac via Steam"
+          - "iOS and Android via App Stores"
+          - "PC (Steam) + Nintendo Switch"
+          - "Web export for itch.io"
+
+  - id: technical-assumptions
+    title: Godot Technical Assumptions
+    instruction: |
+      Gather Godot-specific technical decisions that will guide development. Steps:
+
+      1. Check if {root}/data/godot-preferences.yaml or an attached technical-preferences file exists - use it to pre-populate choices
+      2. Ask user about: Godot version, 2D/3D, GDScript/C#, plugins/addons, target platforms, networking needs
+      3. For unknowns, offer guidance based on game type and target platforms
+      4. Document ALL technical choices with rationale (why this choice fits the game)
+      5. These become constraints for development - be specific and complete
+    elicit: true
+    choices:
+      godot_version: [Godot 4.4, Godot 4.3, Godot 3.x]
+      architecture: [Single Player, Local Multiplayer, Online Multiplayer, MMO]
+      testing: [Manual Playtesting, Automated Tests, Both]
+    sections:
+      - id: godot-version
+        title: "Godot Version: {4.4|4.3|3.x}"
+      - id: game-architecture
+        title: Game Architecture
+        instruction: "CRITICAL DECISION - Document the game architecture (e.g., Single Player, Local Co-op, Online PvP, Server-Authoritative Multiplayer, P2P)."
+      - id: testing-requirements
+        title: Testing & QA Requirements
+        instruction: "CRITICAL DECISION - Document playtesting approach, automated testing needs (if any), performance profiling requirements, platform certification requirements."
+      - id: additional-assumptions
+        title: Additional Godot Technical Assumptions
+        instruction: Throughout the entire process of drafting this document, if any other Godot-specific technical assumptions are raised (rendering pipeline, physics engine settings, audio system, input handling), add them here as additional bulleted items
+
+  - 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 deliver a significant, end-to-end, fully deployable increment of testable functionality
+      - Epic 1 must establish foundational project infrastructure (app setup, Git, CI/CD, core services) unless we are adding new functionality to an existing app, while also delivering an initial piece of functionality, even as simple as a health-check route or display of a simple canary page - 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 completed can deliver value even if a UI 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: Foundation & Core Systems: Setup Godot project, implement player controller, and basic game loop"
+      - "Epic 2: Core Gameplay Mechanics: Implement primary game mechanics, combat/interaction systems"
+      - "Epic 3: Level Design & Content: Create levels, enemies, and game progression"
+      - "Epic 4: Polish & Game Feel: Add VFX, audio, juice, and game polish"
+      - "Epic 5: Menus & Meta Systems: Implement save/load, settings, achievements"
+
+  - 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
+        template: |
+          As a {{user_type}},
+          I want {{action}},
+          so that {{benefit}}.
+        sections:
+          - id: acceptance-criteria
+            title: Acceptance Criteria
+            type: numbered-list
+            item_template: "{{criterion_number}}: {{criteria}}"
+            repeatable: true
+            instruction: |
+              Define clear, comprehensive, and testable acceptance criteria that:
+
+              - Precisely define what "done" means from a functional perspective
+              - Are unambiguous and serve as basis for verification
+              - Include any critical non-functional requirements from the PRD
+              - Consider local testability for backend/data components
+              - Specify UI/UX requirements and framework adherence where applicable
+              - Avoid cross-cutting concerns that should be in other stories or PRD sections
+
+  - id: checklist-results
+    title: Checklist Results Report
+    instruction: Before running the checklist and drafting the prompts, offer to output the full updated PRD. If outputting it, confirm with the user that you will be proceeding to run the checklist and produce the report. Once the user confirms, execute the pm-checklist and populate the results in this section.
+
+  - id: next-steps
+    title: Next Steps
+    sections:
+      - id: architect-prompt
+        title: Game Architect Prompt
+        instruction: This section will contain the prompt for the Game Architect, keep it short and to the point to initiate Godot architecture design using this document as input.

package/expansion-packs/bmad-godot-game-dev/templates/game-qa-gate-tmpl.yaml

@@ -0,0 +1,186 @@
+template:
+  id: godot-qa-gate-template-v2
+  name: Godot Game Quality Gate Decision
+  version: 2.0
+  output:
+    format: yaml
+    filename: docs/qa/gates/{{epic_num}}.{{story_num}}-{{story_slug}}.yml
+    title: "Godot Quality Gate: {{epic_num}}.{{story_num}}"
+
+# Required fields (keep these first)
+schema: 1
+story: "{{epic_num}}.{{story_num}}"
+story_title: "{{story_title}}"
+gate: "{{gate_status}}" # PASS|CONCERNS|FAIL|WAIVED
+status_reason: "{{status_reason}}" # 1-2 sentence summary focusing on TDD compliance and 60+ FPS performance
+reviewer: "Linus (Godot Game Test Architect)"
+updated: "{{iso_timestamp}}"
+
+# Always present but only active when WAIVED
+waiver: { active: false }
+
+# Godot-specific Issues (if any) - Use fixed severity: low | medium | high
+top_issues: [] # Focus on performance drops below 60 FPS, missing TDD tests, wrong language choices
+
+# Risk summary (from risk-profile task if run)
+risk_summary:
+  totals: { critical: 0, high: 0, medium: 0, low: 0 }
+  recommendations:
+    must_fix: []
+    monitor: []
+
+# Godot examples section using block scalars for clarity
+examples:
+  with_issues: |
+    top_issues:
+      - id: "PERF-001"
+        severity: high  # ONLY: low|medium|high
+        finding: "Frame rate drops to 45 FPS during particle spawning"
+        suggested_action: "Implement object pooling for particle systems"
+      - id: "TDD-001"  
+        severity: high
+        finding: "No GUT tests for player controller despite GDScript implementation"
+        suggested_action: "Add GUT test coverage before marking story complete"
+      - id: "LANG-001"
+        severity: medium
+        finding: "Physics system using GDScript instead of C# causing performance issues"
+        suggested_action: "Refactor physics calculations to C# for better performance"
+
+  when_waived: |
+    waiver:
+      active: true
+      reason: "Performance at 55 FPS acceptable for early access - optimization planned for next sprint"
+      approved_by: "Product Owner"
+
+# ============ Optional Extended Fields ============
+# Uncomment and use if your team wants more detail
+# CRITICAL: Gates should FAIL if performance drops below 60 FPS or TDD is not followed
+
+optional_fields_examples:
+  quality_and_expiry: |
+    quality_score: 75  # 100 - (20*FAILs) - (10*CONCERNS) - (5*FPS_drops_below_60)
+    expires: "2025-01-26T00:00:00Z"  # Optional gate freshness window
+
+  evidence: |
+    evidence:
+      gut_tests_reviewed: 15  # GDScript tests
+      godottest_reviewed: 8   # C# tests
+      performance_validated: true  # 60+ FPS confirmed
+      language_strategy_verified: true  # GDScript/C# choices appropriate
+      trace:
+        ac_covered: [1, 2, 3]  # AC numbers with GUT/GoDotTest coverage
+        ac_gaps: [4]  # AC numbers lacking TDD coverage
+        fps_validation: "60+ FPS on all target platforms"
+
+  nfr_validation: |
+    nfr_validation:
+      performance: { status: PASS, notes: "60+ FPS maintained, frame time <16.67ms" }
+      tdd_compliance: { status: PASS, notes: "GUT coverage 85%, GoDotTest coverage 80%" }
+      language_strategy: { status: PASS, notes: "GDScript for logic, C# for physics - appropriate" }
+      object_pooling: { status: CONCERNS, notes: "Pooling missing for bullet spawns" }
+      signal_cleanup: { status: PASS, notes: "All signals properly disconnected" }
+      platform_exports: { status: PASS, notes: "Export templates configured for all targets" }
+
+  history: |
+    history:  # Append-only audit trail
+      - at: "2025-01-12T10:00:00Z"
+        gate: FAIL
+        note: "Initial review - FPS dropped to 45, no GUT tests"
+      - at: "2025-01-12T15:00:00Z"  
+        gate: CONCERNS
+        note: "GUT tests added, FPS improved to 58 - needs object pooling"
+
+  risk_summary: |
+    risk_summary:  # From Godot risk-profile task
+      totals:
+        critical: 0  # FPS < 30 or no TDD
+        high: 0      # FPS < 60 or wrong language choice
+        medium: 0    # Missing optimizations
+        low: 0       # Minor issues
+      # 'highest' is emitted only when risks exist
+      recommendations:
+        must_fix: []  # Performance below 60 FPS, missing TDD
+        monitor: []   # Language strategy concerns
+
+  recommendations: |
+    recommendations:
+      immediate:  # Must fix before production
+        - action: "Implement object pooling for all spawned entities"
+          refs: ["res://scripts/spawners/bullet_spawner.gd:42-68"]
+        - action: "Add GUT tests for player controller"
+          refs: ["res://scripts/player/player_controller.gd"]
+        - action: "Optimize particle system to maintain 60+ FPS"
+          refs: ["res://scenes/effects/particles.tscn"]
+      future:  # Can be addressed later
+        - action: "Consider migrating physics to C# for 20% performance gain"
+          refs: ["res://scripts/physics/physics_manager.gd"]
+        - action: "Add performance benchmarks to GUT test suite"
+          refs: ["res://tests/"]
+
+  godot_performance_metrics: |
+    godot_metrics:
+      frame_rate:
+        current: 62  # Current FPS
+        target: 60   # Minimum acceptable (FAIL if below)
+        peak: 120    # Best achieved
+      frame_time:
+        current_ms: 16.1  # Current frame time
+        target_ms: 16.67  # Maximum for 60 FPS
+      memory:
+        scene_mb: 45      # Scene memory usage
+        texture_mb: 128   # Texture memory
+        pool_count: 5     # Active object pools
+      draw_calls:
+        current: 85
+        budget: 100       # Platform-specific budget
+      language_distribution:
+        gdscript_files: 45  # With static typing
+        csharp_files: 12    # Performance-critical systems
+
+  test_coverage_metrics: |
+    test_coverage:
+      gut_tests:
+        total: 45
+        passing: 43
+        coverage_percent: 85
+        performance_tests: 8  # Tests validating 60+ FPS
+      godottest_tests:
+        total: 20
+        passing: 20
+        coverage_percent: 80
+        physics_tests: 15     # C# physics validation
+      tdd_compliance:
+        stories_with_tests_first: 18
+        stories_without_tests: 2
+        compliance_percent: 90
+
+# ============ Godot Gate Decision Criteria ============
+# Apply these rules in order to determine gate status:
+
+gate_decision_rules: |
+  1. AUTOMATIC FAIL CONDITIONS:
+     - Performance below 60 FPS on any target platform
+     - No TDD tests (neither GUT nor GoDotTest)
+     - Memory leaks detected (signals not cleaned up)
+     - Wrong language choice causing performance issues
+     - Object pooling missing for frequently spawned entities
+     
+  2. CONCERNS CONDITIONS:
+     - Performance between 55-59 FPS
+     - TDD coverage below 80%
+     - Static typing not used in GDScript
+     - LINQ usage in C# hot paths
+     - Scene transitions exceeding 3 seconds
+     
+  3. PASS CONDITIONS:
+     - Consistent 60+ FPS across all platforms
+     - GUT/GoDotTest coverage >= 80%
+     - Appropriate language choices (GDScript for logic, C# for performance)
+     - Object pooling implemented for all spawned entities
+     - All signals properly connected and cleaned up
+     
+  4. WAIVER ONLY WITH:
+     - Product Owner approval
+     - Clear remediation plan
+     - Timeline for fixing issues
+     - Risk acceptance documented