diff --git a/expansion-packs/bmad-2d-unity-game-dev/agents/game-sm.md b/expansion-packs/bmad-2d-unity-game-dev/agents/game-sm.md index 6717367c..c22d78e4 100644 --- a/expansion-packs/bmad-2d-unity-game-dev/agents/game-sm.md +++ b/expansion-packs/bmad-2d-unity-game-dev/agents/game-sm.md @@ -50,16 +50,17 @@ persona: commands: - help: Show numbered list of the following commands to allow selection - draft: Execute task create-game-story.md - - correct-course: Execute task correct-course.md + - correct-course: Execute task correct-course-game.md - story-checklist: Execute task execute-checklist.md with checklist game-story-dod-checklist.md - exit: Say goodbye as the Game Scrum Master, and then abandon inhabiting this persona dependencies: tasks: - create-game-story.md - execute-checklist.md - - correct-course.md + - correct-course-game.md templates: - game-story-tmpl.yaml checklists: - game-story-dod-checklist.md + - game-change-checklist.md ``` diff --git a/expansion-packs/bmad-2d-unity-game-dev/checklists/game-change-checklist.md b/expansion-packs/bmad-2d-unity-game-dev/checklists/game-change-checklist.md new file mode 100644 index 00000000..708f6fc0 --- /dev/null +++ b/expansion-packs/bmad-2d-unity-game-dev/checklists/game-change-checklist.md @@ -0,0 +1,203 @@ +# Game Development Change Navigation Checklist + +**Purpose:** To systematically guide the Game SM agent and user through analysis and planning when a significant change (performance issue, platform constraint, technical blocker, gameplay feedback) is identified during Unity game development. + +**Instructions:** Review each item with the user. Mark `[x]` for completed/confirmed, `[N/A]` if not applicable, or add notes for discussion points. + +[[LLM: INITIALIZATION INSTRUCTIONS - GAME CHANGE NAVIGATION + +Changes during game development are common - performance issues, platform constraints, gameplay feedback, and technical limitations are part of the process. + +Before proceeding, understand: + +1. This checklist is for SIGNIFICANT changes affecting game architecture or features +2. Minor tweaks (shader adjustments, UI positioning) don't require this process +3. The goal is to maintain playability while adapting to technical realities +4. Performance and player experience are paramount + +Required context: + +- The triggering issue (performance metrics, crash logs, feedback) +- Current development state (implemented features, current sprint) +- Access to GDD, technical specs, and performance budgets +- Understanding of remaining features and milestones + +APPROACH: +This is an interactive process. Discuss performance implications, platform constraints, and player impact. The user makes final decisions, but provide expert Unity/game dev guidance. + +REMEMBER: Game development is iterative. Changes often lead to better gameplay and performance.]] + +--- + +## 1. Understand the Trigger & Context + +[[LLM: Start by understanding the game-specific issue. Ask technical questions: + +- What performance metrics triggered this? (FPS, memory, load times) +- Is this platform-specific or universal? +- Can we reproduce it consistently? +- What Unity profiler data do we have? +- Is this a gameplay issue or technical constraint? + +Focus on measurable impacts and technical specifics.]] + +- [ ] **Identify Triggering Element:** Clearly identify the game feature/system revealing the issue. +- [ ] **Define the Issue:** Articulate the core problem precisely. + - [ ] Performance bottleneck (CPU/GPU/Memory)? + - [ ] Platform-specific limitation? + - [ ] Unity engine constraint? + - [ ] Gameplay/balance issue from playtesting? + - [ ] Asset pipeline or build size problem? + - [ ] Third-party SDK/plugin conflict? +- [ ] **Assess Performance Impact:** Document specific metrics (current FPS, target FPS, memory usage, build size). +- [ ] **Gather Technical Evidence:** Note profiler data, crash logs, platform test results, player feedback. + +## 2. Game Feature Impact Assessment + +[[LLM: Game features are interconnected. Evaluate systematically: + +1. Can we optimize the current feature without changing gameplay? +2. Do dependent features need adjustment? +3. Are there platform-specific workarounds? +4. Does this affect our performance budget allocation? + +Consider both technical and gameplay impacts.]] + +- [ ] **Analyze Current Sprint Features:** + - [ ] Can the current feature be optimized (LOD, pooling, batching)? + - [ ] Does it need gameplay simplification? + - [ ] Should it be platform-specific (high-end only)? +- [ ] **Analyze Dependent Systems:** + - [ ] Review all game systems interacting with the affected feature. + - [ ] Do physics systems need adjustment? + - [ ] Are UI/HUD systems impacted? + - [ ] Do save/load systems require changes? + - [ ] Are multiplayer systems affected? +- [ ] **Summarize Feature Impact:** Document effects on gameplay systems and technical architecture. + +## 3. Game Artifact Conflict & Impact Analysis + +[[LLM: Game documentation drives development. Check each artifact: + +1. Does this invalidate GDD mechanics? +2. Are technical architecture assumptions still valid? +3. Do performance budgets need reallocation? +4. Are platform requirements still achievable? + +Missing conflicts cause performance issues later.]] + +- [ ] **Review GDD:** + - [ ] Does the issue conflict with core gameplay mechanics? + - [ ] Do game features need scaling for performance? + - [ ] Are progression systems affected? + - [ ] Do balance parameters need adjustment? +- [ ] **Review Technical Architecture:** + - [ ] Does the issue conflict with Unity architecture (scene structure, prefab hierarchy)? + - [ ] Are component systems impacted? + - [ ] Do shader/rendering approaches need revision? + - [ ] Are data structures optimal for the scale? +- [ ] **Review Performance Specifications:** + - [ ] Are target framerates still achievable? + - [ ] Do memory budgets need reallocation? + - [ ] Are load time targets realistic? + - [ ] Do we need platform-specific targets? +- [ ] **Review Asset Specifications:** + - [ ] Do texture resolutions need adjustment? + - [ ] Are model poly counts appropriate? + - [ ] Do audio compression settings need changes? + - [ ] Is the animation budget sustainable? +- [ ] **Summarize Artifact Impact:** List all game documents requiring updates. + +## 4. Path Forward Evaluation + +[[LLM: Present game-specific solutions with technical trade-offs: + +1. What's the performance gain? +2. How much rework is required? +3. What's the player experience impact? +4. Are there platform-specific solutions? +5. Is this maintainable across updates? + +Be specific about Unity implementation details.]] + +- [ ] **Option 1: Optimization Within Current Design:** + - [ ] Can performance be improved through Unity optimizations? + - [ ] Object pooling implementation? + - [ ] LOD system addition? + - [ ] Texture atlasing? + - [ ] Draw call batching? + - [ ] Shader optimization? + - [ ] Define specific optimization techniques. + - [ ] Estimate performance improvement potential. +- [ ] **Option 2: Feature Scaling/Simplification:** + - [ ] Can the feature be simplified while maintaining fun? + - [ ] Identify specific elements to scale down. + - [ ] Define platform-specific variations. + - [ ] Assess player experience impact. +- [ ] **Option 3: Architecture Refactor:** + - [ ] Would restructuring improve performance significantly? + - [ ] Identify Unity-specific refactoring needs: + - [ ] Scene organization changes? + - [ ] Prefab structure optimization? + - [ ] Component system redesign? + - [ ] State machine optimization? + - [ ] Estimate development effort. +- [ ] **Option 4: Scope Adjustment:** + - [ ] Can we defer features to post-launch? + - [ ] Should certain features be platform-exclusive? + - [ ] Do we need to adjust milestone deliverables? +- [ ] **Select Recommended Path:** Choose based on performance gain vs. effort. + +## 5. Game Development Change Proposal Components + +[[LLM: The proposal must include technical specifics: + +1. Performance metrics (before/after projections) +2. Unity implementation details +3. Platform-specific considerations +4. Testing requirements +5. Risk mitigation strategies + +Make it actionable for game developers.]] + +(Ensure all points from previous sections are captured) + +- [ ] **Technical Issue Summary:** Performance/technical problem with metrics. +- [ ] **Feature Impact Summary:** Affected game systems and dependencies. +- [ ] **Performance Projections:** Expected improvements from chosen solution. +- [ ] **Implementation Plan:** Unity-specific technical approach. +- [ ] **Platform Considerations:** Any platform-specific implementations. +- [ ] **Testing Strategy:** Performance benchmarks and validation approach. +- [ ] **Risk Assessment:** Technical risks and mitigation plans. +- [ ] **Updated Game Stories:** Revised stories with technical constraints. + +## 6. Final Review & Handoff + +[[LLM: Game changes require technical validation. Before concluding: + +1. Are performance targets clearly defined? +2. Is the Unity implementation approach clear? +3. Do we have rollback strategies? +4. Are test scenarios defined? +5. Is platform testing covered? + +Get explicit approval on technical approach. + +FINAL REPORT: +Provide a technical summary: + +- Performance issue and root cause +- Chosen solution with expected gains +- Implementation approach in Unity +- Testing and validation plan +- Timeline and milestone impacts + +Keep it technically precise and actionable.]] + +- [ ] **Review Checklist:** Confirm all technical aspects discussed. +- [ ] **Review Change Proposal:** Ensure Unity implementation details are clear. +- [ ] **Performance Validation:** Define how we'll measure success. +- [ ] **User Approval:** Obtain approval for technical approach. +- [ ] **Developer Handoff:** Ensure game-dev agent has all technical details needed. + +--- diff --git a/expansion-packs/bmad-2d-unity-game-dev/tasks/correct-course-game.md b/expansion-packs/bmad-2d-unity-game-dev/tasks/correct-course-game.md new file mode 100644 index 00000000..c0f1173b --- /dev/null +++ b/expansion-packs/bmad-2d-unity-game-dev/tasks/correct-course-game.md @@ -0,0 +1,151 @@ +# Correct Course Task - Game Development + +## Purpose + +- Guide a structured response to game development change triggers using the `{root}/checklists/game-change-checklist`. +- Analyze the impacts of changes on game features, technical systems, and milestone deliverables. +- Explore game-specific solutions (e.g., performance optimizations, feature scaling, platform adjustments). +- Draft specific, actionable proposed updates to affected game artifacts (e.g., GDD sections, technical specs, Unity configurations). +- Produce a consolidated "Game Development Change Proposal" document for review and approval. +- Ensure clear handoff path for changes requiring fundamental redesign or technical architecture updates. + +## Instructions + +### 1. Initial Setup & Mode Selection + +- **Acknowledge Task & Inputs:** + + - Confirm with the user that the "Game Development Correct Course Task" is being initiated. + - Verify the change trigger (e.g., performance issue, platform constraint, gameplay feedback, technical blocker). + - Confirm access to relevant game artifacts: + - Game Design Document (GDD) + - Technical Design Documents + - Unity Architecture specifications + - Performance budgets and platform requirements + - Current sprint's game stories and epics + - Asset specifications and pipelines + - Confirm access to `{root}/checklists/game-change-checklist`. + +- **Establish Interaction Mode:** + - Ask the user their preferred interaction mode: + - **"Incrementally (Default & Recommended):** Work through the game-change-checklist section by section, discussing findings and drafting changes collaboratively. Best for complex technical or gameplay changes." + - **"YOLO Mode (Batch Processing):** Conduct batched analysis and present consolidated findings. Suitable for straightforward performance optimizations or minor adjustments." + - Confirm the selected mode and inform: "We will now use the game-change-checklist to analyze the change and draft proposed updates specific to our Unity game development context." + +### 2. Execute Game Development Checklist Analysis + +- Systematically work through the game-change-checklist sections: + + 1. **Change Context & Game Impact** + 2. **Feature/System Impact Analysis** + 3. **Technical Artifact Conflict Resolution** + 4. **Performance & Platform Evaluation** + 5. **Path Forward Recommendation** + +- For each checklist section: + - Present game-specific prompts and considerations + - Analyze impacts on: + - Unity scenes and prefabs + - Component dependencies + - Performance metrics (FPS, memory, build size) + - Platform-specific code paths + - Asset loading and management + - Third-party plugins/SDKs + - Discuss findings with clear technical context + - Record status: `[x] Addressed`, `[N/A]`, `[!] Further Action Needed` + - Document Unity-specific decisions and constraints + +### 3. Draft Game-Specific Proposed Changes + +Based on the analysis and agreed path forward: + +- **Identify affected game artifacts requiring updates:** + + - GDD sections (mechanics, systems, progression) + - Technical specifications (architecture, performance targets) + - Unity-specific configurations (build settings, quality settings) + - Game story modifications (scope, acceptance criteria) + - Asset pipeline adjustments + - Platform-specific adaptations + +- **Draft explicit changes for each artifact:** + + - **Game Stories:** Revise story text, Unity-specific acceptance criteria, technical constraints + - **Technical Specs:** Update architecture diagrams, component hierarchies, performance budgets + - **Unity Configurations:** Propose settings changes, optimization strategies, platform variants + - **GDD Updates:** Modify feature descriptions, balance parameters, progression systems + - **Asset Specifications:** Adjust texture sizes, model complexity, audio compression + - **Performance Targets:** Update FPS goals, memory limits, load time requirements + +- **Include Unity-specific details:** + - Prefab structure changes + - Scene organization updates + - Component refactoring needs + - Shader/material optimizations + - Build pipeline modifications + +### 4. Generate "Game Development Change Proposal" + +- Create a comprehensive proposal document containing: + + **A. Change Summary:** + + - Original issue (performance, gameplay, technical constraint) + - Game systems affected + - Platform/performance implications + - Chosen solution approach + + **B. Technical Impact Analysis:** + + - Unity architecture changes needed + - Performance implications (with metrics) + - Platform compatibility effects + - Asset pipeline modifications + - Third-party dependency impacts + + **C. Specific Proposed Edits:** + + - For each game story: "Change Story GS-X.Y from: [old] To: [new]" + - For technical specs: "Update Unity Architecture Section X: [changes]" + - For GDD: "Modify [Feature] in Section Y: [updates]" + - For configurations: "Change [Setting] from [old_value] to [new_value]" + + **D. Implementation Considerations:** + + - Required Unity version updates + - Asset reimport needs + - Shader recompilation requirements + - Platform-specific testing needs + +### 5. Finalize & Determine Next Steps + +- Obtain explicit approval for the "Game Development Change Proposal" +- Provide the finalized document to the user + +- **Based on change scope:** + + - **Minor adjustments (can be handled in current sprint):** + - Confirm task completion + - Suggest handoff to game-dev agent for implementation + - Note any required playtesting validation + - **Major changes (require replanning):** + - Clearly state need for deeper technical review + - Recommend engaging Game Architect or Technical Lead + - Provide proposal as input for architecture revision + - Flag any milestone/deadline impacts + +## Output Deliverables + +- **Primary:** "Game Development Change Proposal" document containing: + + - Game-specific change analysis + - Technical impact assessment with Unity context + - Platform and performance considerations + - Clearly drafted updates for all affected game artifacts + - Implementation guidance and constraints + +- **Secondary:** Annotated game-change-checklist showing: + - Technical decisions made + - Performance trade-offs considered + - Platform-specific accommodations + - Unity-specific implementation notes