BMAD-METHOD/expansion-packs/bmad-godot-game-dev/checklists/game-story-dod-checklist.md

Game Development Story Definition of Done (DoD) Checklist (Godot)

Instructions for Developer Agent

Before marking a story as 'Ready for Review', please go through each item in this checklist. Report the status of each item (e.g., [x] Done, [ ] Not Done, [N/A] Not Applicable) and provide brief comments if necessary.

[[LLM: INITIALIZATION INSTRUCTIONS - GODOT GAME STORY DOD VALIDATION

This checklist is for GAME DEVELOPER AGENTS to self-validate their Godot implementation work before marking a story complete.

IMPORTANT: This is a self-assessment following TDD principles. Be honest about what's actually done vs what should be done. Performance targets (60+ FPS) are non-negotiable.

EXECUTION APPROACH:

1. Verify tests were written FIRST (TDD compliance)
2. Go through each section systematically
3. Mark items as Done, Not Done, or [N/A] Not Applicable
4. Add brief comments explaining any or [N/A] items
5. Report performance metrics (FPS, draw calls, memory)
6. Flag any technical debt or optimization needs

The goal is performant, tested, quality delivery following John Carmack's optimization philosophy.]]

Checklist Items

1. Test-Driven Development Compliance:

   LLM: TDD is mandatory. Tests must be written FIRST. No exceptions.

   • Tests were written BEFORE implementation (Red phase)
   • Tests initially failed as expected
   • Implementation made tests pass (Green phase)
   • Code was refactored while maintaining passing tests (Refactor phase)
   • GUT tests written for all GDScript code
   • GoDotTest tests written for all C# code
   • Test coverage meets 80% minimum requirement
   • Performance benchmarks defined and passing

2. Requirements & Game Design:

   LLM: Requirements drive implementation. GDD alignment is critical.

   • All functional requirements from story implemented
   • All acceptance criteria met and tested
   • Game Design Document (GDD) requirements implemented
   • Player experience goals achieved
   • Core gameplay loop functions correctly
   • Fun factor validated through testing

3. Godot Standards & Architecture:

   LLM: Godot best practices ensure maintainability and performance.

   • Node hierarchy follows Godot conventions
   • Scene composition patterns properly used
   • Signal connections documented and optimized
   • Autoload/singleton usage justified
   • Resource system used appropriately
   • Export variables properly configured
   • Node groups used for efficient queries
   • Scene inheritance utilized where appropriate

4. Code Quality & Language Strategy:

   LLM: Language choice impacts performance. GDScript for iteration, C# for computation.

   • GDScript code uses static typing throughout
   • C# code follows .NET conventions
   • Language choice (GDScript vs C#) justified for each system
   • Interop between languages minimized
   • Memory management patterns followed (pooling, references)
   • No GDScript/C# marshalling in hot paths
   • Code comments explain optimization decisions
   • No new script errors or warnings

5. Performance Validation:

   LLM: 60+ FPS is the minimum, not the target. Profile everything.

   • Stable 60+ FPS achieved on target hardware
   • Frame time consistently under 16.67ms
   • Draw calls within budget for scene type
   • Memory usage within platform limits
   • No memory leaks detected
   • Object pooling implemented where needed
   • Godot profiler shows no bottlenecks
   • Performance regression tests pass

6. Platform Testing:

   LLM: Test on all target platforms. Platform-specific issues kill games.

   • Functionality verified in Godot Editor
   • Desktop export tested (Windows/Mac/Linux)
   • Mobile export tested if applicable (iOS/Android)
   • Web export tested if applicable (HTML5)
   • Input handling works on all platforms
   • Platform-specific optimizations applied
   • Export settings properly configured
   • Build sizes within acceptable limits

7. Game Functionality:

   LLM: Games must be fun AND functional. Test the player experience.

   • Game mechanics work as specified
   • Player controls responsive (<50ms input latency)
   • UI elements function correctly (Control nodes)
   • Audio integration works (AudioStreamPlayer)
   • Visual feedback and animations smooth
   • Particle effects within performance budget
   • Save/load system functions correctly
   • Scene transitions work smoothly

8. Testing Coverage:

   LLM: Comprehensive testing prevents player frustration.

   • Unit tests (GUT/GoDotTest) all passing
   • Integration tests for scene interactions pass
   • Performance tests meet benchmarks
   • Edge cases and error conditions handled
   • Multiplayer tests pass (if applicable)
   • Platform-specific tests complete
   • Regression tests for existing features pass
   • Manual playtesting completed

9. Story Administration:

   LLM: Documentation enables team collaboration.

   • All tasks within story marked complete
   • Implementation decisions documented
   • Performance optimizations noted
   • File List section updated with all changes
   • Debug Log references added
   • Completion Notes comprehensive
   • Change Log updated
   • Status set to 'Ready for Review'

10. Project & Dependencies:

    LLM: Project must build and run. Dependencies must be justified.

    • Godot project opens without errors
    • Project exports successfully for all platforms
    • Any new plugins/addons pre-approved
    • Asset import settings optimized
    • Project settings properly configured
    • Version control files (.tscn/.tres) clean
    • No uncommitted debug code
    • Build automation scripts updated

11. Optimization & Polish:

    LLM: Following Carmack's philosophy - measure, optimize, verify.

    • Hot paths identified and optimized
    • Critical code moved to C# if needed
    • Draw call batching implemented
    • Texture atlasing used where appropriate
    • LOD system implemented if needed
    • Occlusion culling configured
    • Static typing used throughout GDScript
    • Signal connections optimized

12. Documentation:

    LLM: Good documentation prevents future confusion.

    • GDScript documentation comments complete
    • C# XML documentation complete
    • Node purposes documented in scenes
    • Export variable tooltips added
    • Performance notes included
    • Platform-specific notes documented
    • Known issues or limitations noted

Performance Metrics Report

LLM: Report actual performance metrics, not estimates.

• Frame Rate: ___ FPS (Target: 60+)
• Frame Time: ___ ms (Target: <16.67ms)
• Draw Calls: _ (Budget: _)
• Memory Usage: _ MB (Limit: _)
• Scene Load Time: ___ seconds
• Input Latency: ___ ms
• Test Coverage: ___% (Minimum: 80%)

Final Confirmation

[[LLM: FINAL GODOT DOD SUMMARY

After completing the checklist:

1. Confirm TDD was followed (tests written first)
2. Report performance metrics with specific numbers
3. List any items marked with explanations
4. Identify optimization opportunities
5. Note any technical debt created
6. Confirm the story is truly ready for review
7. State whether 60+ FPS target is met

Remember Carmack's principle: "Focus on what matters: framerate and responsiveness."

Be honest - performance issues and bugs found now are easier to fix than after release.]]

• I, the Game Developer Agent, confirm that:
  • TDD was followed (tests written first)
  • All applicable items above have been addressed
  • Performance targets (60+ FPS) are met
  • Tests provide 80%+ coverage
  • The story is ready for review