ros/BMAD-METHOD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Feature/expansionpack 2d unity game dev (#332)

Browse Source 
* Added 1.0 files

* Converted agents, and templates to new format. Updated filenames to include extensions like in unity-2d-game-team.yaml, Updated some wordage in workflow, config, and increased minor version number

* Forgot to remove unused startup section in game-sm since it's moved to activation-instructions, now fixed.

* Updated verbosity for development workflow in development-guidenlines.md

* built the web-dist files for the expansion pack

* Synched with main repo and rebuilt dist

* Added enforcement of game-design-checklist to designer persona

* Updated with new changes to phaser epack that seem relevant to discussion we had on discord for summarizing documentation updates

* updated dist build for our epack
This commit is contained in:
PinkyD
2025-07-18 17:14:12 -07:00
committed by GitHub
parent 47b014efa1
commit 5d81c75f4d
23 changed files with 19798 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

183
expansion-packs/bmad-2d-unity-game-dev/workflows/game-dev-greenfield.yaml Normal file
View File

@@ -0,0 +1,183 @@
workflow:
id: unity-game-dev-greenfield
name: Game Development - Greenfield Project (Unity)
description: Specialized workflow for creating 2D games from concept to implementation using Unity and C#. Guides teams through game concept development, design documentation, technical architecture, and story-driven development for professional game development.
type: greenfield
project_types:
- indie-game
- mobile-game
- web-game
- educational-game
- prototype-game
- game-jam
full_game_sequence:
- agent: game-designer
creates: game-brief.md
optional_steps:
- brainstorming_session
- game_research_prompt
- player_research
notes: 'Start with brainstorming game concepts, then create comprehensive game brief. SAVE OUTPUT: Copy final game-brief.md to your project''s docs/design/ folder.'
- agent: game-designer
creates: game-design-doc.md
requires: game-brief.md
optional_steps:
- competitive_analysis
- technical_research
notes: 'Create detailed Game Design Document using game-design-doc-tmpl. Defines all gameplay mechanics, progression, and technical requirements. SAVE OUTPUT: Copy final game-design-doc.md to your project''s docs/design/ folder.'
- agent: game-designer
creates: level-design-doc.md
requires: game-design-doc.md
optional_steps:
- level_prototyping
- difficulty_analysis
notes: 'Create level design framework using level-design-doc-tmpl. Establishes content creation guidelines and performance requirements. SAVE OUTPUT: Copy final level-design-doc.md to your project''s docs/design/ folder.'
- agent: solution-architect
creates: game-architecture.md
requires:
- game-design-doc.md
- level-design-doc.md
optional_steps:
- technical_research_prompt
- performance_analysis
- platform_research
notes: 'Create comprehensive technical architecture using game-architecture-tmpl. Defines Unity systems, performance optimization, and code structure. SAVE OUTPUT: Copy final game-architecture.md to your project''s docs/architecture/ folder.'
- agent: game-designer
validates: design_consistency
requires: all_design_documents
uses: game-design-checklist
notes: Validate all design documents for consistency, completeness, and implementability. May require updates to any design document.
- agent: various
updates: flagged_design_documents
condition: design_validation_issues
notes: If design validation finds issues, return to relevant agent to fix and re-export updated documents to docs/ folder.
project_setup_guidance:
action: guide_game_project_structure
notes: Set up Unity project structure following game architecture document. Create Assets/ with subdirectories for Scenes, Scripts, Prefabs, etc.
workflow_end:
action: move_to_story_development
notes: All design artifacts complete. Begin story-driven development phase. Use Game Scrum Master to create implementation stories from design documents.
prototype_sequence:
- step: prototype_scope
action: assess_prototype_complexity
notes: First, assess if this needs full game design (use full_game_sequence) or can be a rapid prototype.
- agent: game-designer
creates: game-brief.md
optional_steps:
- quick_brainstorming
- concept_validation
notes: 'Create focused game brief for prototype. Emphasize core mechanics and immediate playability. SAVE OUTPUT: Copy final game-brief.md to your project''s docs/ folder.'
- agent: game-designer
creates: prototype-design.md
uses: create-doc prototype-design OR create-game-story
requires: game-brief.md
notes: Create minimal design document or jump directly to implementation stories for rapid prototyping. Choose based on prototype complexity.
prototype_workflow_end:
action: move_to_rapid_implementation
notes: Prototype defined. Begin immediate implementation with Game Developer. Focus on core mechanics first, then iterate based on playtesting.
flow_diagram: |
```mermaid
graph TD
A[Start: Game Development Project] --> B{Project Scope?}
B -->|Full Game/Production| C[game-designer: game-brief.md]
B -->|Prototype/Game Jam| D[game-designer: focused game-brief.md]
C --> E[game-designer: game-design-doc.md]
E --> F[game-designer: level-design-doc.md]
F --> G[solution-architect: game-architecture.md]
G --> H[game-designer: validate design consistency]
H --> I{Design validation issues?}
I -->|Yes| J[Return to relevant agent for fixes]
I -->|No| K[Set up game project structure]
J --> H
K --> L[Move to Story Development Phase]
D --> M[game-designer: prototype-design.md]
M --> N[Move to Rapid Implementation]
C -.-> C1[Optional: brainstorming]
C -.-> C2[Optional: game research]
E -.-> E1[Optional: competitive analysis]
F -.-> F1[Optional: level prototyping]
G -.-> G1[Optional: technical research]
D -.-> D1[Optional: quick brainstorming]
style L fill:#90EE90
style N fill:#90EE90
style C fill:#FFE4B5
style E fill:#FFE4B5
style F fill:#FFE4B5
style G fill:#FFE4B5
style D fill:#FFB6C1
style M fill:#FFB6C1
```
decision_guidance:
use_full_sequence_when:
- Building commercial or production games
- Multiple team members involved
- Complex gameplay systems (3+ core mechanics)
- Long-term development timeline (2+ months)
- Need comprehensive documentation for team coordination
- Targeting multiple platforms
- Educational or enterprise game projects
use_prototype_sequence_when:
- Game jams or time-constrained development
- Solo developer or very small team
- Experimental or proof-of-concept games
- Simple mechanics (1-2 core systems)
- Quick validation of game concepts
- Learning projects or technical demos
handoff_prompts:
designer_to_gdd: Game brief is complete. Save it as docs/design/game-brief.md in your project, then create the comprehensive Game Design Document.
gdd_to_level: Game Design Document ready. Save it as docs/design/game-design-doc.md, then create the level design framework.
level_to_architect: Level design complete. Save it as docs/design/level-design-doc.md, then create the technical architecture.
architect_review: Architecture complete. Save it as docs/architecture/game-architecture.md. Please validate all design documents for consistency.
validation_issues: Design validation found issues with [document]. Please return to [agent] to fix and re-save the updated document.
full_complete: All design artifacts validated and saved. Set up game project structure and move to story development phase.
prototype_designer_to_dev: Prototype brief complete. Save it as docs/game-brief.md, then create minimal design or jump directly to implementation stories.
prototype_complete: Prototype defined. Begin rapid implementation focusing on core mechanics and immediate playability.
story_development_guidance:
epic_breakdown:
- Core Game Systems" - Fundamental gameplay mechanics and player controls
- Level Content" - Individual levels, progression, and content implementation
- User Interface" - Menus, HUD, settings, and player feedback systems
- Audio Integration" - Music, sound effects, and audio systems
- Performance Optimization" - Platform optimization and technical polish
- Game Polish" - Visual effects, animations, and final user experience
story_creation_process:
- Use Game Scrum Master to create detailed implementation stories
- Each story should reference specific GDD sections
- Include performance requirements (stable frame rate)
- Specify Unity implementation details (components, prefabs, scenes)
- Apply game-story-dod-checklist for quality validation
- Ensure stories are immediately actionable by Game Developer
game_development_best_practices:
performance_targets:
- Maintain stable frame rate on target devices throughout development
- Memory usage under specified limits per game system
- Loading times under 3 seconds for levels
- Smooth animation and responsive player controls
technical_standards:
- C# best practices compliance
- Component-based game architecture
- Object pooling for performance-critical objects
- Cross-platform input handling with the new Input System
- Comprehensive error handling and graceful degradation
playtesting_integration:
- Test core mechanics early and frequently
- Validate game balance through metrics and player feedback
- Iterate on design based on implementation discoveries
- Document design changes and rationale
success_criteria:
design_phase_complete:
- All design documents created and validated
- Technical architecture aligns with game design requirements
- Performance targets defined and achievable
- Story breakdown ready for implementation
- Project structure established
implementation_readiness:
- Development environment configured for Unity + C#
- Asset pipeline and build system established
- Testing framework in place
- Team roles and responsibilities defined
- First implementation stories created and ready

175
expansion-packs/bmad-2d-unity-game-dev/workflows/game-prototype.yaml Normal file
View File

@@ -0,0 +1,175 @@
workflow:
id: unity-game-prototype
name: Game Prototype Development (Unity)
description: Fast-track workflow for rapid game prototyping and concept validation. Optimized for game jams, proof-of-concept development, and quick iteration on game mechanics using Unity and C#.
type: prototype
project_types:
- game-jam
- proof-of-concept
- mechanic-test
- technical-demo
- learning-project
- rapid-iteration
prototype_sequence:
- step: concept_definition
agent: game-designer
duration: 15-30 minutes
creates: concept-summary.md
notes: Quickly define core game concept, primary mechanic, and target experience. Focus on what makes this game unique and fun.
- step: rapid_design
agent: game-designer
duration: 30-60 minutes
creates: prototype-spec.md
requires: concept-summary.md
optional_steps:
- quick_brainstorming
- reference_research
notes: Create minimal but complete design specification. Focus on core mechanics, basic controls, and success/failure conditions.
- step: technical_planning
agent: game-developer
duration: 15-30 minutes
creates: prototype-architecture.md
requires: prototype-spec.md
notes: Define minimal technical implementation plan. Identify core Unity systems needed and performance constraints.
- step: implementation_stories
agent: game-sm
duration: 30-45 minutes
creates: prototype-stories/
requires: prototype-spec.md, prototype-architecture.md
notes: Create 3-5 focused implementation stories for core prototype features. Each story should be completable in 2-4 hours.
- step: iterative_development
agent: game-developer
duration: varies
implements: prototype-stories/
notes: Implement stories in priority order. Test frequently in the Unity Editor and adjust design based on what feels fun. Document discoveries.
workflow_end:
action: prototype_evaluation
notes: 'Prototype complete. Evaluate core mechanics, gather feedback, and decide next steps: iterate, expand, or archive.'
game_jam_sequence:
- step: jam_concept
agent: game-designer
duration: 10-15 minutes
creates: jam-concept.md
notes: Define game concept based on jam theme. One sentence core mechanic, basic controls, win condition.
- step: jam_implementation
agent: game-developer
duration: varies (jam timeline)
creates: working-prototype
requires: jam-concept.md
notes: Directly implement core mechanic in Unity. No formal stories - iterate rapidly on what's fun. Document major decisions.
jam_workflow_end:
action: jam_submission
notes: Submit to game jam. Capture lessons learned and consider post-jam development if concept shows promise.
flow_diagram: |
```mermaid
graph TD
A[Start: Prototype Project] --> B{Development Context?}
B -->|Standard Prototype| C[game-designer: concept-summary.md]
B -->|Game Jam| D[game-designer: jam-concept.md]
C --> E[game-designer: prototype-spec.md]
E --> F[game-developer: prototype-architecture.md]
F --> G[game-sm: create prototype stories]
G --> H[game-developer: iterative implementation]
H --> I[Prototype Evaluation]
D --> J[game-developer: direct implementation]
J --> K[Game Jam Submission]
E -.-> E1[Optional: quick brainstorming]
E -.-> E2[Optional: reference research]
style I fill:#90EE90
style K fill:#90EE90
style C fill:#FFE4B5
style E fill:#FFE4B5
style F fill:#FFE4B5
style G fill:#FFE4B5
style H fill:#FFE4B5
style D fill:#FFB6C1
style J fill:#FFB6C1
```
decision_guidance:
use_prototype_sequence_when:
- Learning new game development concepts
- Testing specific game mechanics
- Building portfolio pieces
- Have 1-7 days for development
- Need structured but fast development
- Want to validate game concepts before full development
use_game_jam_sequence_when:
- Participating in time-constrained game jams
- Have 24-72 hours total development time
- Want to experiment with wild or unusual concepts
- Learning through rapid iteration
- Building networking/portfolio presence
prototype_best_practices:
scope_management:
- Start with absolute minimum viable gameplay
- One core mechanic implemented well beats many mechanics poorly
- Focus on "game feel" over features
- Cut features ruthlessly to meet timeline
rapid_iteration:
- Test the game every 1-2 hours of development in the Unity Editor
- Ask "Is this fun?" frequently during development
- Be willing to pivot mechanics if they don't feel good
- Document what works and what doesn't
technical_efficiency:
- Use simple graphics (geometric shapes, basic sprites)
- Leverage Unity's built-in components heavily
- Avoid complex custom systems in prototypes
- Prioritize functional over polished
prototype_evaluation_criteria:
core_mechanic_validation:
- Is the primary mechanic engaging for 30+ seconds?
- Do players understand the mechanic without explanation?
- Does the mechanic have depth for extended play?
- Are there natural difficulty progression opportunities?
technical_feasibility:
- Does the prototype run at acceptable frame rates?
- Are there obvious technical blockers for expansion?
- Is the codebase clean enough for further development?
- Are performance targets realistic for full game?
player_experience:
- Do testers engage with the game voluntarily?
- What emotions does the game create in players?
- Are players asking for "just one more try"?
- What do players want to see added or changed?
post_prototype_options:
iterate_and_improve:
action: continue_prototyping
when: Core mechanic shows promise but needs refinement
next_steps: Create new prototype iteration focusing on identified improvements
expand_to_full_game:
action: transition_to_full_development
when: Prototype validates strong game concept
next_steps: Use game-dev-greenfield workflow to create full game design and architecture
pivot_concept:
action: new_prototype_direction
when: Current mechanic doesn't work but insights suggest new direction
next_steps: Apply learnings to new prototype concept
archive_and_learn:
action: document_learnings
when: Prototype doesn't work but provides valuable insights
next_steps: Document lessons learned and move to next prototype concept
time_boxing_guidance:
concept_phase: Maximum 30 minutes - if you can't explain the game simply, simplify it
design_phase: Maximum 1 hour - focus on core mechanics only
planning_phase: Maximum 30 minutes - identify critical path to playable prototype
implementation_phase: Time-boxed iterations - test every 2-4 hours of work
success_metrics:
development_velocity:
- Playable prototype in first day of development
- Core mechanic demonstrable within 4-6 hours of coding
- Major iteration cycles completed in 2-4 hour blocks
learning_objectives:
- Clear understanding of what makes the mechanic fun (or not)
- Technical feasibility assessment for full development
- Player reaction and engagement validation
- Design insights for future development
handoff_prompts:
concept_to_design: Game concept defined. Create minimal design specification focusing on core mechanics and player experience.
design_to_technical: Design specification ready. Create technical implementation plan for rapid prototyping.
technical_to_stories: Technical plan complete. Create focused implementation stories for prototype development.
stories_to_implementation: Stories ready. Begin iterative implementation with frequent playtesting and design validation.
prototype_to_evaluation: Prototype playable. Evaluate core mechanics, gather feedback, and determine next development steps.