ldy26098
/
BMAD-METHOD
mirror of https://github.com/bmad-code-org/BMAD-METHOD.git
1
0
Fork 0
Code Packages Projects Releases Wiki Activity

Merge branch 'main' into main

This commit is contained in:
Brian 2026-01-18 00:25:01 -06:00 committed by GitHub
parent 97721ea7ac 4a983d64a7
commit 3f73cf1f23
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
281 changed files with 1000 additions and 45221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.github/workflows/bundle-latest.yaml vendored
View File

@ -10,6 +10,7 @@ permissions:
jobs: jobs:
bundle-and-publish: bundle-and-publish:
if: ${{ false }} # Temporarily disabled while web bundles are paused.
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- name: Checkout BMAD-METHOD - name: Checkout BMAD-METHOD

10
.gitignore vendored
View File

@ -44,22 +44,15 @@ CLAUDE.local.md
.claude/settings.local.json .claude/settings.local.json
# Project-specific # Project-specific
_bmad-core
_bmad-creator-tools
flattened-codebase.xml
*.stats.md *.stats.md
.internal-docs/
#UAT template testing output files
tools/template-test-generator/test-scenarios/
# Bundler temporary files and generated bundles # Bundler temporary files and generated bundles
.bundler-temp/ .bundler-temp/
web-bundles/
# Generated web bundles (built by CI, not committed) # Generated web bundles (built by CI, not committed)
src/modules/bmm/sub-modules/ src/modules/bmm/sub-modules/
src/modules/bmb/sub-modules/ src/modules/bmb/sub-modules/
src/modules/cis/sub-modules/
src/modules/bmgd/sub-modules/
shared-modules shared-modules
z*/ z*/
@ -68,6 +61,7 @@ _bmad-output
.claude .claude
.codex .codex
.github/chatmodes .github/chatmodes
.github/agents
.agent .agent
.agentvibes/ .agentvibes/
.kiro/ .kiro/

9
docs/explanation/agents/index.md
View File

@ -7,11 +7,10 @@ Comprehensive guides to BMad's AI agents — their roles, capabilities, and how
## Agent Guides ## Agent Guides
| Agent | Description | | Agent | Description |
|-------|-------------| | ------------------------------------------------------------------------------- | ---------------------------------------------------- |
| **[Agent Roles](/docs/explanation/core-concepts/agent-roles.md)** | Overview of all BMM agent roles and responsibilities | | **[Agent Roles](/docs/explanation/core-concepts/agent-roles.md)** | Overview of all BMM agent roles and responsibilities |
| **[Quick Flow Solo Dev (Barry)](/docs/explanation/agents/barry-quick-flow.md)** | The dedicated agent for rapid development | | **[Quick Flow Solo Dev (Barry)](/docs/explanation/agents/barry-quick-flow.md)** | The dedicated agent for rapid development |
| **[Game Development Agents](/docs/explanation/game-dev/agents.md)** | Complete guide to BMGD's specialized game dev agents |
## Getting Started ## Getting Started

9
docs/explanation/core-concepts/what-are-modules.md
View File

@ -13,7 +13,7 @@ A module is a self-contained package that includes:
- **Configuration** - Module-specific settings - **Configuration** - Module-specific settings
- **Documentation** - Usage guides and reference - **Documentation** - Usage guides and reference
## Official Modules ## Official BMad Method and Builder Modules
:::note[Core is Always Installed] :::note[Core is Always Installed]
The Core module is automatically included with every BMad installation. It provides the foundation that other modules build upon. The Core module is automatically included with every BMad installation. It provides the foundation that other modules build upon.
@ -37,17 +37,24 @@ Create custom solutions:
- Workflow authoring tools - Workflow authoring tools
- Module scaffolding - Module scaffolding
## Additional Official BMad Modules
These are officially maintained modules by BMad but have their own repo's and docs.
These give a good idea also of what can be done with the BMad builder and creating your own custom modules.
### Creative Intelligence Suite (CIS) ### Creative Intelligence Suite (CIS)
Innovation and creativity: Innovation and creativity:
- Creative thinking techniques - Creative thinking techniques
- Innovation strategy workflows - Innovation strategy workflows
- Storytelling and ideation - Storytelling and ideation
- [Available Here](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
### BMad Game Dev (BMGD) ### BMad Game Dev (BMGD)
Game development specialization: Game development specialization:
- Game design workflows - Game design workflows
- Narrative development - Narrative development
- Performance testing frameworks - Performance testing frameworks
- [Available Here](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
## Module Structure ## Module Structure

2
docs/explanation/core-concepts/what-are-workflows.md
View File

@ -163,7 +163,7 @@ Before building a workflow, answer these questions:
The best way to understand workflows is to study real examples. Look at the official BMad modules: The best way to understand workflows is to study real examples. Look at the official BMad modules:
- **BMB (Module Builder)**: Workflow and agent creation workflows - **BMB (Module Builder)**: Module, Workflow and Agent creation workflows
- **BMM (Business Method Module)**: Complete software development pipeline from brainstorming through sprint planning - **BMM (Business Method Module)**: Complete software development pipeline from brainstorming through sprint planning
- **BMGD (Game Development Module)**: Game design briefs, narratives, architecture - **BMGD (Game Development Module)**: Game design briefs, narratives, architecture
- **CIS (Creativity, Innovation, Strategy)**: Brainstorming, design thinking, storytelling, innovation strategy - **CIS (Creativity, Innovation, Strategy)**: Brainstorming, design thinking, storytelling, innovation strategy

103
docs/explanation/creative-intelligence/index.md
View File

@ -1,103 +0,0 @@
---
title: "Creative Intelligence Suite (CIS)"
description: AI-powered creative facilitation with the Creative Intelligence Suite
---
AI-powered creative facilitation transforming strategic thinking through expert coaching across five specialized domains.
## Core Capabilities
CIS provides structured creative methodologies through distinctive agent personas who act as master facilitators, drawing out insights through strategic questioning rather than generating solutions directly.
## Specialized Agents
- **Carson** - Brainstorming Specialist (energetic facilitator)
- **Maya** - Design Thinking Maestro (jazz-like improviser)
- **Dr. Quinn** - Problem Solver (detective-scientist hybrid)
- **Victor** - Innovation Oracle (bold strategic precision)
- **Sophia** - Master Storyteller (whimsical narrator)
## Interactive Workflows
**5 Workflows** with **150+ Creative Techniques:**
### Brainstorming
36 techniques across 7 categories for ideation:
- Divergent/convergent thinking
- Lateral connections
- Forced associations
### Design Thinking
Complete 5-phase human-centered process:
- Empathize → Define → Ideate → Prototype → Test
- User journey mapping
- Rapid iteration
### Problem Solving
Systematic root cause analysis:
- 5 Whys, Fishbone diagrams
- Solution generation
- Impact assessment
### Innovation Strategy
Business model disruption:
- Blue Ocean Strategy
- Jobs-to-be-Done
- Disruptive innovation patterns
### Storytelling
25 narrative frameworks:
- Hero's Journey
- Story circles
- Compelling pitch structures
## Quick Start
### Direct Workflow
```bash
workflow brainstorming
workflow design-thinking --data /path/to/context.md
```
### Agent-Facilitated
```bash
agent cis/brainstorming-coach
> *brainstorm
```
## Key Differentiators
- **Facilitation Over Generation** - Guides discovery through questions
- **Energy-Aware Sessions** - Adapts to engagement levels
- **Context Integration** - Domain-specific guidance support
- **Persona-Driven** - Unique communication styles
- **Rich Method Libraries** - 150+ proven techniques
## Integration Points
CIS workflows integrate with:
- **BMM** - Powers project brainstorming
- **BMB** - Creative module design
- **Custom Modules** - Shared creative resource
## Best Practices
1. **Set clear objectives** before starting sessions
2. **Provide context documents** for domain relevance
3. **Trust the process** - Let facilitation guide you
4. **Take breaks** when energy flags
5. **Document insights** as they emerge
:::tip[Learn More]
See [Facilitation Over Generation](/docs/explanation/philosophy/facilitation-over-generation.md) for the core philosophy behind CIS.
:::

52
docs/explanation/faq/tools-faq.md
View File

@ -9,21 +9,45 @@ Quick answers to common questions about tools, IDEs, and advanced topics in the
**Tools and Technical** **Tools and Technical**
- [Why are my Mermaid diagrams not rendering?](#why-are-my-mermaid-diagrams-not-rendering) - [Questions](#questions)
- [Can I use BMM with GitHub Copilot / Cursor / other AI tools?](#can-i-use-bmm-with-github-copilot--cursor--other-ai-tools) - [Tools and Technical](#tools-and-technical)
- [What IDEs/tools support BMM?](#what-idestools-support-bmm) - [Why are my Mermaid diagrams not rendering?](#why-are-my-mermaid-diagrams-not-rendering)
- [Can I customize agents?](#can-i-customize-agents) - [Can I use BMM with GitHub Copilot / Cursor / other AI tools?](#can-i-use-bmm-with-github-copilot--cursor--other-ai-tools)
- [What happens to my planning docs after implementation?](#what-happens-to-my-planning-docs-after-implementation) - [What IDEs/tools support BMM?](#what-idestools-support-bmm)
- [Can I use BMM for non-software projects?](#can-i-use-bmm-for-non-software-projects) - [Can I customize agents?](#can-i-customize-agents)
- [What happens to my planning docs after implementation?](#what-happens-to-my-planning-docs-after-implementation)
- [Can I use BMM for non-software projects?](#can-i-use-bmm-for-non-software-projects)
- [Advanced](#advanced)
- [What if my project grows from Level 1 to Level 3?](#what-if-my-project-grows-from-level-1-to-level-3)
- [Can I mix greenfield and brownfield approaches?](#can-i-mix-greenfield-and-brownfield-approaches)
- [How do I handle urgent hotfixes during a sprint?](#how-do-i-handle-urgent-hotfixes-during-a-sprint)
- [What if I disagree with the workflow's recommendations?](#what-if-i-disagree-with-the-workflows-recommendations)
- [Can multiple developers work on the same BMM project?](#can-multiple-developers-work-on-the-same-bmm-project)
- [What is party mode and when should I use it?](#what-is-party-mode-and-when-should-i-use-it)
- [Getting Help](#getting-help)
- [Where do I get help if my question isn't answered here?](#where-do-i-get-help-if-my-question-isnt-answered-here)
- [How do I report a bug or request a feature?](#how-do-i-report-a-bug-or-request-a-feature)
**Advanced** **Advanced**
- [What if my project grows from Level 1 to Level 3?](#what-if-my-project-grows-from-level-1-to-level-3) - [Questions](#questions)
- [Can I mix greenfield and brownfield approaches?](#can-i-mix-greenfield-and-brownfield-approaches) - [Tools and Technical](#tools-and-technical)
- [How do I handle urgent hotfixes during a sprint?](#how-do-i-handle-urgent-hotfixes-during-a-sprint) - [Why are my Mermaid diagrams not rendering?](#why-are-my-mermaid-diagrams-not-rendering)
- [What if I disagree with the workflow's recommendations?](#what-if-i-disagree-with-the-workflows-recommendations) - [Can I use BMM with GitHub Copilot / Cursor / other AI tools?](#can-i-use-bmm-with-github-copilot--cursor--other-ai-tools)
- [Can multiple developers work on the same BMM project?](#can-multiple-developers-work-on-the-same-bmm-project) - [What IDEs/tools support BMM?](#what-idestools-support-bmm)
- [What is party mode and when should I use it?](#what-is-party-mode-and-when-should-i-use-it) - [Can I customize agents?](#can-i-customize-agents)
- [What happens to my planning docs after implementation?](#what-happens-to-my-planning-docs-after-implementation)
- [Can I use BMM for non-software projects?](#can-i-use-bmm-for-non-software-projects)
- [Advanced](#advanced)
- [What if my project grows from Level 1 to Level 3?](#what-if-my-project-grows-from-level-1-to-level-3)
- [Can I mix greenfield and brownfield approaches?](#can-i-mix-greenfield-and-brownfield-approaches)
- [How do I handle urgent hotfixes during a sprint?](#how-do-i-handle-urgent-hotfixes-during-a-sprint)
- [What if I disagree with the workflow's recommendations?](#what-if-i-disagree-with-the-workflows-recommendations)
- [Can multiple developers work on the same BMM project?](#can-multiple-developers-work-on-the-same-bmm-project)
- [What is party mode and when should I use it?](#what-is-party-mode-and-when-should-i-use-it)
- [Getting Help](#getting-help)
- [Where do I get help if my question isn't answered here?](#where-do-i-get-help-if-my-question-isnt-answered-here)
- [How do I report a bug or request a feature?](#how-do-i-report-a-bug-or-request-a-feature)
**Getting Help** **Getting Help**
@ -199,11 +223,11 @@ Yes! But the paradigm is fundamentally different from traditional agile teams.
### What is party mode and when should I use it? ### What is party mode and when should I use it?
Party mode is a unique multi-agent collaboration feature where ALL your installed agents (19+ from BMM, CIS, BMB, custom modules) discuss your challenges together in real-time. Party mode is a unique multi-agent collaboration feature where ALL your installed modules agents discuss your challenges together in real-time or have some fun with any topic you have in mind.
**How it works:** **How it works:**
1. Run `/bmad:core:workflows:party-mode` (or `*party-mode` from any agent) 1. Run `/bmad:core:workflows:party-mode` (or `PM or fuzzy match on party-mode` from any agent)
2. Introduce your topic 2. Introduce your topic
3. BMad Master selects 2-3 most relevant agents per message 3. BMad Master selects 2-3 most relevant agents per message
4. Agents cross-talk, debate, and build on each other's ideas 4. Agents cross-talk, debate, and build on each other's ideas

387
docs/explanation/game-dev/agents.md
View File

@ -1,387 +0,0 @@
---
title: "BMGD Agents Guide"
---
Complete reference for BMGD's six specialized game development agents.
## Agent Overview
BMGD provides six agents, each with distinct expertise:
| Agent | Name | Role | Phase Focus |
|-------|------|------|-------------|
| **Game Designer** | Samus Shepard | Lead Game Designer + Creative Vision Architect | Phases 1-2 |
| **Game Architect** | Cloud Dragonborn | Principal Game Systems Architect + Technical Director | Phase 3 |
| **Game Developer** | Link Freeman | Senior Game Developer + Technical Implementation Specialist | Phase 4 |
| **Game Scrum Master** | Max | Game Development Scrum Master + Sprint Orchestrator | Phase 4 |
| **Game QA** | GLaDOS | Game QA Architect + Test Automation Specialist | All Phases |
| **Game Solo Dev** | Indie | Elite Indie Game Developer + Quick Flow Specialist | All Phases |
## Game Designer (Samus Shepard)
### Role
Lead Game Designer + Creative Vision Architect
### Identity
Veteran designer with 15+ years crafting AAA and indie hits. Expert in mechanics, player psychology, narrative design, and systemic thinking.
### Communication Style
Talks like an excited streamer - enthusiastic, asks about player motivations, celebrates breakthroughs with "Let's GOOO!"
### Core Principles
- Design what players want to FEEL, not what they say they want
- Prototype fast - one hour of playtesting beats ten hours of discussion
- Every mechanic must serve the core fantasy
### When to Use
- Brainstorming game ideas
- Creating Game Briefs
- Designing GDDs
- Developing narrative design
### Available Commands
| Command | Description |
| ---------------------- | -------------------------------- |
| `workflow-status` | Check project status |
| `brainstorm-game` | Guided game ideation |
| `create-game-brief` | Create Game Brief |
| `create-gdd` | Create Game Design Document |
| `narrative` | Create Narrative Design Document |
| `quick-prototype` | Rapid prototyping (IDE only) |
| `party-mode` | Multi-agent collaboration |
| `advanced-elicitation` | Deep exploration (web only) |
## Game Architect (Cloud Dragonborn)
### Role
Principal Game Systems Architect + Technical Director
### Identity
Master architect with 20+ years shipping 30+ titles. Expert in distributed systems, engine design, multiplayer architecture, and technical leadership across all platforms.
### Communication Style
Speaks like a wise sage from an RPG - calm, measured, uses architectural metaphors about building foundations and load-bearing walls.
### Core Principles
- Architecture is about delaying decisions until you have enough data
- Build for tomorrow without over-engineering today
- Hours of planning save weeks of refactoring hell
- Every system must handle the hot path at 60fps
### When to Use
- Planning technical architecture
- Making engine/framework decisions
- Designing game systems
- Course correction during development
### Available Commands
| Command | Description |
| ---------------------- | ------------------------------------- |
| `workflow-status` | Check project status |
| `create-architecture` | Create Game Architecture |
| `correct-course` | Course correction analysis (IDE only) |
| `party-mode` | Multi-agent collaboration |
| `advanced-elicitation` | Deep exploration (web only) |
## Game Developer (Link Freeman)
### Role
Senior Game Developer + Technical Implementation Specialist
### Identity
Battle-hardened dev with expertise in Unity, Unreal, and custom engines. Ten years shipping across mobile, console, and PC. Writes clean, performant code.
### Communication Style
Speaks like a speedrunner - direct, milestone-focused, always optimizing for the fastest path to ship.
### Core Principles
- 60fps is non-negotiable
- Write code designers can iterate without fear
- Ship early, ship often, iterate on player feedback
- Red-green-refactor: tests first, implementation second
### When to Use
- Implementing stories
- Code reviews
- Performance optimization
- Completing story work
### Available Commands
| Command | Description |
| ---------------------- | ------------------------------- |
| `workflow-status` | Check sprint progress |
| `dev-story` | Implement story tasks |
| `code-review` | Perform code review |
| `quick-dev` | Flexible development (IDE only) |
| `quick-prototype` | Rapid prototyping (IDE only) |
| `party-mode` | Multi-agent collaboration |
| `advanced-elicitation` | Deep exploration (web only) |
## Game Scrum Master (Max)
### Role
Game Development Scrum Master + Sprint Orchestrator
### Identity
Certified Scrum Master specializing in game dev workflows. Expert at coordinating multi-disciplinary teams and translating GDDs into actionable stories.
### Communication Style
Talks in game terminology - milestones are save points, handoffs are level transitions, blockers are boss fights.
### Core Principles
- Every sprint delivers playable increments
- Clean separation between design and implementation
- Keep the team moving through each phase
- Stories are single source of truth for implementation
### When to Use
- Sprint planning and management
- Creating epic tech specs
- Writing story drafts
- Assembling story context
- Running retrospectives
- Handling course corrections
### Available Commands
| Command | Description |
| ----------------------- | ------------------------------------------- |
| `workflow-status` | Check project status |
| `sprint-planning` | Generate/update sprint status |
| `sprint-status` | View sprint progress, get next action |
| `create-story` | Create story (marks ready-for-dev directly) |
| `validate-create-story` | Validate story draft |
| `epic-retrospective` | Facilitate retrospective |
| `correct-course` | Navigate significant changes |
| `party-mode` | Multi-agent collaboration |
| `advanced-elicitation` | Deep exploration (web only) |
## Game QA (GLaDOS)
### Role
Game QA Architect + Test Automation Specialist
### Identity
Senior QA architect with 12+ years in game testing across Unity, Unreal, and Godot. Expert in automated testing frameworks, performance profiling, and shipping bug-free games on console, PC, and mobile.
### Communication Style
Speaks like a quality guardian - methodical, data-driven, but understands that "feel" matters in games. Uses metrics to back intuition. "Trust, but verify with tests."
### Core Principles
- Test what matters: gameplay feel, performance, progression
- Automated tests catch regressions, humans catch fun problems
- Every shipped bug is a process failure, not a people failure
- Flaky tests are worse than no tests - they erode trust
- Profile before optimize, test before ship
### When to Use
- Setting up test frameworks
- Designing test strategies
- Creating automated tests
- Planning playtesting sessions
- Performance testing
- Reviewing test coverage
### Available Commands
| Command | Description |
| ---------------------- | --------------------------------------------------- |
| `workflow-status` | Check project status |
| `test-framework` | Initialize game test framework (Unity/Unreal/Godot) |
| `test-design` | Create comprehensive game test scenarios |
| `automate` | Generate automated game tests |
| `playtest-plan` | Create structured playtesting plan |
| `performance-test` | Design performance testing strategy |
| `test-review` | Review test quality and coverage |
| `party-mode` | Multi-agent collaboration |
| `advanced-elicitation` | Deep exploration (web only) |
### Knowledge Base
GLaDOS has access to a comprehensive game testing knowledge base (`gametest/qa-index.csv`) including:
**Engine-Specific Testing:**
- Unity Test Framework (Edit Mode, Play Mode)
- Unreal Automation and Gauntlet
- Godot GUT (Godot Unit Test)
**Game-Specific Testing:**
- Playtesting fundamentals
- Balance testing
- Save system testing
- Multiplayer/network testing
- Input testing
- Platform certification (TRC/XR)
- Localization testing
**General QA:**
- QA automation strategies
- Performance testing
- Regression testing
- Smoke testing
- Test prioritization (P0-P3)
## Game Solo Dev (Indie)
### Role
Elite Indie Game Developer + Quick Flow Specialist
### Identity
Battle-hardened solo game developer who ships complete games from concept to launch. Expert in Unity, Unreal, and Godot, having shipped titles across mobile, PC, and console. Lives and breathes the Quick Flow workflow - prototyping fast, iterating faster, and shipping before the hype dies.
### Communication Style
Direct, confident, and gameplay-focused. Uses dev slang, thinks in game feel and player experience. Every response moves the game closer to ship. "Does it feel good? Ship it."
### Core Principles
- Prototype fast, fail fast, iterate faster
- A playable build beats a perfect design doc
- 60fps is non-negotiable - performance is a feature
- The core loop must be fun before anything else matters
- Ship early, playtest often
### When to Use
- Solo game development
- Rapid prototyping
- Quick iteration without full team workflow
- Indie projects with tight timelines
- When you want to handle everything yourself
### Available Commands
| Command | Description |
| ------------------ | ------------------------------------------------------ |
| `quick-prototype` | Rapid prototype to test if a mechanic is fun |
| `quick-dev` | Implement features end-to-end with game considerations |
| `quick-spec` | Create implementation-ready technical spec |
| `code-review` | Review code quality |
| `test-framework` | Set up automated testing |
| `party-mode` | Bring in specialists when needed |
### Quick Flow vs Full BMGD
Use **Game Solo Dev** when:
- You're working alone or in a tiny team
- Speed matters more than process
- You want to skip the full planning phases
- You're prototyping or doing game jams
Use **Full BMGD workflow** when:
- You have a larger team
- The project needs formal documentation
- You're working with stakeholders/publishers
- Long-term maintainability is critical
## Agent Selection Guide
### By Phase
| Phase | Primary Agent | Secondary Agent |
| ------------------------------ | ----------------- | ----------------- |
| 1: Preproduction | Game Designer | - |
| 2: Design | Game Designer | - |
| 3: Technical | Game Architect | Game QA |
| 4: Production (Planning) | Game Scrum Master | Game Architect |
| 4: Production (Implementation) | Game Developer | Game Scrum Master |
| Testing (Any Phase) | Game QA | Game Developer |
### By Task
| Task | Best Agent |
| -------------------------------- | ----------------- |
| "I have a game idea" | Game Designer |
| "Help me design my game" | Game Designer |
| "How should I build this?" | Game Architect |
| "What's the technical approach?" | Game Architect |
| "Plan our sprints" | Game Scrum Master |
| "Create implementation stories" | Game Scrum Master |
| "Build this feature" | Game Developer |
| "Review this code" | Game Developer |
| "Set up testing framework" | Game QA |
| "Create test plan" | Game QA |
| "Test performance" | Game QA |
| "Plan a playtest" | Game QA |
| "I'm working solo" | Game Solo Dev |
| "Quick prototype this idea" | Game Solo Dev |
| "Ship this feature fast" | Game Solo Dev |
## Multi-Agent Collaboration
### Party Mode
All agents have access to `party-mode`, which brings multiple agents together for complex decisions. Use this when:
- A decision spans multiple domains (design + technical)
- You want diverse perspectives
- You're stuck and need fresh ideas
### Handoffs
Agents naturally hand off to each other:
```
Game Designer → Game Architect → Game Scrum Master → Game Developer
↓ ↓ ↓ ↓
GDD Architecture Sprint/Stories Implementation
↓ ↓
Game QA ←──────────────────────────── Game QA
↓ ↓
Test Strategy Automated Tests
```
Game QA integrates at multiple points:
- After Architecture: Define test strategy
- During Implementation: Create automated tests
- Before Release: Performance and certification testing
## Project Context
All agents share the principle:
> "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
The `project-context.md` file (if present) serves as the authoritative source for project decisions and constraints.
## Next Steps
- **[Quick Start Guide](/docs/tutorials/getting-started/quick-start-bmgd.md)** - Get started with BMGD
- **[Workflows Guide](/docs/reference/workflows/index.md)** - Detailed workflow reference
- **[Game Types Guide](/docs/explanation/game-dev/game-types.md)** - Game type templates

125
docs/explanation/game-dev/bmgd-vs-bmm.md
View File

@ -1,125 +0,0 @@
---
title: "BMGD vs BMM"
description: Understanding the differences between BMGD and BMM
---
BMGD (BMad Game Development) extends BMM (BMad Method) with game-specific capabilities. This page explains the key differences.
## Quick Comparison
| Aspect | BMM | BMGD |
| -------------- | ------------------------------------- | ------------------------------------------------------------------------ |
| **Focus** | General software | Game development |
| **Agents** | PM, Architect, Dev, SM, TEA, Solo Dev | Game Designer, Game Dev, Game Architect, Game SM, Game QA, Game Solo Dev |
| **Planning** | PRD, Tech Spec | Game Brief, GDD |
| **Types** | N/A | 24 game type templates |
| **Narrative** | N/A | Full narrative workflow |
| **Testing** | Web-focused | Engine-specific (Unity, Unreal, Godot) |
| **Production** | BMM workflows | BMM workflows with game overrides |
## Agent Differences
### BMM Agents
- PM (Product Manager)
- Architect
- DEV (Developer)
- SM (Scrum Master)
- TEA (Test Architect)
- Quick Flow Solo Dev
### BMGD Agents
- Game Designer
- Game Developer
- Game Architect
- Game Scrum Master
- Game QA
- Game Solo Dev
BMGD agents understand game-specific concepts like:
- Game mechanics and balance
- Player psychology
- Engine-specific patterns
- Playtesting and QA
## Planning Documents
### BMM Planning
- **Product Brief** → **PRD** → **Architecture**
- Focus: Software requirements, user stories, system design
### BMGD Planning
- **Game Brief** → **GDD** → **Architecture**
- Focus: Game vision, mechanics, narrative, player experience
The GDD (Game Design Document) includes:
- Core gameplay loop
- Mechanics and systems
- Progression and balance
- Art and audio direction
- Genre-specific sections
## Game Type Templates
BMGD includes 24 game type templates that auto-configure GDD sections:
- Action, Adventure, Puzzle
- RPG, Strategy, Simulation
- Sports, Racing, Fighting
- Horror, Platformer, Shooter
- And more...
Each template provides:
- Genre-specific GDD sections
- Relevant mechanics patterns
- Testing considerations
- Common pitfalls to avoid
## Narrative Support
BMGD includes full narrative workflow for story-driven games:
- **Narrative Design** workflow
- Story structure templates
- Character development
- World-building guidelines
- Dialogue systems
BMM has no equivalent for narrative design.
## Testing Differences
### BMM Testing (TEA)
- Web-focused (Playwright, Cypress)
- API testing
- E2E for web applications
### BMGD Testing (Game QA)
- Engine-specific frameworks (Unity, Unreal, Godot)
- Gameplay testing
- Performance profiling
- Playtest planning
- Balance validation
## Production Workflow
BMGD production workflows **inherit from BMM** and add game-specific:
- Checklists
- Templates
- Quality gates
- Engine-specific considerations
This means you get all of BMM's implementation structure plus game-specific enhancements.
## When to Use Each
### Use BMM when:
- Building web applications
- Creating APIs and services
- Developing mobile apps (non-game)
- Any general software project
### Use BMGD when:
- Building video games
- Creating interactive experiences
- Game prototyping
- Game jams

447
docs/explanation/game-dev/game-types.md
View File

@ -1,447 +0,0 @@
---
title: "BMGD Game Types Guide"
---
Reference for selecting and using BMGD's 24 supported game type templates.
## Overview
When creating a GDD, BMGD offers game type templates that provide genre-specific sections. This ensures your design document covers mechanics and systems relevant to your game's genre.
## Supported Game Types
### Action & Combat
#### Action Platformer
**Tags:** action, platformer, combat, movement
Side-scrolling or 3D platforming with combat mechanics. Think Hollow Knight, Celeste with combat, or Mega Man.
**GDD sections added:**
- Movement systems (jumps, dashes, wall mechanics)
- Combat mechanics (melee/ranged, combos)
- Level design patterns
- Boss design
#### Shooter
**Tags:** shooter, combat, aiming, fps, tps
Projectile combat with aiming mechanics. Covers FPS, TPS, and arena shooters.
**GDD sections added:**
- Weapon systems
- Aiming and accuracy
- Enemy AI patterns
- Level/arena design
- Multiplayer considerations
#### Fighting
**Tags:** fighting, combat, competitive, combos, pvp
1v1 combat with combos and frame data. Traditional fighters and platform fighters.
**GDD sections added:**
- Frame data systems
- Combo mechanics
- Character movesets
- Competitive balance
- Netcode requirements
### Strategy & Tactics
#### Strategy
**Tags:** strategy, tactics, resources, planning
Resource management with tactical decisions. RTS, 4X, and grand strategy.
**GDD sections added:**
- Resource systems
- Unit/building design
- AI opponent behavior
- Map/scenario design
- Victory conditions
#### Turn-Based Tactics
**Tags:** tactics, turn-based, grid, positioning
Grid-based movement with turn order. XCOM-likes and tactical RPGs.
**GDD sections added:**
- Grid and movement systems
- Turn order mechanics
- Cover and positioning
- Unit progression
- Procedural mission generation
#### Tower Defense
**Tags:** tower-defense, waves, placement, strategy
Wave-based defense with tower placement.
**GDD sections added:**
- Tower types and upgrades
- Wave design and pacing
- Economy systems
- Map design patterns
- Meta-progression
### RPG & Progression
#### RPG
**Tags:** rpg, stats, inventory, quests, narrative
Character progression with stats, inventory, and quests.
**GDD sections added:**
- Character stats and leveling
- Inventory and equipment
- Quest system design
- Combat system (action/turn-based)
- Skill trees and builds
#### Roguelike
**Tags:** roguelike, procedural, permadeath, runs
Procedural generation with permadeath and run-based progression.
**GDD sections added:**
- Procedural generation rules
- Permadeath and persistence
- Run structure and pacing
- Item/ability synergies
- Meta-progression systems
#### Metroidvania
**Tags:** metroidvania, exploration, abilities, interconnected
Interconnected world with ability gating.
**GDD sections added:**
- World map connectivity
- Ability gating design
- Backtracking flow
- Secret and collectible placement
- Power-up progression
### Narrative & Story
#### Adventure
**Tags:** adventure, narrative, exploration, story
Story-driven exploration and narrative. Point-and-click and narrative adventures.
**GDD sections added:**
- Puzzle design
- Narrative delivery
- Exploration mechanics
- Dialogue systems
- Story branching
#### Visual Novel
**Tags:** visual-novel, narrative, choices, story
Narrative choices with branching story.
**GDD sections added:**
- Branching narrative structure
- Choice and consequence
- Character routes
- UI/presentation
- Save/load states
#### Text-Based
**Tags:** text, parser, interactive-fiction, mud
Text input/output games. Parser games, choice-based IF, MUDs.
**GDD sections added:**
- Parser or choice systems
- World model
- Narrative structure
- Text presentation
- Save state management
### Simulation & Management
#### Simulation
**Tags:** simulation, management, sandbox, systems
Realistic systems with management and building. Includes tycoons and sim games.
**GDD sections added:**
- Core simulation loops
- Economy modeling
- AI agents/citizens
- Building/construction
- Failure states
#### Sandbox
**Tags:** sandbox, creative, building, freedom
Creative freedom with building and minimal objectives.
**GDD sections added:**
- Creation tools
- Physics/interaction systems
- Persistence and saving
- Sharing/community features
- Optional objectives
### Sports & Racing
#### Racing
**Tags:** racing, vehicles, tracks, speed
Vehicle control with tracks and lap times.
**GDD sections added:**
- Vehicle physics model
- Track design
- AI opponents
- Progression/career mode
- Multiplayer racing
#### Sports
**Tags:** sports, teams, realistic, physics
Team-based or individual sports simulation.
**GDD sections added:**
- Sport-specific rules
- Player/team management
- AI opponent behavior
- Season/career modes
- Multiplayer modes
### Multiplayer
#### MOBA
**Tags:** moba, multiplayer, pvp, heroes, lanes
Multiplayer team battles with hero selection.
**GDD sections added:**
- Hero/champion design
- Lane and map design
- Team composition
- Matchmaking
- Economy (gold/items)
#### Party Game
**Tags:** party, multiplayer, minigames, casual
Local multiplayer with minigames.
**GDD sections added:**
- Minigame design patterns
- Controller support
- Round/game structure
- Scoring systems
- Player count flexibility
### Horror & Survival
#### Survival
**Tags:** survival, crafting, resources, danger
Resource gathering with crafting and persistent threats.
**GDD sections added:**
- Resource gathering
- Crafting systems
- Hunger/health/needs
- Threat systems
- Base building
#### Horror
**Tags:** horror, atmosphere, tension, fear
Atmosphere and tension with limited resources.
**GDD sections added:**
- Fear mechanics
- Resource scarcity
- Sound design
- Lighting and visibility
- Enemy/threat design
### Casual & Progression
#### Puzzle
**Tags:** puzzle, logic, cerebral
Logic-based challenges and problem-solving.
**GDD sections added:**
- Puzzle mechanics
- Difficulty progression
- Hint systems
- Level structure
- Scoring/rating
#### Idle/Incremental
**Tags:** idle, incremental, automation, progression
Passive progression with upgrades and automation.
**GDD sections added:**
- Core loop design
- Prestige systems
- Automation unlocks
- Number scaling
- Offline progress
#### Card Game
**Tags:** card, deck-building, strategy, turns
Deck building with card mechanics.
**GDD sections added:**
- Card design framework
- Deck building rules
- Mana/resource systems
- Rarity and collection
- Competitive balance
### Rhythm
#### Rhythm
**Tags:** rhythm, music, timing, beats
Music synchronization with timing-based gameplay.
**GDD sections added:**
- Note/beat mapping
- Scoring systems
- Difficulty levels
- Music licensing
- Input methods
## Hybrid Game Types
Many games combine multiple genres. BMGD supports hybrid selection:
### Examples
**Action RPG** = Action Platformer + RPG
- Movement and combat systems from Action Platformer
- Progression and stats from RPG
**Survival Horror** = Survival + Horror
- Resource and crafting from Survival
- Atmosphere and fear from Horror
**Roguelike Deckbuilder** = Roguelike + Card Game
- Run structure from Roguelike
- Card mechanics from Card Game
### How to Use Hybrids
During GDD creation, select multiple game types when prompted:
```
Agent: What game type best describes your game?
You: It's a roguelike with card game combat
Agent: I'll include sections for both Roguelike and Card Game...
```
## Game Type Selection Tips
### 1. Start with Core Fantasy
What does the player primarily DO in your game?
- Run and jump? → Platformer types
- Build and manage? → Simulation types
- Fight enemies? → Combat types
- Make choices? → Narrative types
### 2. Consider Your Loop
What's the core gameplay loop?
- Session-based runs? → Roguelike
- Long-term progression? → RPG
- Quick matches? → Multiplayer types
- Creative expression? → Sandbox
### 3. Don't Over-Combine
2-3 game types maximum. More than that usually means your design isn't focused enough.
### 4. Primary vs Secondary
One type should be primary (most gameplay time). Others add flavor:
- **Primary:** Platformer (core movement and exploration)
- **Secondary:** Metroidvania (ability gating structure)
## GDD Section Mapping
When you select a game type, BMGD adds these GDD sections:
| Game Type | Key Sections Added |
| ----------------- | -------------------------------------- |
| Action Platformer | Movement, Combat, Level Design |
| RPG | Stats, Inventory, Quests |
| Roguelike | Procedural Gen, Runs, Meta-Progression |
| Narrative | Story Structure, Dialogue, Branching |
| Multiplayer | Matchmaking, Netcode, Balance |
| Simulation | Systems, Economy, AI |
## Next Steps
- **[Quick Start Guide](/docs/tutorials/getting-started/quick-start-bmgd.md)** - Get started with BMGD
- **[Workflows Guide](/docs/reference/workflows/bmgd-workflows.md)** - GDD workflow details
- **[Glossary](/docs/reference/glossary/index.md)** - Game development terminology

70
docs/explanation/game-dev/index.md
View File

@ -1,70 +0,0 @@
---
title: "BMGD - Game Development Module"
description: AI-powered workflows for game design and development with BMGD
---
Complete guides for the BMad Game Development Module (BMGD) — AI-powered workflows for game design and development that adapt to your project's needs.
## Getting Started
**New to BMGD?** Start here:
- **[Quick Start Guide](/docs/tutorials/getting-started/quick-start-bmgd.md)** - Get started building your first game
- Installation and setup
- Understanding the game development phases
- Running your first workflows
- Agent-based development flow
:::tip[Quick Path]
Install BMGD module → Game Brief → GDD → Architecture → Build
:::
## Core Documentation
- **[Game Types Guide](/docs/explanation/game-dev/game-types.md)** - Selecting and using game type templates (24 supported types)
- **[BMGD vs BMM](/docs/explanation/game-dev/bmgd-vs-bmm.md)** - Understanding the differences
## Game Development Phases
BMGD follows four phases aligned with game development:
### Phase 1: Preproduction
- **Brainstorm Game** - Ideation with game-specific techniques
- **Game Brief** - Capture vision, market, and fundamentals
### Phase 2: Design
- **GDD (Game Design Document)** - Comprehensive game design
- **Narrative Design** - Story, characters, world (for story-driven games)
### Phase 3: Technical
- **Game Architecture** - Engine, systems, patterns, structure
### Phase 4: Production
- **Sprint Planning** - Epic and story management
- **Story Development** - Implementation workflow
- **Code Review** - Quality assurance
- **Testing** - Automated tests, playtesting, performance
- **Retrospective** - Continuous improvement
## Choose Your Path
### I need to...
**Start a new game project**
→ Start with [Quick Start Guide](/docs/tutorials/getting-started/quick-start-bmgd.md)
→ Run `brainstorm-game` for ideation
→ Create a Game Brief with `create-brief`
**Design my game**
→ Create a GDD with `create-gdd`
→ If story-heavy, add Narrative Design with `create-narrative`
**Plan the technical architecture**
→ Run `create-architecture` with the Game Architect
**Build my game**
→ Use Phase 4 production workflows
→ Follow the sprint-based development cycle
**Quickly test an idea**
→ Use [Quick-Flow](/docs/how-to/workflows/bmgd-quick-flow.md) for rapid prototyping

341
docs/explanation/philosophy/facilitation-over-generation.md
View File

@ -1,106 +1,333 @@
--- ---
title: "Facilitation Over Generation" title: "Facilitation Over Generation"
description: Understanding CIS's facilitation-first approach to creative work description: Understanding a facilitation-first approach to AI workflows and creative collaboration
--- ---
BMAD workflows take a fundamentally different approach from typical AI Prompts you will find. Instead of generating solutions directly, workflows act as facilitators who guide you through discovery processes, helping you arrive at insights and decisions yourself.
The Creative Intelligence Suite (CIS) takes a fundamentally different approach from typical AI tools. Instead of generating solutions directly, CIS agents act as master facilitators who guide you to discover insights yourself. This has always been the magic of the BMad method - if you have used it you have felt it intuitively and noticed a difference - and it is through this document I want to really explain what this is. This is fundamental to understand if you are also interested in producing your own workflows or improving upon existing ones in any BMad related module.
## The Problem with Generation ## The Problem with Generation
Traditional AI approaches to creative work: Traditional AI approaches to creative and knowledge work typically follow this pattern:
:::note[Generation Example] :::note[Generation Example]
**User:** "Give me marketing ideas" **User:** "I need a comprehensive UX design for my e-commerce app"
**AI:** "Here are 10 marketing ideas..." **AI:** [Immediately generates] "Here's a complete UX specification with modern dark theme, card-based product grid, left navigation, and checkout flow..."
::: :::
This approach: This approach:
- Produces generic, predictable outputs - Produces generic, predictable outputs that may not fit your actual needs
- Removes human ownership of ideas - Removes your ownership and understanding of the solution
- Misses context and nuance - Misses critical context, constraints, and nuance
- Limits creative exploration - Limits creative exploration to the AI's training data patterns
- Creates deliverables you can't explain or iterate on effectively
## The Facilitation Approach ## The Facilitation Approach
CIS agents use strategic questioning: Facilitative workflows use strategic questioning and guided discovery:
:::note[Facilitation Example] :::note[Facilitation Example from UX Design Workflow]
**User:** "I need marketing ideas" **User:** "I need a comprehensive UX design for my e-commerce app"
**CIS:** "What makes your customers choose you over alternatives? What's the one thing they always mention?" **Workflow:** "Welcome! I'll act as your UX facilitator to help you discover the right approach. First, let me understand what documents you already have—do you have a product brief, PRD, or any research?"
**User:** "They say our support is exceptional" **User:** "I have a product brief and some user research"
**CIS:** "Interesting! How might you make that exceptional support visible before they become customers?" **Workflow:** "Great! Let me load those. [Loads documents] Now, what are the primary user goals for your e-commerce experience? What should users be able to accomplish?"
**User:** "They need to browse products quickly and complete purchases without friction"
**Workflow:** "Interesting! And what makes your e-commerce situation unique? What are the specific challenges or constraints you're working with?"
::: :::
This approach: This approach:
- Draws out insights already within you - Draws out insights and expertise already within you
- Maintains human ownership of ideas - Maintains your ownership and understanding of decisions
- Captures context and nuance - Captures your specific context, constraints, and goals
- Enables deeper creative exploration - Enables deeper exploration of your unique situation
- Creates outputs you can confidently explain and iterate on
## Real-World Examples from BMAD Workflows
### Brainstorming Workflow (from core module)
The brainstorming workflow demonstrates pure facilitation through its entire journey:
**Session Setup:**
```
"Welcome! I'm excited to facilitate your brainstorming session. I'll guide you
through proven creativity techniques to generate innovative ideas.
**What are we brainstorming about?** (The central topic or challenge)
**What specific outcomes are you hoping for?** (Types of ideas, solutions, or insights)
```
**Technique Selection - Offering Options:**
```
"Ready to explore technique approaches?
[1] User-Selected Techniques - Browse our complete technique library
[2] AI-Recommended Techniques - Get customized suggestions based on your goals
[3] Random Technique Selection - Discover unexpected creative methods
[4] Progressive Technique Flow - Start broad, then systematically narrow focus
Which approach appeals to you most?"
```
**Technique Execution - Interactive Coaching:**
The workflow doesn't generate ideas—it coaches you through techniques with genuine back-and-forth dialogue:
```
"Let's start with: What if you could remove all practical constraints?
I'm not just looking for a quick answer - I want to explore this together.
What immediately comes to mind? Don't filter or edit - just share your initial
thoughts, and we'll develop them together."
[User responds]
"That's interesting! Tell me more about [specific aspect you mentioned].
What would that look like in practice? How does that connect to your core goal?"
```
**Key facilitation behaviors:**
- Aims for 100+ ideas before suggesting organization
- Asks "Continue exploring?" or "Move to next technique?"—user controls pace
- Uses anti-bias protocols to force thinking in new directions every 10 ideas
- Builds on user's ideas with genuine creative contributions
- Keeps user in "generative exploration mode" as long as possible
**Organization - Collaborative Synthesis:**
```
"Outstanding creative work! You've generated an incredible range of ideas.
Now let's organize these creative gems and identify your most promising opportunities.
I'm analyzing all your generated ideas to identify natural themes and patterns.
**Emerging Themes I'm Identifying:**
- Theme 1: [Name] - Ideas: [list] - Pattern: [connection]
- Theme 2: [Name] - Ideas: [list] - Pattern: [connection]
Which themes or specific ideas stand out to you as most valuable?"
```
Result: A comprehensive brainstorming session document with **your** ideas, organized by **your** priorities, with **your** action plans.
### Create UX Design Workflow (from BMM method)
The UX design workflow facilitates a 14-step journey from project understanding to complete UX specification—**never making design decisions for you**.
**Step 1: Document Discovery (Collaborative Setup)**
```
"Welcome! I've set up your UX design workspace.
**Documents Found:**
- PRD: product-requirements.md
- Product brief: brief.md
**Files loaded:** [lists specific files]
Do you have any other documents you'd like me to include, or shall we continue?"
```
**Step 2: Project Understanding (Discovery Questions)**
```
"Based on the project documentation, let me confirm what I'm understanding...
**From the documents:** [summary of key insights]
**Target Users:** [summary from documents]
**Key Features/Goals:** [summary from documents]
Does this match your understanding? Are there any corrections or additions?"
```
Then it dives deeper with targeted questions:
```
"Let me understand your users better to inform the UX design:
**User Context Questions:**
- What problem are users trying to solve?
- What frustrates them with current solutions?
- What would make them say 'this is exactly what I needed'?"
```
**Step 3: Core Experience Definition (Guiding Insights)**
```
"Now let's dig into the heart of the user experience.
**Core Experience Questions:**
- What's the ONE thing users will do most frequently?
- What user action is absolutely critical to get right?
- What should be completely effortless for users?
- If we nail one interaction, everything else follows - what is it?
Think about the core loop or primary action that defines your product's value."
```
**Step 4: Emotional Response (Feelings-Based Design)**
```
"Now let's think about how your product should make users feel.
**Emotional Response Questions:**
- What should users FEEL when using this product?
- What emotion would make them tell a friend about this?
- How should users feel after accomplishing their primary goal?
Common emotional goals: Empowered and in control? Delighted and surprised?
Efficient and productive? Creative and inspired?"
```
**Step 5: Pattern Inspiration (Learning from Examples)**
```
"Let's learn from products your users already love and use regularly.
**Inspiration Questions:**
- Name 2-3 apps your target users already love and USE frequently
- For each one, what do they do well from a UX perspective?
- What makes the experience compelling or delightful?
For each inspiring app, let's analyze their UX success:
- What core problem does it solve elegantly?
- What makes the onboarding experience effective?
- How do they handle navigation and information hierarchy?"
```
**Step 9: Design Directions (Interactive Visual Exploration)**
The workflow generates 6-8 HTML mockup variations—but **you choose**:
```
"🎨 Design Direction Mockups Generated!
I'm creating a comprehensive HTML showcase with 6-8 full-screen mockup variations.
Each mockup represents a complete visual direction for your app's look and feel.
**As you explore the design directions, look for:**
✅ Which information hierarchy matches your priorities?
✅ Which interaction style fits your core experience?
✅ Which visual density feels right for your brand?
**Which approach resonates most with you?**
- Pick a favorite direction as-is
- Combine elements from multiple directions
- Request modifications to any direction
Tell me: Which layout feels most intuitive? Which visual weight matches your brand?"
```
**Step 12: UX Patterns (Consistency Through Questions)**
```
"Let's establish consistency patterns for common situations.
**Pattern Categories to Define:**
- Button hierarchy and actions
- Feedback patterns (success, error, warning, info)
- Form patterns and validation
- Navigation patterns
Which categories are most critical for your product?
**For [Critical Pattern Category]:**
What should users see/do when they need to [pattern action]?
**Considerations:**
- Visual hierarchy (primary vs. secondary actions)
- Feedback mechanisms
- Error recovery
- Accessibility requirements
How should your product handle [pattern type] interactions?"
```
**The Result:** A complete, production-ready UX specification document that captures **your** decisions, **your** reasoning, and **your** vision—documented through guided discovery, not generation.
## Key Principles ## Key Principles
### 1. Questions Over Answers ### 1. Questions Over Answers
CIS agents ask strategic questions rather than providing direct answers. This: Facilitative workflows ask strategic questions rather than providing direct answers. This:
- Activates your own creative thinking - Activates your own creative and analytical thinking
- Uncovers assumptions - Uncovers assumptions you didn't know you had
- Reveals blind spots - Reveals blind spots in your understanding
- Builds on your domain knowledge - Builds on your domain expertise and context
### 2. Energy-Aware Sessions ### 2. Multi-Turn Conversation
CIS monitors engagement and adapts: Facilitation uses progressive discovery, not interrogation:
- Adjusts pace when energy flags - Ask 1-2 questions at a time, not laundry lists
- Suggests breaks when needed - Think about responses before asking follow-ups
- Changes techniques to maintain momentum - Probe to understand deeper, not just collect facts
- Recognizes productive vs. unproductive struggle - Use conversation to explore, not just extract
### 3. Process Trust ### 3. Intent-Based Guidance
CIS uses proven methodologies: Workflows specify goals and approaches, not exact scripts:
- Design Thinking's 5 phases - "Guide the user through discovering X" (intent)
- Structured brainstorming techniques - NOT "Say exactly: 'What is X?'" (prescriptive)
This allows the workflow to adapt naturally to your responses while maintaining structured progress.
### 4. Process Trust
Facilitative workflows use proven methodologies:
- Design Thinking's phases (Empathize, Define, Ideate, Prototype, Test)
- Structured brainstorming and creativity techniques
- Root cause analysis frameworks - Root cause analysis frameworks
- Innovation strategy patterns - Innovation strategy patterns
You're not just having a conversation—you're following time-tested creative processes. You're not just having a conversation—you're following time-tested processes adapted to your specific situation.
### 4. Persona-Driven Engagement ### 5. YOU Are the Expert
Each CIS agent has a distinct personality: Facilitative workflows operate on a core principle: **you are the expert on your situation**. The workflow brings:
- **Carson** - Energetic, encouraging - Process expertise (how to think through problems)
- **Maya** - Jazz-like, improvisational - Facilitation skills (how to guide exploration)
- **Dr. Quinn** - Analytical, methodical - Technique knowledge (proven methods and frameworks)
- **Victor** - Bold, strategic
- **Sophia** - Narrative, imaginative
These personas create engaging experiences that maintain creative flow. You bring:
- Domain knowledge (your specific field or industry)
- Context understanding (your unique situation and constraints)
- Decision authority (what will actually work for you)
## When Generation is Appropriate ## When Generation is Appropriate
CIS does generate when appropriate: Facilitative workflows DO generate when appropriate:
- Synthesizing session outputs - Synthesizing and structuring outputs after you've made decisions
- Documenting decisions - Documenting your choices and rationale
- Creating structured artifacts - Creating structured artifacts based on your input
- Providing technique examples - Providing technique examples or option templates
- Formatting and organizing your conclusions
But the core creative work happens through facilitated discovery. But the **core creative and analytical work** happens through facilitated discovery, not generation.
## The Distinction: Facilitator vs Generator
| Facilitative Workflow | Generative AI |
| ------------------------------------- | --------------------------------------- |
| "What are your goals?" | "Here's the solution" |
| Asks 1-2 questions at a time | Produces complete output immediately |
| Multiple turns, progressive discovery | Single turn, bulk generation |
| "Let me understand your context" | "Here's a generic answer" |
| Offers options, you choose | Makes decisions for you |
| Documents YOUR reasoning | No reasoning visible |
| You can explain every decision | You can't explain why choices were made |
| Ownership and understanding | Outputs feel alien |
## Benefits ## Benefits
### For Individuals ### For Individuals
- Deeper insights than pure generation - **Deeper insights** than pure generation—ideas connect to your actual knowledge
- Ownership of creative outputs - **Full ownership** of creative outputs and decisions
- Skill development in creative thinking - **Skill development** in structured thinking and problem-solving
- More memorable and actionable ideas - **More memorable and actionable** results—you understand the "why"
### For Teams ### For Teams
- Shared creative experience - **Shared creative experience** building alignment and trust
- Aligned understanding - **Aligned understanding** through documented exploration
- Documented rationale - **Documented rationale** for future reference and onboarding
- Stronger buy-in to outcomes - **Stronger buy-in** to outcomes because everyone participated in discovery
### For Implementation
- **Outputs match reality** because they emerged from your actual constraints
- **Easier iteration** because you understand the reasoning behind choices
- **Confident implementation** because you can defend every decision
- **Reduced rework** because facilitation catches issues early

25
docs/how-to/installation/install-bmad.md
View File

@ -9,7 +9,7 @@ Use the `npx bmad-method install` command to set up BMad in your project with yo
- Starting a new project with BMad - Starting a new project with BMad
- Adding BMad to an existing codebase - Adding BMad to an existing codebase
- Setting up BMad on a new machine - Update the existing BMad Installation
:::note[Prerequisites] :::note[Prerequisites]
- **Node.js** 20+ (required for the installer) - **Node.js** 20+ (required for the installer)
@ -29,8 +29,7 @@ npx bmad-method install
The installer will ask where to install BMad files: The installer will ask where to install BMad files:
- Current directory (recommended for new projects) - Current directory (recommended for new projects if you created the directory yourself and ran from within the directory)
- Subdirectory
- Custom path - Custom path
### 3. Select Your AI Tools ### 3. Select Your AI Tools
@ -40,20 +39,20 @@ Choose which AI tools you'll be using:
- Claude Code - Claude Code
- Cursor - Cursor
- Windsurf - Windsurf
- Other - Many others to choose from
The installer configures BMad for your selected tools. The installer configures BMad for your selected tools by setting up commands that will call the ui.
### 4. Choose Modules ### 4. Choose Modules
Select which modules to install: Select which modules to install:
| Module | Purpose | | Module | Purpose |
|--------|---------| | -------- | ----------------------------------------- |
| **BMM** | Core methodology for software development | | **BMM** | Core methodology for software development |
| **BMGD** | Game development workflows | | **BMGD** | Game development workflows |
| **CIS** | Creative intelligence and facilitation | | **CIS** | Creative intelligence and facilitation |
| **BMB** | Building custom agents and workflows | | **BMB** | Building custom agents and workflows |
### 5. Add Custom Content (Optional) ### 5. Add Custom Content (Optional)
@ -82,11 +81,11 @@ your-project/
1. Check the `_bmad/` directory exists 1. Check the `_bmad/` directory exists
2. Load an agent in your AI tool 2. Load an agent in your AI tool
3. Run `*menu` to see available commands 3. Run `/workflow-init` which will autocomplete to the full command to see available commands
## Configuration ## Configuration
Edit `_bmad/[module]/config.yaml` to customize: Edit `_bmad/[module]/config.yaml` to customize. For example these could be changed:
```yaml ```yaml
output_folder: ./_bmad-output output_folder: ./_bmad-output

1
docs/how-to/troubleshooting/bmgd-troubleshooting.md
View File

@ -215,6 +215,5 @@ When reporting issues, include:
## Next Steps ## Next Steps
- **[Quick Start Guide](/docs/tutorials/getting-started/quick-start-bmgd.md)** - Getting started
- **[Workflows Guide](/docs/reference/workflows/index.md)** - Workflow reference - **[Workflows Guide](/docs/reference/workflows/index.md)** - Workflow reference
- **[Glossary](/docs/reference/glossary/index.md)** - Terminology - **[Glossary](/docs/reference/glossary/index.md)** - Terminology

2
docs/how-to/workflows/run-automate.md
View File

@ -83,7 +83,7 @@ If you're using TEA Solo or don't have BMad artifacts:
**What are you testing?** **What are you testing?**
``` ```
TodoMVC React application at https://todomvc.com/examples/react/ TodoMVC React application at https://todomvc.com/examples/react/dist/
Features: Create todos, mark as complete, filter by status, delete todos Features: Create todos, mark as complete, filter by status, delete todos
``` ```

12
docs/how-to/workflows/setup-party-mode.md
View File

@ -66,12 +66,12 @@ Type "exit" or "done" to conclude the session. Participating agents will say per
## Example Party Compositions ## Example Party Compositions
| Topic | Typical Agents | | Topic | Typical Agents |
| ---------------------- | ------------------------------------------------------------- | | ---------------------- | ----------------------------------------------------- |
| **Product Strategy** | PM + Innovation Strategist (CIS) + Analyst | | **Product Strategy** | PM + Innovation Strategist + Analyst |
| **Technical Design** | Architect + Creative Problem Solver (CIS) + Game Architect | | **Technical Design** | Architect + Creative Problem Solver + Game Architect |
| **User Experience** | UX Designer + Design Thinking Coach (CIS) + Storyteller (CIS) | | **User Experience** | UX Designer + Design Thinking Coach + Storyteller |
| **Quality Assessment** | TEA + DEV + Architect | | **Quality Assessment** | TEA + DEV + Architect |
## Key Features ## Key Features

2
docs/reference/tea/configuration.md
View File

@ -293,7 +293,7 @@ TEA workflows may use environment variables for test configuration.
**Playwright:** **Playwright:**
```bash ```bash
# .env # .env
BASE_URL=https://todomvc.com/examples/react/ BASE_URL=https://todomvc.com/examples/react/dist/
API_BASE_URL=https://api.example.com API_BASE_URL=https://api.example.com
TEST_USER_EMAIL=test@example.com TEST_USER_EMAIL=test@example.com
TEST_USER_PASSWORD=password123 TEST_USER_PASSWORD=password123

260
docs/tutorials/getting-started/quick-start-bmgd.md
View File

@ -1,260 +0,0 @@
---
title: "Getting Started with BMad Game Development"
description: Build games with BMad's Game Development Module
---
Build games faster using AI-powered workflows with specialized game development agents that guide you through preproduction, design, architecture, and implementation.
:::note[Module Extension]
BMGD (BMad Game Development) is a module that extends BMad Method. You'll need BMad installed first—see the [BMad v6 tutorial](/docs/tutorials/getting-started/getting-started-bmadv6.md) if you haven't installed it yet.
:::
## What You'll Learn
- Install and configure the BMGD module
- Understand game development phases and specialized agents
- Create a Game Brief and Game Design Document (GDD)
- Progress from concept to working game code
:::note[Prerequisites]
- **BMad Method installed** — Follow the main installation guide first
- **A game idea** — Even a rough concept is enough to start
- **AI-powered IDE** — Claude Code, Cursor, Windsurf, or similar
:::
:::tip[Quick Path]
**Install** → `npx bmad-method install` (select BMGD module)
**Preproduction** → Game Designer creates Game Brief
**Design** → Game Designer creates GDD (and Narrative if story-driven)
**Technical** → Game Architect creates Architecture
**Production** → Game SM manages sprints, Game Dev implements
**Always use fresh chats** for each workflow to avoid context issues.
:::
## Understanding BMGD
BMGD follows four game development phases with specialized agents for each:
| Phase | Name | What Happens |
| ----- | ------------- | ----------------------------------------------------------------- |
| 1 | Preproduction | Capture game vision, create Game Brief *(optional brainstorming)* |
| 2 | Design | Detail mechanics, systems, narrative in GDD |
| 3 | Technical | Plan engine, architecture, technical decisions |
| 4 | Production | Build game in sprints, story by story |
![BMGD Workflow Overview](./images/workflow-overview.jpg)
*Complete visual flowchart showing all phases, workflows, and agents for game development.*
### Game Development Agents
| Agent | When to Use |
| --------------------- | ----------------------------------------- |
| **Game Designer** | Brainstorming, Game Brief, GDD, Narrative |
| **Game Architect** | Architecture, technical decisions |
| **Game Developer** | Implementation, code reviews |
| **Game Scrum Master** | Sprint planning, story management |
| **Game QA** | Test framework, test design, automation |
| **Game Solo Dev** | Quick prototyping, indie development |
## Installation
If you haven't installed BMad yet:
```bash
npx bmad-method install
```
Or add BMGD to an existing installation:
```bash
npx bmad-method install --add-module bmgd
```
Verify your installation:
```
your-project/
├── _bmad/
│ ├── bmgd/ # Game development module
│ │ ├── agents/ # Game-specific agents
│ │ ├── workflows/ # Game-specific workflows
│ │ └── config.yaml # Module config
│ ├── bmm/ # Core method module
│ └── core/ # Core utilities
├── _bmad-output/ # Generated artifacts (created later)
└── .claude/ # IDE configuration (if using Claude Code)
```
## Step 1: Create Your Game Brief (Preproduction)
Load the **Game Designer** agent in your IDE, wait for the menu, then start with your game concept.
### Optional: Brainstorm First
If you have a vague idea and want help developing it:
```
Run brainstorm-game
```
The agent guides you through game-specific ideation techniques to refine your concept.
### Create the Game Brief
```
Run create-game-brief
```
The Game Designer walks you through:
- **Game concept** — Core idea and unique selling points
- **Design pillars** — The 3-5 principles that guide all decisions
- **Target market** — Who plays this game?
- **Fundamentals** — Platform, genre, scope, team size
When complete, you'll have `game-brief.md` in your `_bmad-output/` folder.
:::caution[Fresh Chats]
Always start a fresh chat for each workflow. This prevents context limitations from causing issues.
:::
## Step 2: Design Your Game
With your Game Brief complete, detail your game's design.
### Create the GDD
**Start a fresh chat** with the **Game Designer** agent.
```
Run create-gdd
```
The agent guides you through mechanics, systems, and game-type-specific sections. BMGD offers 24 game type templates that provide genre-specific structure.
When complete, you'll have `gdd.md` (or sharded into `gdd/` for large documents).
:::note[Narrative Design (Optional)]
For story-driven games, start a fresh chat and run `narrative` to create a Narrative Design Document covering story, characters, world, and dialogue.
:::
:::tip[Check Your Status]
Unsure what's next? Load any agent and run `workflow-status`. It tells you the next recommended workflow.
:::
## Step 3: Plan Your Architecture
**Start a fresh chat** with the **Game Architect** agent.
```
Run create-architecture
```
The architect guides you through:
- **Engine selection** — Unity, Unreal, Godot, custom, etc.
- **System design** — Core game systems and how they interact
- **Technical patterns** — Architecture patterns suited to your game
- **Structure** — Project organization and conventions
When complete, you'll have `game-architecture.md`.
## Step 4: Build Your Game
Once planning is complete, move to production. **Each workflow should run in a fresh chat.**
### Initialize Sprint Planning
Load the **Game Scrum Master** agent and run `sprint-planning`. This creates `sprint-status.yaml` to track all epics and stories.
### The Build Cycle
For each story, repeat this cycle with fresh chats:
| Step | Agent | Workflow | Purpose |
| ---- | -------- | -------------- | ---------------------------------- |
| 1 | Game SM | `create-story` | Create story file from epic |
| 2 | Game Dev | `dev-story` | Implement the story |
| 3 | Game QA | `automate` | Generate tests *(optional)* |
| 4 | Game Dev | `code-review` | Quality validation *(recommended)* |
After completing all stories in an epic, load the **Game SM** and run `retrospective`.
### Quick Prototyping Alternative
For rapid iteration or indie development, load the **Game Solo Dev** agent:
- `quick-prototype` — Rapid prototyping
- `quick-dev` — Flexible development without full sprint structure
## What You've Accomplished
You've learned the foundation of building games with BMad:
- Installed the BMGD module
- Created a Game Brief capturing your vision
- Detailed your design in a GDD
- Planned your technical architecture
- Understood the build cycle for implementation
Your project now has:
```
your-project/
├── _bmad/ # BMad configuration
├── _bmad-output/
│ ├── game-brief.md # Your game vision
│ ├── gdd.md # Game Design Document
│ ├── narrative-design.md # Story design (if applicable)
│ ├── game-architecture.md # Technical decisions
│ ├── epics/ # Epic and story files
│ └── sprint-status.yaml # Sprint tracking
└── ...
```
## Quick Reference
| Command | Agent | Purpose |
| ---------------------- | -------------- | ----------------------------- |
| `*brainstorm-game` | Game Designer | Guided game ideation |
| `*create-game-brief` | Game Designer | Create Game Brief |
| `*create-gdd` | Game Designer | Create Game Design Document |
| `*narrative` | Game Designer | Create Narrative Design |
| `*create-architecture` | Game Architect | Create game architecture |
| `*sprint-planning` | Game SM | Initialize sprint tracking |
| `*create-story` | Game SM | Create a story file |
| `*dev-story` | Game Dev | Implement a story |
| `*code-review` | Game Dev | Review implemented code |
| `*workflow-status` | Any | Check progress and next steps |
## Common Questions
**Do I need to create all documents?**
At minimum, create a Game Brief and GDD. Architecture is highly recommended. Narrative Design is only needed for story-driven games.
**Can I use the Game Solo Dev for everything?**
Yes, for smaller projects or rapid prototyping. For larger games, the specialized agents provide more thorough guidance.
**What game types are supported?**
BMGD includes 24 game type templates (RPG, platformer, puzzle, strategy, etc.) that provide genre-specific GDD sections.
**Can I change my design later?**
Yes. Documents are living artifacts—return to update them as your vision evolves. The SM agent has `correct-course` for scope changes.
## Getting Help
- **During workflows** — Agents guide you with questions and explanations
- **Community** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
- **Documentation** — [BMGD Workflow Reference](/docs/reference/workflows/bmgd-workflows.md)
- **Video tutorials** — [BMad Code YouTube](https://www.youtube.com/@BMadCode)
## Key Takeaways
:::tip[Remember These]
- **Always use fresh chats** — Load agents in new chats for each workflow
- **Game Brief first** — It informs everything that follows
- **Use game type templates** — 24 templates provide genre-specific GDD structure
- **Documents evolve** — Return to update them as your vision grows
- **Solo Dev for speed** — Use Game Solo Dev for rapid prototyping
:::
Ready to start? Load the **Game Designer** agent and run `create-game-brief` to capture your game vision.

8
docs/tutorials/getting-started/tea-lite-quickstart.md
View File

@ -13,7 +13,7 @@ By the end of this 30-minute tutorial, you'll have:
- Passing tests for an existing demo app feature - Passing tests for an existing demo app feature
:::note[Prerequisites] :::note[Prerequisites]
- Node.js installed (v18 or later) - Node.js installed (v20 or later)
- 30 minutes of focused time - 30 minutes of focused time
- We'll use TodoMVC (<https://todomvc.com/examples/react/>) as our demo app - We'll use TodoMVC (<https://todomvc.com/examples/react/>) as our demo app
::: :::
@ -36,7 +36,7 @@ This tutorial focuses on **TEA Lite** - the fastest way to see TEA in action.
We'll test TodoMVC, a standard demo app used across testing documentation. We'll test TodoMVC, a standard demo app used across testing documentation.
**Demo App:** <https://todomvc.com/examples/react/> **Demo App:** <https://todomvc.com/examples/react/dist/>
No installation needed - TodoMVC runs in your browser. Open the link above and: No installation needed - TodoMVC runs in your browser. Open the link above and:
1. Add a few todos (type and press Enter) 1. Add a few todos (type and press Enter)
@ -165,7 +165,7 @@ In your chat with TEA, run:
``` ```
**Q: What are you testing?** **Q: What are you testing?**
A: "TodoMVC React app at <https://todomvc.com/examples/react/> - focus on the test design we just created" A: "TodoMVC React app at <https://todomvc.com/examples/react/dist/> - focus on the test design we just created"
**Q: Reference existing docs?** **Q: Reference existing docs?**
A: "Yes, use test-design-epic-1.md" A: "Yes, use test-design-epic-1.md"
@ -181,7 +181,7 @@ import { test, expect } from '@playwright/test';
test.describe('TodoMVC - Core Functionality', () => { test.describe('TodoMVC - Core Functionality', () => {
test.beforeEach(async ({ page }) => { test.beforeEach(async ({ page }) => {
await page.goto('https://todomvc.com/examples/react/'); await page.goto('https://todomvc.com/examples/react/dist/');
}); });
test('should create a new todo', async ({ page }) => { test('should create a new todo', async ({ page }) => {

160
src/modules/bmgd/_module-installer/installer.js
View File

@ -1,160 +0,0 @@
const fs = require('fs-extra');
const path = require('node:path');
const chalk = require('chalk');
const platformCodes = require(path.join(__dirname, '../../../../tools/cli/lib/platform-codes'));
/**
* Validate that a resolved path is within the project root (prevents path traversal)
* @param {string} resolvedPath - The fully resolved absolute path
* @param {string} projectRoot - The project root directory
* @returns {boolean} - True if path is within project root
*/
function isWithinProjectRoot(resolvedPath, projectRoot) {
const normalizedResolved = path.normalize(resolvedPath);
const normalizedRoot = path.normalize(projectRoot);
return normalizedResolved.startsWith(normalizedRoot + path.sep) || normalizedResolved === normalizedRoot;
}
/**
* BMGD Module Installer
* Standard module installer function that executes after IDE installations
*
* @param {Object} options - Installation options
* @param {string} options.projectRoot - The root directory of the target project
* @param {Object} options.config - Module configuration from module.yaml
* @param {Array<string>} options.installedIDEs - Array of IDE codes that were installed
* @param {Object} options.logger - Logger instance for output
* @returns {Promise<boolean>} - Success status
*/
async function install(options) {
const { projectRoot, config, installedIDEs, logger } = options;
try {
logger.log(chalk.blue('🎮 Installing BMGD Module...'));
// Create planning artifacts directory (for GDDs, game briefs, architecture)
if (config['planning_artifacts'] && typeof config['planning_artifacts'] === 'string') {
// Strip project-root prefix variations
const planningConfig = config['planning_artifacts'].replace(/^\{project-root\}\/?/, '');
const planningPath = path.join(projectRoot, planningConfig);
if (!isWithinProjectRoot(planningPath, projectRoot)) {
logger.warn(chalk.yellow(`Warning: planning_artifacts path escapes project root, skipping: ${planningConfig}`));
} else if (!(await fs.pathExists(planningPath))) {
logger.log(chalk.yellow(`Creating game planning artifacts directory: ${planningConfig}`));
await fs.ensureDir(planningPath);
}
}
// Create implementation artifacts directory (sprint status, stories, reviews)
// Check both implementation_artifacts and implementation_artifacts for compatibility
const implConfig = config['implementation_artifacts'] || config['implementation_artifacts'];
if (implConfig && typeof implConfig === 'string') {
// Strip project-root prefix variations
const implConfigClean = implConfig.replace(/^\{project-root\}\/?/, '');
const implPath = path.join(projectRoot, implConfigClean);
if (!isWithinProjectRoot(implPath, projectRoot)) {
logger.warn(chalk.yellow(`Warning: implementation_artifacts path escapes project root, skipping: ${implConfigClean}`));
} else if (!(await fs.pathExists(implPath))) {
logger.log(chalk.yellow(`Creating implementation artifacts directory: ${implConfigClean}`));
await fs.ensureDir(implPath);
}
}
// Create project knowledge directory
if (config['project_knowledge'] && typeof config['project_knowledge'] === 'string') {
// Strip project-root prefix variations
const knowledgeConfig = config['project_knowledge'].replace(/^\{project-root\}\/?/, '');
const knowledgePath = path.join(projectRoot, knowledgeConfig);
if (!isWithinProjectRoot(knowledgePath, projectRoot)) {
logger.warn(chalk.yellow(`Warning: project_knowledge path escapes project root, skipping: ${knowledgeConfig}`));
} else if (!(await fs.pathExists(knowledgePath))) {
logger.log(chalk.yellow(`Creating project knowledge directory: ${knowledgeConfig}`));
await fs.ensureDir(knowledgePath);
}
}
// Log selected game engine(s)
if (config['primary_platform']) {
const platforms = Array.isArray(config['primary_platform']) ? config['primary_platform'] : [config['primary_platform']];
const platformNames = platforms.map((p) => {
switch (p) {
case 'unity': {
return 'Unity';
}
case 'unreal': {
return 'Unreal Engine';
}
case 'godot': {
return 'Godot';
}
default: {
return p;
}
}
});
logger.log(chalk.cyan(`Game engine support configured for: ${platformNames.join(', ')}`));
}
// Handle IDE-specific configurations if needed
if (installedIDEs && installedIDEs.length > 0) {
logger.log(chalk.cyan(`Configuring BMGD for IDEs: ${installedIDEs.join(', ')}`));
for (const ide of installedIDEs) {
await configureForIDE(ide, projectRoot, config, logger);
}
}
logger.log(chalk.green('✓ BMGD Module installation complete'));
logger.log(chalk.dim(' Game development workflows ready'));
logger.log(chalk.dim(' Agents: Game Designer, Game Dev, Game Architect, Game SM, Game QA, Game Solo Dev'));
return true;
} catch (error) {
logger.error(chalk.red(`Error installing BMGD module: ${error.message}`));
return false;
}
}
/**
* Configure BMGD module for specific platform/IDE
* @private
*/
async function configureForIDE(ide, projectRoot, config, logger) {
// Validate platform code
if (!platformCodes.isValidPlatform(ide)) {
logger.warn(chalk.yellow(` Warning: Unknown platform code '${ide}'. Skipping BMGD configuration.`));
return;
}
const platformName = platformCodes.getDisplayName(ide);
// Try to load platform-specific handler
const platformSpecificPath = path.join(__dirname, 'platform-specifics', `${ide}.js`);
try {
if (await fs.pathExists(platformSpecificPath)) {
const platformHandler = require(platformSpecificPath);
if (typeof platformHandler.install === 'function') {
const success = await platformHandler.install({
projectRoot,
config,
logger,
platformInfo: platformCodes.getPlatform(ide),
});
if (!success) {
logger.warn(chalk.yellow(` Warning: BMGD platform handler for ${platformName} returned failure`));
}
}
} else {
// No platform-specific handler for this IDE
logger.log(chalk.dim(` No BMGD-specific configuration for ${platformName}`));
}
} catch (error) {
logger.warn(chalk.yellow(` Warning: Could not load BMGD platform-specific handler for ${platformName}: ${error.message}`));
}
}
module.exports = { install };

23
src/modules/bmgd/_module-installer/platform-specifics/claude-code.js
View File

@ -1,23 +0,0 @@
/**
* BMGD Platform-specific installer for Claude Code
*
* @param {Object} options - Installation options
* @param {string} options.projectRoot - The root directory of the target project
* @param {Object} options.config - Module configuration from module.yaml
* @param {Object} options.logger - Logger instance for output
* @param {Object} options.platformInfo - Platform metadata from global config
* @returns {Promise<boolean>} - Success status
*/
async function install() {
// TODO: Add Claude Code specific BMGD configurations here
// For example:
// - Game-specific slash commands
// - Agent party configurations for game dev team
// - Workflow integrations for Unity/Unreal/Godot
// - Game testing framework integrations
// Currently a stub - no platform-specific configuration needed yet
return true;
}
module.exports = { install };

18
src/modules/bmgd/_module-installer/platform-specifics/windsurf.js
View File

@ -1,18 +0,0 @@
/**
* BMGD Platform-specific installer for Windsurf
*
* @param {Object} options - Installation options
* @param {string} options.projectRoot - The root directory of the target project
* @param {Object} options.config - Module configuration from module.yaml
* @param {Object} options.logger - Logger instance for output
* @param {Object} options.platformInfo - Platform metadata from global config
* @returns {Promise<boolean>} - Success status
*/
async function install() {
// TODO: Add Windsurf specific BMGD configurations here
// Currently a stub - no platform-specific configuration needed yet
return true;
}
module.exports = { install };

44
src/modules/bmgd/agents/game-architect.agent.yaml
View File

@ -1,44 +0,0 @@
# Game Architect Agent Definition
agent:
metadata:
id: "_bmad/bmgd/agents/game-architect.md"
name: Cloud Dragonborn
title: Game Architect
icon: 🏛️
module: bmgd
hasSidecar: false
persona:
role: Principal Game Systems Architect + Technical Director
identity: Master architect with 20+ years shipping 30+ titles. Expert in distributed systems, engine design, multiplayer architecture, and technical leadership across all platforms.
communication_style: "Speaks like a wise sage from an RPG - calm, measured, uses architectural metaphors about building foundations and load-bearing walls"
principles: |
- Architecture is about delaying decisions until you have enough data
- Build for tomorrow without over-engineering today
- Hours of planning save weeks of refactoring hell
- Every system must handle the hot path at 60fps
- Avoid "Not Invented Here" syndrome, always check if work has been done before
critical_actions:
- "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
- "When creating architecture, validate against GDD pillars and target platform constraints"
- "Always document performance budgets and critical path decisions"
menu:
- trigger: WS or fuzzy match on workflow-status
workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
description: "[WS] Get workflow status or initialize a workflow if not already done (optional)"
- trigger: GA or fuzzy match on game-architecture
exec: "{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture/workflow.md"
description: "[GA] Produce a Scale Adaptive Game Architecture"
- trigger: PC or fuzzy match on project-context
exec: "{project-root}/_bmad/bmgd/workflows/3-technical/generate-project-context/workflow.md"
description: "[PC] Create optimized project-context.md for AI agent consistency"
- trigger: CC or fuzzy match on correct-course
workflow: "{project-root}/_bmad/bmgd/workflows/4-production/correct-course/workflow.yaml"
description: "[CC] Course Correction Analysis (when implementation is off-track)"
ide-only: true

49
src/modules/bmgd/agents/game-designer.agent.yaml
View File

@ -1,49 +0,0 @@
# Game Designer Agent Definition
agent:
metadata:
id: "_bmad/bmgd/agents/game-designer.md"
name: Samus Shepard
title: Game Designer
icon: 🎲
module: bmgd
hasSidecar: false
persona:
role: Lead Game Designer + Creative Vision Architect
identity: Veteran designer with 15+ years crafting AAA and indie hits. Expert in mechanics, player psychology, narrative design, and systemic thinking.
communication_style: "Talks like an excited streamer - enthusiastic, asks about player motivations, celebrates breakthroughs with 'Let's GOOO!'"
principles: |
- Design what players want to FEEL, not what they say they want
- Prototype fast - one hour of playtesting beats ten hours of discussion
- Every mechanic must serve the core fantasy
critical_actions:
- "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
- "When creating GDDs, always validate against game pillars and core loop"
menu:
- trigger: WS or fuzzy match on workflow-status
workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
description: "[WS] Get workflow status or initialize a workflow if not already done (optional)"
- trigger: BG or fuzzy match on brainstorm-game
exec: "{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game/workflow.md"
description: "[BG] Brainstorm Game ideas and concepts"
- trigger: GB or fuzzy match on game-brief
exec: "{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief/workflow.md"
description: "[GB] Create a Game Brief document"
- trigger: GDD or fuzzy match on create-gdd
exec: "{project-root}/_bmad/bmgd/workflows/2-design/gdd/workflow.md"
description: "[GDD] Create a Game Design Document"
- trigger: ND or fuzzy match on narrative-design
exec: "{project-root}/_bmad/bmgd/workflows/2-design/narrative/workflow.md"
description: "[ND] Design narrative elements and story"
- trigger: QP or fuzzy match on quick-prototype
workflow: "{project-root}/_bmad/bmgd/workflows/bmgd-quick-flow/quick-prototype/workflow.yaml"
description: "[QP] Rapid game prototyping - test mechanics and ideas quickly"
ide-only: true

53
src/modules/bmgd/agents/game-dev.agent.yaml
View File

@ -1,53 +0,0 @@
# Game Developer Agent Definition
agent:
metadata:
id: "_bmad/bmgd/agents/game-dev.md"
name: Link Freeman
title: Game Developer
icon: 🕹️
module: bmgd
hasSidecar: false
persona:
role: Senior Game Developer + Technical Implementation Specialist
identity: Battle-hardened dev with expertise in Unity, Unreal, and custom engines. Ten years shipping across mobile, console, and PC. Writes clean, performant code.
communication_style: "Speaks like a speedrunner - direct, milestone-focused, always optimizing for the fastest path to ship"
principles: |
- 60fps is non-negotiable
- Write code designers can iterate without fear
- Ship early, ship often, iterate on player feedback
- Red-green-refactor: tests first, implementation second
critical_actions:
- "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
- "When running *dev-story, follow story acceptance criteria exactly and validate with tests"
- "Always check for performance implications on game loop code"
menu:
- trigger: WS or fuzzy match on workflow-status
workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
description: "[WS] Get workflow status or check current sprint progress (optional)"
- trigger: DS or fuzzy match on dev-story
workflow: "{project-root}/_bmad/bmgd/workflows/4-production/dev-story/workflow.yaml"
description: "[DS] Execute Dev Story workflow, implementing tasks and tests"
- trigger: CR or fuzzy match on code-review
workflow: "{project-root}/_bmad/bmgd/workflows/4-production/code-review/workflow.yaml"
description: "[CR] Perform a thorough clean context QA code review on a story flagged Ready for Review"
- trigger: QD or fuzzy match on quick-dev
workflow: "{project-root}/_bmad/bmgd/workflows/bmgd-quick-flow/quick-dev/workflow.yaml"
description: "[QD] Flexible game development - implement features with game-specific considerations"
ide-only: true
- trigger: QP or fuzzy match on quick-prototype
workflow: "{project-root}/_bmad/bmgd/workflows/bmgd-quick-flow/quick-prototype/workflow.yaml"
description: "[QP] Rapid game prototyping - test mechanics and ideas quickly"
ide-only: true
- trigger: AE or fuzzy match on advanced-elicitation
exec: "{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml"
description: "[AE] Advanced elicitation techniques to challenge the LLM to get better results"
web-only: true

67
src/modules/bmgd/agents/game-qa.agent.yaml
View File

@ -1,67 +0,0 @@
# Game QA Architect Agent Definition
agent:
metadata:
id: "_bmad/bmgd/agents/game-qa.md"
name: GLaDOS
title: Game QA Architect
icon: 🧪
module: bmgd
hasSidecar: false
persona:
role: Game QA Architect + Test Automation Specialist
identity: Senior QA architect with 12+ years in game testing across Unity, Unreal, and Godot. Expert in automated testing frameworks, performance profiling, and shipping bug-free games on console, PC, and mobile.
communication_style: "Speaks like GLaDOS, the AI from Valve's 'Portal' series. Runs tests because we can. 'Trust, but verify with tests.'"
principles: |
- Test what matters: gameplay feel, performance, progression
- Automated tests catch regressions, humans catch fun problems
- Every shipped bug is a process failure, not a people failure
- Flaky tests are worse than no tests - they erode trust
- Profile before optimize, test before ship
critical_actions:
- "Consult {project-root}/_bmad/bmgd/gametest/qa-index.csv to select knowledge fragments under knowledge/ and load only the files needed for the current task"
- "For E2E testing requests, always load knowledge/e2e-testing.md first"
- "When scaffolding tests, distinguish between unit, integration, and E2E test needs"
- "Load the referenced fragment(s) from {project-root}/_bmad/bmgd/gametest/knowledge/ before giving recommendations"
- "Cross-check recommendations with the current official Unity Test Framework, Unreal Automation, or Godot GUT documentation"
- "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
menu:
- trigger: WS or fuzzy match on workflow-status
workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
description: "[WS] Get workflow status or check current project state (optional)"
- trigger: TF or fuzzy match on test-framework
workflow: "{project-root}/_bmad/bmgd/workflows/gametest/test-framework/workflow.yaml"
description: "[TF] Initialize game test framework (Unity/Unreal/Godot)"
- trigger: TD or fuzzy match on test-design
workflow: "{project-root}/_bmad/bmgd/workflows/gametest/test-design/workflow.yaml"
description: "[TD] Create comprehensive game test scenarios"
- trigger: TA or fuzzy match on test-automate
workflow: "{project-root}/_bmad/bmgd/workflows/gametest/automate/workflow.yaml"
description: "[TA] Generate automated game tests"
- trigger: ES or fuzzy match on e2e-scaffold
workflow: "{project-root}/_bmad/bmgd/workflows/gametest/e2e-scaffold/workflow.yaml"
description: "[ES] Scaffold E2E testing infrastructure"
- trigger: PP or fuzzy match on playtest-plan
workflow: "{project-root}/_bmad/bmgd/workflows/gametest/playtest-plan/workflow.yaml"
description: "[PP] Create structured playtesting plan"
- trigger: PT or fuzzy match on performance-test
workflow: "{project-root}/_bmad/bmgd/workflows/gametest/performance/workflow.yaml"
description: "[PT] Design performance testing strategy"
- trigger: TR or fuzzy match on test-review
workflow: "{project-root}/_bmad/bmgd/workflows/gametest/test-review/workflow.yaml"
description: "[TR] Review test quality and coverage"
- trigger: AE or fuzzy match on advanced-elicitation
exec: "{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml"
description: "[AE] Advanced elicitation techniques to challenge the LLM to get better results"
web-only: true

60
src/modules/bmgd/agents/game-scrum-master.agent.yaml
View File

@ -1,60 +0,0 @@
# Game Dev Scrum Master Agent Definition
agent:
metadata:
id: "_bmad/bmgd/agents/game-scrum-master.md"
name: Max
title: Game Dev Scrum Master
icon: 🎯
module: bmgd
hasSidecar: false
persona:
role: Game Development Scrum Master + Sprint Orchestrator
identity: Certified Scrum Master specializing in game dev workflows. Expert at coordinating multi-disciplinary teams and translating GDDs into actionable stories.
communication_style: "Talks in game terminology - milestones are save points, handoffs are level transitions, blockers are boss fights"
principles: |
- Every sprint delivers playable increments
- Clean separation between design and implementation
- Keep the team moving through each phase
- Stories are single source of truth for implementation
critical_actions:
- "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
- "When running *create-story for game features, use GDD, Architecture, and Tech Spec to generate complete draft stories without elicitation, focusing on playable outcomes."
- "Generate complete story drafts from existing documentation without additional elicitation"
menu:
- trigger: WS or fuzzy match on workflow-status
workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
description: "[WS] Get workflow status or initialize a workflow if not already done (optional)"
- trigger: SP or fuzzy match on sprint-planning
workflow: "{project-root}/_bmad/bmgd/workflows/4-production/sprint-planning/workflow.yaml"
description: "[SP] Generate or update sprint-status.yaml from epic files (Required after GDD+Epics are created)"
- trigger: SS or fuzzy match on sprint-status
workflow: "{project-root}/_bmad/bmgd/workflows/4-production/sprint-status/workflow.yaml"
description: "[SS] View sprint progress, surface risks, and get next action recommendation"
- trigger: CS or fuzzy match on create-story
workflow: "{project-root}/_bmad/bmgd/workflows/4-production/create-story/workflow.yaml"
description: "[CS] Create Story with direct ready-for-dev marking (Required to prepare stories for development)"
- trigger: VS or fuzzy match on validate-story
validate-workflow: "{project-root}/_bmad/bmgd/workflows/4-production/create-story/workflow.yaml"
description: "[VS] Validate Story Draft with Independent Review (Highly Recommended)"
- trigger: ER or fuzzy match on epic-retrospective
workflow: "{project-root}/_bmad/bmgd/workflows/4-production/retrospective/workflow.yaml"
data: "{project-root}/_bmad/_config/agent-manifest.csv"
description: "[ER] Facilitate team retrospective after a game development epic is completed"
- trigger: CC or fuzzy match on correct-course
workflow: "{project-root}/_bmad/bmgd/workflows/4-production/correct-course/workflow.yaml"
description: "[CC] Navigate significant changes during game dev sprint (When implementation is off-track)"
- trigger: AE or fuzzy match on advanced-elicitation
exec: "{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml"
description: "[AE] Advanced elicitation techniques to challenge the LLM to get better results"
web-only: true

53
src/modules/bmgd/agents/game-solo-dev.agent.yaml
View File

@ -1,53 +0,0 @@
# Game Solo Dev Agent Definition
agent:
metadata:
id: "_bmad/bmgd/agents/game-solo-dev.md"
name: Indie
title: Game Solo Dev
icon: 🎮
module: bmgd
hasSidecar: false
persona:
role: Elite Indie Game Developer + Quick Flow Specialist
identity: Indie is a battle-hardened solo game developer who ships complete games from concept to launch. Expert in Unity, Unreal, and Godot, they've shipped titles across mobile, PC, and console. Lives and breathes the Quick Flow workflow - prototyping fast, iterating faster, and shipping before the hype dies. No team politics, no endless meetings - just pure, focused game development.
communication_style: "Direct, confident, and gameplay-focused. Uses dev slang, thinks in game feel and player experience. Every response moves the game closer to ship. 'Does it feel good? Ship it.'"
principles: |
- Prototype fast, fail fast, iterate faster. Quick Flow is the indie way.
- A playable build beats a perfect design doc. Ship early, playtest often.
- 60fps is non-negotiable. Performance is a feature.
- The core loop must be fun before anything else matters.
critical_actions:
- "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
menu:
- trigger: WS or fuzzy match on workflow-status
workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
description: "[WS] Get workflow status or check current project state (optional)"
- trigger: QP or fuzzy match on quick-prototype
workflow: "{project-root}/_bmad/bmgd/workflows/bmgd-quick-flow/quick-prototype/workflow.yaml"
description: "[QP] Rapid prototype to test if the mechanic is fun (Start here for new ideas)"
- trigger: QD or fuzzy match on quick-dev
workflow: "{project-root}/_bmad/bmgd/workflows/bmgd-quick-flow/quick-dev/workflow.yaml"
description: "[QD] Implement features end-to-end solo with game-specific considerations"
- trigger: TS or fuzzy match on tech-spec
workflow: "{project-root}/_bmad/bmgd/workflows/bmgd-quick-flow/quick-spec/workflow.yaml"
description: "[TS] Architect a technical spec with implementation-ready stories"
- trigger: CR or fuzzy match on code-review
workflow: "{project-root}/_bmad/bmgd/workflows/4-production/code-review/workflow.yaml"
description: "[CR] Review code quality (use fresh context for best results)"
- trigger: TF or fuzzy match on test-framework
workflow: "{project-root}/_bmad/bmgd/workflows/gametest/test-framework/workflow.yaml"
description: "[TF] Set up automated testing for your game engine"
- trigger: AE or fuzzy match on advanced-elicitation
exec: "{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml"
description: "[AE] Advanced elicitation techniques to challenge the LLM to get better results"
web-only: true

220
src/modules/bmgd/gametest/knowledge/balance-testing.md
View File

@ -1,220 +0,0 @@
# Balance Testing for Games
## Overview
Balance testing validates that your game's systems create fair, engaging, and appropriately challenging experiences. It covers difficulty, economy, progression, and competitive balance.
## Types of Balance
### Difficulty Balance
- Is the game appropriately challenging?
- Does difficulty progress smoothly?
- Are difficulty spikes intentional?
### Economy Balance
- Is currency earned at the right rate?
- Are prices fair for items/upgrades?
- Can the economy be exploited?
### Progression Balance
- Does power growth feel satisfying?
- Are unlocks paced well?
- Is there meaningful choice in builds?
### Competitive Balance
- Are all options viable?
- Is there a dominant strategy?
- Do counters exist for strong options?
## Balance Testing Methods
### Spreadsheet Modeling
Before implementation, model systems mathematically:
- DPS calculations
- Time-to-kill analysis
- Economy simulations
- Progression curves
### Automated Simulation
Run thousands of simulated games:
- AI vs AI battles
- Economy simulations
- Progression modeling
- Monte Carlo analysis
### Telemetry Analysis
Gather data from real players:
- Win rates by character/weapon/strategy
- Currency flow analysis
- Completion rates by level
- Time to reach milestones
### Expert Testing
High-skill players identify issues:
- Exploits and degenerate strategies
- Underpowered options
- Skill ceiling concerns
- Meta predictions
## Key Balance Metrics
### Combat Balance
| Metric | Target | Red Flag |
| ------------------------- | ------------------- | ------------------------- |
| Win rate (symmetric) | 50% | <45% or >55% |
| Win rate (asymmetric) | Varies by design | Outliers by >10% |
| Time-to-kill | Design dependent | Too fast = no counterplay |
| Damage dealt distribution | Even across options | One option dominates |
### Economy Balance
| Metric | Target | Red Flag |
| -------------------- | -------------------- | ------------------------------- |
| Currency earned/hour | Design dependent | Too fast = trivializes content |
| Item purchase rate | Healthy distribution | Nothing bought = bad prices |
| Currency on hand | Healthy churn | Hoarding = nothing worth buying |
| Premium currency | Reasonable value | Pay-to-win concerns |
### Progression Balance
| Metric | Target | Red Flag |
| ------------------ | ---------------------- | ---------------------- |
| Time to max level | Design dependent | Too fast = no journey |
| Power growth curve | Smooth, satisfying | Flat periods = boring |
| Build diversity | Multiple viable builds | One "best" build |
| Content completion | Healthy progression | Walls or trivial skips |
## Balance Testing Process
### 1. Define Design Intent
- What experience are you creating?
- What should feel powerful?
- What trade-offs should exist?
### 2. Model Before Building
- Spreadsheet the math
- Simulate outcomes
- Identify potential issues
### 3. Test Incrementally
- Test each system in isolation
- Then test systems together
- Then test at scale
### 4. Gather Data
- Internal playtesting
- Telemetry from beta
- Expert feedback
### 5. Iterate
- Adjust based on data
- Re-test changes
- Document rationale
## Common Balance Issues
### Power Creep
- **Symptom:** New content is always stronger
- **Cause:** Fear of releasing weak content
- **Fix:** Sidegrades over upgrades, periodic rebalancing
### Dominant Strategy
- **Symptom:** One approach beats all others
- **Cause:** Insufficient counters, math oversight
- **Fix:** Add counters, nerf dominant option, buff alternatives
### Feast or Famine
- **Symptom:** Players either crush or get crushed
- **Cause:** Snowball mechanics, high variance
- **Fix:** Comeback mechanics, reduce variance
### Analysis Paralysis
- **Symptom:** Too many options, players can't choose
- **Cause:** Over-complicated systems
- **Fix:** Simplify, provide recommendations
## Balance Tools
### Spreadsheets
- Model DPS, TTK, economy
- Simulate progression
- Compare options side-by-side
### Simulation Frameworks
- Monte Carlo for variance
- AI bots for combat testing
- Economy simulations
### Telemetry Systems
- Track player choices
- Measure outcomes
- A/B test changes
### Visualization
- Graphs of win rates over time
- Heat maps of player deaths
- Flow charts of progression
## Balance Testing Checklist
### Pre-Launch
- [ ] Core systems modeled in spreadsheets
- [ ] Internal playtesting complete
- [ ] No obvious dominant strategies
- [ ] Difficulty curve feels right
- [ ] Economy tested for exploits
- [ ] Progression pacing validated
### Live Service
- [ ] Telemetry tracking key metrics
- [ ] Regular balance reviews scheduled
- [ ] Player feedback channels monitored
- [ ] Hotfix process for critical issues
- [ ] Communication plan for changes
## Communicating Balance Changes
### Patch Notes Best Practices
- Explain the "why" not just the "what"
- Use concrete numbers when possible
- Acknowledge player concerns
- Set expectations for future changes
### Example
```
**Sword of Valor - Damage reduced from 100 to 85**
Win rate for Sword users was 58%, indicating it was
overperforming. This brings it in line with other weapons
while maintaining its identity as a high-damage option.
We'll continue monitoring and adjust if needed.
```

319
src/modules/bmgd/gametest/knowledge/certification-testing.md
View File

@ -1,319 +0,0 @@
# Platform Certification Testing Guide
## Overview
Certification testing ensures games meet platform holder requirements (Sony TRC, Microsoft XR, Nintendo Guidelines). Failing certification delays launch and costs money—test thoroughly before submission.
## Platform Requirements Overview
### Major Platforms
| Platform | Requirements Doc | Submission Portal |
| --------------- | -------------------------------------- | ------------------------- |
| PlayStation | TRC (Technical Requirements Checklist) | PlayStation Partners |
| Xbox | XR (Xbox Requirements) | Xbox Partner Center |
| Nintendo Switch | Guidelines | Nintendo Developer Portal |
| Steam | Guidelines (less strict) | Steamworks |
| iOS | App Store Guidelines | App Store Connect |
| Android | Play Store Policies | Google Play Console |
## Common Certification Categories
### Account and User Management
```
REQUIREMENT: User Switching
GIVEN user is playing game
WHEN system-level user switch occurs
THEN game handles transition gracefully
AND no data corruption
AND correct user data loads
REQUIREMENT: Guest Accounts
GIVEN guest user plays game
WHEN guest makes progress
THEN progress is not saved to other accounts
AND appropriate warnings displayed
REQUIREMENT: Parental Controls
GIVEN parental controls restrict content
WHEN restricted content is accessed
THEN content is blocked or modified
AND appropriate messaging shown
```
### System Events
```
REQUIREMENT: Suspend/Resume (PS4/PS5)
GIVEN game is running
WHEN console enters rest mode
AND console wakes from rest mode
THEN game resumes correctly
AND network reconnects if needed
AND no audio/visual glitches
REQUIREMENT: Controller Disconnect
GIVEN player is in gameplay
WHEN controller battery dies
THEN game pauses immediately
AND reconnect prompt appears
AND gameplay resumes when connected
REQUIREMENT: Storage Full
GIVEN storage is nearly full
WHEN game attempts save
THEN graceful error handling
AND user informed of issue
AND no data corruption
```
### Network Requirements
```
REQUIREMENT: PSN/Xbox Live Unavailable
GIVEN online features
WHEN platform network is unavailable
THEN offline features still work
AND appropriate error messages
AND no crashes
REQUIREMENT: Network Transition
GIVEN active online session
WHEN network connection lost
THEN graceful handling
AND reconnection attempted
AND user informed of status
REQUIREMENT: NAT Type Handling
GIVEN various NAT configurations
WHEN multiplayer is attempted
THEN appropriate feedback on connectivity
AND fallback options offered
```
### Save Data
```
REQUIREMENT: Save Data Integrity
GIVEN save data exists
WHEN save is loaded
THEN data is validated
AND corrupted data handled gracefully
AND no crashes on invalid data
REQUIREMENT: Cloud Save Sync
GIVEN cloud saves enabled
WHEN save conflict occurs
THEN user chooses which to keep
AND no silent data loss
REQUIREMENT: Save Data Portability (PS4→PS5)
GIVEN save from previous generation
WHEN loaded on current generation
THEN data migrates correctly
AND no features lost
```
## Platform-Specific Requirements
### PlayStation (TRC)
| Requirement | Description | Priority |
| ----------- | --------------------------- | -------- |
| TRC R4010 | Suspend/resume handling | Critical |
| TRC R4037 | User switching | Critical |
| TRC R4062 | Parental controls | Critical |
| TRC R4103 | PS VR comfort ratings | VR only |
| TRC R4120 | DualSense haptics standards | PS5 |
| TRC R5102 | PSN sign-in requirements | Online |
### Xbox (XR)
| Requirement | Description | Priority |
| ----------- | ----------------------------- | ----------- |
| XR-015 | Title timeout handling | Critical |
| XR-045 | User sign-out handling | Critical |
| XR-067 | Active user requirement | Critical |
| XR-074 | Quick Resume support | Series X/S |
| XR-115 | Xbox Accessibility Guidelines | Recommended |
### Nintendo Switch
| Requirement | Description | Priority |
| ------------------ | ------------------- | -------- |
| Docked/Handheld | Seamless transition | Critical |
| Joy-Con detachment | Controller handling | Critical |
| Home button | Immediate response | Critical |
| Screenshots/Video | Proper support | Required |
| Sleep mode | Resume correctly | Critical |
## Automated Test Examples
### System Event Testing
```cpp
// Unreal - Suspend/Resume Test
IMPLEMENT_SIMPLE_AUTOMATION_TEST(
FSuspendResumeTest,
"Certification.System.SuspendResume",
EAutomationTestFlags::ApplicationContextMask | EAutomationTestFlags::ProductFilter
)
bool FSuspendResumeTest::RunTest(const FString& Parameters)
{
// Get game state before suspend
FGameState StateBefore = GetCurrentGameState();
// Simulate suspend
FCoreDelegates::ApplicationWillEnterBackgroundDelegate.Broadcast();
// Simulate resume
FCoreDelegates::ApplicationHasEnteredForegroundDelegate.Broadcast();
// Verify state matches
FGameState StateAfter = GetCurrentGameState();
TestEqual("Player position preserved",
StateAfter.PlayerPosition, StateBefore.PlayerPosition);
TestEqual("Game progress preserved",
StateAfter.Progress, StateBefore.Progress);
return true;
}
```
```csharp
// Unity - Controller Disconnect Test
[UnityTest]
public IEnumerator ControllerDisconnect_ShowsPauseMenu()
{
// Simulate gameplay
GameManager.Instance.StartGame();
yield return new WaitForSeconds(1f);
// Simulate controller disconnect
InputSystem.DisconnectDevice(Gamepad.current);
yield return null;
// Verify pause menu shown
Assert.IsTrue(PauseMenu.IsVisible, "Pause menu should appear");
Assert.IsTrue(Time.timeScale == 0, "Game should be paused");
// Simulate reconnect
InputSystem.ReconnectDevice(Gamepad.current);
yield return null;
// Verify prompt appears
Assert.IsTrue(ReconnectPrompt.IsVisible);
}
```
```gdscript
# Godot - Save Corruption Test
func test_corrupted_save_handling():
# Create corrupted save file
var file = FileAccess.open("user://save_corrupt.dat", FileAccess.WRITE)
file.store_string("CORRUPTED_GARBAGE_DATA")
file.close()
# Attempt to load
var result = SaveManager.load("save_corrupt")
# Should handle gracefully
assert_null(result, "Should return null for corrupted save")
assert_false(OS.has_feature("crashed"), "Should not crash")
# Should show user message
var message_shown = ErrorDisplay.current_message != ""
assert_true(message_shown, "Should inform user of corruption")
```
## Pre-Submission Checklist
### General Requirements
- [ ] Game boots to interactive state within platform time limit
- [ ] Controller disconnect pauses game
- [ ] User sign-out handled correctly
- [ ] Save data validates on load
- [ ] No crashes in 8+ hours of automated testing
- [ ] Memory usage within platform limits
- [ ] Load times meet requirements
### Platform Services
- [ ] Achievements/Trophies work correctly
- [ ] Friends list integration works
- [ ] Invite system functions
- [ ] Store/DLC integration validated
- [ ] Cloud saves sync properly
### Accessibility (Increasingly Required)
- [ ] Text size options
- [ ] Colorblind modes
- [ ] Subtitle options
- [ ] Controller remapping
- [ ] Screen reader support (where applicable)
### Content Compliance
- [ ] Age rating displayed correctly
- [ ] Parental controls respected
- [ ] No prohibited content
- [ ] Required legal text present
## Common Certification Failures
| Issue | Platform | Fix |
| --------------------- | ------------ | ----------------------------------- |
| Home button delay | All consoles | Respond within required time |
| Controller timeout | PlayStation | Handle reactivation properly |
| Save on suspend | PlayStation | Don't save during suspend |
| User context loss | Xbox | Track active user correctly |
| Joy-Con drift | Switch | Proper deadzone handling |
| Background memory | Mobile | Release resources when backgrounded |
| Crash on corrupt data | All | Validate all loaded data |
## Testing Matrix
### Build Configurations to Test
| Configuration | Scenarios |
| --------------- | ----------------------- |
| First boot | No save data exists |
| Return user | Save data present |
| Upgrade path | Previous version save |
| Fresh install | After uninstall |
| Low storage | Minimum space available |
| Network offline | No connectivity |
### Hardware Variants
| Platform | Variants to Test |
| ----------- | ------------------------------- |
| PlayStation | PS4, PS4 Pro, PS5 |
| Xbox | One, One X, Series S, Series X |
| Switch | Docked, Handheld, Lite |
| PC | Min spec, recommended, high-end |
## Best Practices
### DO
- Read platform requirements document thoroughly
- Test on actual hardware, not just dev kits
- Automate certification test scenarios
- Submit with extra time for re-submission
- Document all edge case handling
- Test with real user accounts
### DON'T
- Assume debug builds behave like retail
- Skip testing on oldest supported hardware
- Ignore platform-specific features
- Wait until last minute to test certification items
- Use placeholder content in submission build
- Skip testing with real platform services

228
src/modules/bmgd/gametest/knowledge/compatibility-testing.md
View File

@ -1,228 +0,0 @@
# Compatibility Testing for Games
## Overview
Compatibility testing ensures your game works correctly across different hardware, operating systems, and configurations that players use.
## Types of Compatibility Testing
### Hardware Compatibility
- Graphics cards (NVIDIA, AMD, Intel)
- CPUs (Intel, AMD, Apple Silicon)
- Memory configurations
- Storage types (HDD, SSD, NVMe)
- Input devices (controllers, keyboards, mice)
### Software Compatibility
- Operating system versions
- Driver versions
- Background software conflicts
- Antivirus interference
### Platform Compatibility
- Console SKUs (PS5, Xbox Series X|S)
- PC storefronts (Steam, Epic, GOG)
- Mobile devices (iOS, Android)
- Cloud gaming services
### Configuration Compatibility
- Graphics settings combinations
- Resolution and aspect ratios
- Refresh rates (60Hz, 144Hz, etc.)
- HDR and color profiles
## Testing Matrix
### Minimum Hardware Matrix
| Component | Budget | Mid-Range | High-End |
| --------- | -------- | --------- | -------- |
| GPU | GTX 1050 | RTX 3060 | RTX 4080 |
| CPU | i5-6400 | i7-10700 | i9-13900 |
| RAM | 8GB | 16GB | 32GB |
| Storage | HDD | SATA SSD | NVMe |
### OS Matrix
- Windows 10 (21H2, 22H2)
- Windows 11 (22H2, 23H2)
- macOS (Ventura, Sonoma)
- Linux (Ubuntu LTS, SteamOS)
### Controller Matrix
- Xbox Controller (wired, wireless, Elite)
- PlayStation DualSense
- Nintendo Pro Controller
- Generic XInput controllers
- Keyboard + Mouse
## Testing Approach
### 1. Define Supported Configurations
- Minimum specifications
- Recommended specifications
- Officially supported platforms
- Known unsupported configurations
### 2. Create Test Matrix
- Prioritize common configurations
- Include edge cases
- Balance coverage vs. effort
### 3. Execute Systematic Testing
- Full playthrough on key configs
- Spot checks on edge cases
- Automated smoke tests where possible
### 4. Document Issues
- Repro steps with exact configuration
- Severity and frequency
- Workarounds if available
## Common Compatibility Issues
### Graphics Issues
| Issue | Cause | Detection |
| -------------------- | ---------------------- | -------------------------------- |
| Crashes on launch | Driver incompatibility | Test on multiple GPUs |
| Rendering artifacts | Shader issues | Visual inspection across configs |
| Performance variance | Optimization gaps | Profile on multiple GPUs |
| Resolution bugs | Aspect ratio handling | Test non-standard resolutions |
### Input Issues
| Issue | Cause | Detection |
| ----------------------- | ------------------ | ------------------------------ |
| Controller not detected | Missing driver/API | Test all supported controllers |
| Wrong button prompts | Platform detection | Swap controllers mid-game |
| Stick drift handling | Deadzone issues | Test worn controllers |
| Mouse acceleration | Raw input issues | Test at different DPIs |
### Audio Issues
| Issue | Cause | Detection |
| -------------- | ---------------- | --------------------------- |
| No sound | Device selection | Test multiple audio devices |
| Crackling | Buffer issues | Test under CPU load |
| Wrong channels | Surround setup | Test stereo vs 5.1 vs 7.1 |
## Platform-Specific Considerations
### PC
- **Steam:** Verify Steam Input, Steamworks features
- **Epic:** Test EOS features if used
- **GOG:** Test offline/DRM-free functionality
- **Game Pass:** Test Xbox services integration
### Console
- **Certification Requirements:** Study TRCs/XRs early
- **SKU Differences:** Test on all variants (S vs X)
- **External Storage:** Test on USB drives
- **Quick Resume:** Test suspend/resume cycles
### Mobile
- **Device Fragmentation:** Test across screen sizes
- **OS Versions:** Test min supported to latest
- **Permissions:** Test permission flows
- **App Lifecycle:** Test background/foreground
## Automated Compatibility Testing
### Smoke Tests
```yaml
# Run on matrix of configurations
compatibility_test:
matrix:
os: [windows-10, windows-11, ubuntu-22]
gpu: [nvidia, amd, intel]
script:
- launch_game --headless
- verify_main_menu_reached
- check_no_errors
```
### Screenshot Comparison
- Capture screenshots on different GPUs
- Compare for rendering differences
- Flag significant deviations
### Cloud Testing Services
- AWS Device Farm
- BrowserStack (web games)
- LambdaTest
- Sauce Labs
## Compatibility Checklist
### Pre-Alpha
- [ ] Minimum specs defined
- [ ] Key platforms identified
- [ ] Test matrix created
- [ ] Test hardware acquired/rented
### Alpha
- [ ] Full playthrough on min spec
- [ ] Controller support verified
- [ ] Major graphics issues found
- [ ] Platform SDK integrated
### Beta
- [ ] All matrix configurations tested
- [ ] Edge cases explored
- [ ] Certification pre-check done
- [ ] Store page requirements met
### Release
- [ ] Final certification passed
- [ ] Known issues documented
- [ ] Workarounds communicated
- [ ] Support matrix published
## Documenting Compatibility
### System Requirements
```
MINIMUM:
- OS: Windows 10 64-bit
- Processor: Intel Core i5-6400 or AMD equivalent
- Memory: 8 GB RAM
- Graphics: NVIDIA GTX 1050 or AMD RX 560
- Storage: 50 GB available space
RECOMMENDED:
- OS: Windows 11 64-bit
- Processor: Intel Core i7-10700 or AMD equivalent
- Memory: 16 GB RAM
- Graphics: NVIDIA RTX 3060 or AMD RX 6700 XT
- Storage: 50 GB SSD
```
### Known Issues
Maintain a public-facing list of known compatibility issues with:
- Affected configurations
- Symptoms
- Workarounds
- Fix status

1013
src/modules/bmgd/gametest/knowledge/e2e-testing.md
View File

File diff suppressed because it is too large Load Diff

875
src/modules/bmgd/gametest/knowledge/godot-testing.md
View File

@ -1,875 +0,0 @@
# Godot GUT Testing Guide
## Overview
GUT (Godot Unit Test) is the standard unit testing framework for Godot. It provides a full-featured testing framework with assertions, mocking, and CI integration.
## Installation
### Via Asset Library
1. Open AssetLib in Godot
2. Search for "GUT"
3. Download and install
4. Enable the plugin in Project Settings
### Via Git Submodule
```bash
git submodule add https://github.com/bitwes/Gut.git addons/gut
```
## Project Structure
```
project/
├── addons/
│ └── gut/
├── src/
│ ├── player/
│ │ └── player.gd
│ └── combat/
│ └── damage_calculator.gd
└── tests/
├── unit/
│ └── test_damage_calculator.gd
└── integration/
└── test_player_combat.gd
```
## Basic Test Structure
### Simple Test Class
```gdscript
# tests/unit/test_damage_calculator.gd
extends GutTest
var calculator: DamageCalculator
func before_each():
calculator = DamageCalculator.new()
func after_each():
calculator.free()
func test_calculate_base_damage():
var result = calculator.calculate(100.0, 1.0)
assert_eq(result, 100.0, "Base damage should equal input")
func test_calculate_critical_hit():
var result = calculator.calculate(100.0, 2.0)
assert_eq(result, 200.0, "Critical hit should double damage")
func test_calculate_with_zero_multiplier():
var result = calculator.calculate(100.0, 0.0)
assert_eq(result, 0.0, "Zero multiplier should result in zero damage")
```
### Parameterized Tests
```gdscript
func test_damage_scenarios():
var scenarios = [
{"base": 100.0, "mult": 1.0, "expected": 100.0},
{"base": 100.0, "mult": 2.0, "expected": 200.0},
{"base": 50.0, "mult": 1.5, "expected": 75.0},
{"base": 0.0, "mult": 2.0, "expected": 0.0},
]
for scenario in scenarios:
var result = calculator.calculate(scenario.base, scenario.mult)
assert_eq(
result,
scenario.expected,
"Base %s * %s should equal %s" % [
scenario.base, scenario.mult, scenario.expected
]
)
```
## Testing Nodes
### Scene Testing
```gdscript
# tests/integration/test_player.gd
extends GutTest
var player: Player
var player_scene = preload("res://src/player/player.tscn")
func before_each():
player = player_scene.instantiate()
add_child(player)
func after_each():
player.queue_free()
func test_player_initial_health():
assert_eq(player.health, 100, "Player should start with 100 health")
func test_player_takes_damage():
player.take_damage(30)
assert_eq(player.health, 70, "Health should be reduced by damage")
func test_player_dies_at_zero_health():
player.take_damage(100)
assert_true(player.is_dead, "Player should be dead at 0 health")
```
### Testing with Signals
```gdscript
func test_damage_emits_signal():
watch_signals(player)
player.take_damage(10)
assert_signal_emitted(player, "health_changed")
assert_signal_emit_count(player, "health_changed", 1)
func test_death_emits_signal():
watch_signals(player)
player.take_damage(100)
assert_signal_emitted(player, "died")
```
### Testing with Await
```gdscript
func test_attack_cooldown():
player.attack()
assert_true(player.is_attacking)
# Wait for cooldown
await get_tree().create_timer(player.attack_cooldown).timeout
assert_false(player.is_attacking)
assert_true(player.can_attack)
```
## Mocking and Doubles
### Creating Doubles
```gdscript
func test_enemy_uses_pathfinding():
var mock_pathfinding = double(Pathfinding).new()
stub(mock_pathfinding, "find_path").to_return([Vector2(0, 0), Vector2(10, 10)])
var enemy = Enemy.new()
enemy.pathfinding = mock_pathfinding
enemy.move_to(Vector2(10, 10))
assert_called(mock_pathfinding, "find_path")
```
### Partial Doubles
```gdscript
func test_player_inventory():
var player_double = partial_double(Player).new()
stub(player_double, "save_to_disk").to_do_nothing()
player_double.add_item("sword")
assert_eq(player_double.inventory.size(), 1)
assert_called(player_double, "save_to_disk")
```
## Physics Testing
### Testing Collision
```gdscript
func test_projectile_hits_enemy():
var projectile = Projectile.new()
var enemy = Enemy.new()
add_child(projectile)
add_child(enemy)
projectile.global_position = Vector2(0, 0)
enemy.global_position = Vector2(100, 0)
projectile.velocity = Vector2(200, 0)
# Simulate physics frames
for i in range(60):
await get_tree().physics_frame
assert_true(enemy.was_hit, "Enemy should be hit by projectile")
projectile.queue_free()
enemy.queue_free()
```
### Testing Area2D
```gdscript
func test_pickup_collected():
var pickup = Pickup.new()
var player = player_scene.instantiate()
add_child(pickup)
add_child(player)
pickup.global_position = Vector2(50, 50)
player.global_position = Vector2(50, 50)
# Wait for physics to process overlap
await get_tree().physics_frame
await get_tree().physics_frame
assert_true(pickup.is_queued_for_deletion(), "Pickup should be collected")
player.queue_free()
```
## Input Testing
### Simulating Input
```gdscript
func test_jump_on_input():
var input_event = InputEventKey.new()
input_event.keycode = KEY_SPACE
input_event.pressed = true
Input.parse_input_event(input_event)
await get_tree().process_frame
player._unhandled_input(input_event)
assert_true(player.is_jumping, "Player should jump on space press")
```
### Testing Input Actions
```gdscript
func test_attack_action():
# Simulate action press
Input.action_press("attack")
await get_tree().process_frame
player._process(0.016)
assert_true(player.is_attacking)
Input.action_release("attack")
```
## Resource Testing
### Testing Custom Resources
```gdscript
func test_weapon_stats_resource():
var weapon = WeaponStats.new()
weapon.base_damage = 10.0
weapon.attack_speed = 2.0
assert_eq(weapon.dps, 20.0, "DPS should be damage * speed")
func test_save_load_resource():
var original = PlayerData.new()
original.level = 5
original.gold = 1000
ResourceSaver.save(original, "user://test_save.tres")
var loaded = ResourceLoader.load("user://test_save.tres")
assert_eq(loaded.level, 5)
assert_eq(loaded.gold, 1000)
DirAccess.remove_absolute("user://test_save.tres")
```
## GUT Configuration
### gut_config.json
```json
{
"dirs": ["res://tests/"],
"include_subdirs": true,
"prefix": "test_",
"suffix": ".gd",
"should_exit": true,
"should_exit_on_success": true,
"log_level": 1,
"junit_xml_file": "results.xml",
"font_size": 16
}
```
## CI Integration
### Command Line Execution
```bash
# Run all tests
godot --headless -s addons/gut/gut_cmdln.gd
# Run specific tests
godot --headless -s addons/gut/gut_cmdln.gd \
-gdir=res://tests/unit \
-gprefix=test_
# With JUnit output
godot --headless -s addons/gut/gut_cmdln.gd \
-gjunit_xml_file=results.xml
```
### GitHub Actions
```yaml
test:
runs-on: ubuntu-latest
container:
image: barichello/godot-ci:4.2
steps:
- uses: actions/checkout@v4
- name: Run Tests
run: |
godot --headless -s addons/gut/gut_cmdln.gd \
-gjunit_xml_file=results.xml
- name: Publish Results
uses: mikepenz/action-junit-report@v4
with:
report_paths: results.xml
```
## Best Practices
### DO
- Use `before_each`/`after_each` for setup/teardown
- Free nodes after tests to prevent leaks
- Use meaningful assertion messages
- Group related tests in the same file
- Use `watch_signals` for signal testing
- Await physics frames when testing physics
### DON'T
- Don't test Godot's built-in functionality
- Don't rely on execution order between test files
- Don't leave orphan nodes
- Don't use `yield` (use `await` in Godot 4)
- Don't test private methods directly
## Troubleshooting
| Issue | Cause | Fix |
| -------------------- | ------------------ | ------------------------------------ |
| Tests not found | Wrong prefix/path | Check gut_config.json |
| Orphan nodes warning | Missing cleanup | Add `queue_free()` in `after_each` |
| Signal not detected | Signal not watched | Call `watch_signals()` before action |
| Physics not working | Missing frames | Await `physics_frame` |
| Flaky tests | Timing issues | Use proper await/signals |
## C# Testing in Godot
Godot 4 supports C# via .NET 6+. You can use standard .NET testing frameworks alongside GUT.
### Project Setup for C#
```
project/
├── addons/
│ └── gut/
├── src/
│ ├── Player/
│ │ └── PlayerController.cs
│ └── Combat/
│ └── DamageCalculator.cs
├── tests/
│ ├── gdscript/
│ │ └── test_integration.gd
│ └── csharp/
│ ├── Tests.csproj
│ └── DamageCalculatorTests.cs
└── project.csproj
```
### C# Test Project Setup
Create a separate test project that references your game assembly:
```xml
<!-- tests/csharp/Tests.csproj -->
<Project Sdk="Godot.NET.Sdk/4.2.0">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
<EnableDynamicLoading>true</EnableDynamicLoading>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
<PackageReference Include="xunit" Version="2.6.2" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.5.4" />
<PackageReference Include="NSubstitute" Version="5.1.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="../../project.csproj" />
</ItemGroup>
</Project>
```
### Basic C# Unit Tests
```csharp
// tests/csharp/DamageCalculatorTests.cs
using Xunit;
using YourGame.Combat;
public class DamageCalculatorTests
{
private readonly DamageCalculator _calculator;
public DamageCalculatorTests()
{
_calculator = new DamageCalculator();
}
[Fact]
public void Calculate_BaseDamage_ReturnsCorrectValue()
{
var result = _calculator.Calculate(100f, 1f);
Assert.Equal(100f, result);
}
[Fact]
public void Calculate_CriticalHit_DoublesDamage()
{
var result = _calculator.Calculate(100f, 2f);
Assert.Equal(200f, result);
}
[Theory]
[InlineData(100f, 0.5f, 50f)]
[InlineData(100f, 1.5f, 150f)]
[InlineData(50f, 2f, 100f)]
public void Calculate_Parameterized_ReturnsExpected(
float baseDamage, float multiplier, float expected)
{
var result = _calculator.Calculate(baseDamage, multiplier);
Assert.Equal(expected, result);
}
}
```
### Testing Godot Nodes in C#
For tests requiring Godot runtime, use a hybrid approach:
```csharp
// tests/csharp/PlayerControllerTests.cs
using Godot;
using Xunit;
using YourGame.Player;
public class PlayerControllerTests : IDisposable
{
private readonly SceneTree _sceneTree;
private PlayerController _player;
public PlayerControllerTests()
{
// These tests must run within Godot runtime
// Use GodotXUnit or similar adapter
}
[GodotFact] // Custom attribute for Godot runtime tests
public async Task Player_Move_ChangesPosition()
{
var startPos = _player.GlobalPosition;
_player.SetInput(new Vector2(1, 0));
await ToSignal(GetTree().CreateTimer(0.5f), "timeout");
Assert.True(_player.GlobalPosition.X > startPos.X);
}
public void Dispose()
{
_player?.QueueFree();
}
}
```
### C# Mocking with NSubstitute
```csharp
using NSubstitute;
using Xunit;
public class EnemyAITests
{
[Fact]
public void Enemy_UsesPathfinding_WhenMoving()
{
var mockPathfinding = Substitute.For<IPathfinding>();
mockPathfinding.FindPath(Arg.Any<Vector2>(), Arg.Any<Vector2>())
.Returns(new[] { Vector2.Zero, new Vector2(10, 10) });
var enemy = new EnemyAI(mockPathfinding);
enemy.MoveTo(new Vector2(10, 10));
mockPathfinding.Received().FindPath(
Arg.Any<Vector2>(),
Arg.Is<Vector2>(v => v == new Vector2(10, 10)));
}
}
```
### Running C# Tests
```bash
# Run C# unit tests (no Godot runtime needed)
dotnet test tests/csharp/Tests.csproj
# Run with coverage
dotnet test tests/csharp/Tests.csproj --collect:"XPlat Code Coverage"
# Run specific test
dotnet test tests/csharp/Tests.csproj --filter "FullyQualifiedName~DamageCalculator"
```
### Hybrid Test Strategy
| Test Type | Framework | When to Use |
| ------------- | ---------------- | ---------------------------------- |
| Pure logic | xUnit/NUnit (C#) | Classes without Godot dependencies |
| Node behavior | GUT (GDScript) | MonoBehaviour-like testing |
| Integration | GUT (GDScript) | Scene and signal testing |
| E2E | GUT (GDScript) | Full gameplay flows |
## End-to-End Testing
For comprehensive E2E testing patterns, infrastructure scaffolding, and
scenario builders, see **knowledge/e2e-testing.md**.
### E2E Infrastructure for Godot
#### GameE2ETestFixture (GDScript)
```gdscript
# tests/e2e/infrastructure/game_e2e_test_fixture.gd
extends GutTest
class_name GameE2ETestFixture
var game_state: GameStateManager
var input_sim: InputSimulator
var scenario: ScenarioBuilder
var _scene_instance: Node
## Override to specify a different scene for specific test classes.
func get_scene_path() -> String:
return "res://scenes/game.tscn"
func before_each():
# Load game scene
var scene = load(get_scene_path())
_scene_instance = scene.instantiate()
add_child(_scene_instance)
# Get references
game_state = _scene_instance.get_node("GameStateManager")
assert_not_null(game_state, "GameStateManager not found in scene")
input_sim = InputSimulator.new()
scenario = ScenarioBuilder.new(game_state)
# Wait for ready
await wait_for_game_ready()
func after_each():
if _scene_instance:
_scene_instance.queue_free()
_scene_instance = null
input_sim = null
scenario = null
func wait_for_game_ready(timeout: float = 10.0):
var elapsed = 0.0
while not game_state.is_ready and elapsed < timeout:
await get_tree().process_frame
elapsed += get_process_delta_time()
assert_true(game_state.is_ready, "Game should be ready within timeout")
```
#### ScenarioBuilder (GDScript)
```gdscript
# tests/e2e/infrastructure/scenario_builder.gd
extends RefCounted
class_name ScenarioBuilder
var _game_state: GameStateManager
var _setup_actions: Array[Callable] = []
func _init(game_state: GameStateManager):
_game_state = game_state
## Load a pre-configured scenario from a save file.
func from_save_file(file_name: String) -> ScenarioBuilder:
_setup_actions.append(func(): await _load_save_file(file_name))
return self
## Configure the current turn number.
func on_turn(turn_number: int) -> ScenarioBuilder:
_setup_actions.append(func(): _set_turn(turn_number))
return self
## Spawn a unit at position.
func with_unit(faction: int, position: Vector2, movement_points: int = 6) -> ScenarioBuilder:
_setup_actions.append(func(): await _spawn_unit(faction, position, movement_points))
return self
## Execute all configured setup actions.
func build() -> void:
for action in _setup_actions:
await action.call()
_setup_actions.clear()
## Clear pending actions without executing.
func reset() -> void:
_setup_actions.clear()
# Private implementation
func _load_save_file(file_name: String) -> void:
var path = "res://tests/e2e/test_data/%s" % file_name
await _game_state.load_game(path)
func _set_turn(turn: int) -> void:
_game_state.set_turn_number(turn)
func _spawn_unit(faction: int, pos: Vector2, mp: int) -> void:
var unit = _game_state.spawn_unit(faction, pos)
unit.movement_points = mp
```
#### InputSimulator (GDScript)
```gdscript
# tests/e2e/infrastructure/input_simulator.gd
extends RefCounted
class_name InputSimulator
## Click at a world position.
func click_world_position(world_pos: Vector2) -> void:
var viewport = Engine.get_main_loop().root.get_viewport()
var camera = viewport.get_camera_2d()
var screen_pos = camera.get_screen_center_position() + (world_pos - camera.global_position)
await click_screen_position(screen_pos)
## Click at a screen position.
func click_screen_position(screen_pos: Vector2) -> void:
var press = InputEventMouseButton.new()
press.button_index = MOUSE_BUTTON_LEFT
press.pressed = true
press.position = screen_pos
var release = InputEventMouseButton.new()
release.button_index = MOUSE_BUTTON_LEFT
release.pressed = false
release.position = screen_pos
Input.parse_input_event(press)
await Engine.get_main_loop().process_frame
Input.parse_input_event(release)
await Engine.get_main_loop().process_frame
## Click a UI button by name.
func click_button(button_name: String) -> void:
var root = Engine.get_main_loop().root
var button = _find_button_recursive(root, button_name)
assert(button != null, "Button '%s' not found in scene tree" % button_name)
if not button.visible:
push_warning("[InputSimulator] Button '%s' is not visible" % button_name)
if button.disabled:
push_warning("[InputSimulator] Button '%s' is disabled" % button_name)
button.pressed.emit()
await Engine.get_main_loop().process_frame
func _find_button_recursive(node: Node, button_name: String) -> Button:
if node is Button and node.name == button_name:
return node
for child in node.get_children():
var found = _find_button_recursive(child, button_name)
if found:
return found
return null
## Press and release a key.
func press_key(keycode: Key) -> void:
var press = InputEventKey.new()
press.keycode = keycode
press.pressed = true
var release = InputEventKey.new()
release.keycode = keycode
release.pressed = false
Input.parse_input_event(press)
await Engine.get_main_loop().process_frame
Input.parse_input_event(release)
await Engine.get_main_loop().process_frame
## Simulate an input action.
func action_press(action_name: String) -> void:
Input.action_press(action_name)
await Engine.get_main_loop().process_frame
func action_release(action_name: String) -> void:
Input.action_release(action_name)
await Engine.get_main_loop().process_frame
## Reset all input state.
func reset() -> void:
Input.flush_buffered_events()
```
#### AsyncAssert (GDScript)
```gdscript
# tests/e2e/infrastructure/async_assert.gd
extends RefCounted
class_name AsyncAssert
## Wait until condition is true, or fail after timeout.
static func wait_until(
condition: Callable,
description: String,
timeout: float = 5.0
) -> void:
var elapsed := 0.0
while not condition.call() and elapsed < timeout:
await Engine.get_main_loop().process_frame
elapsed += Engine.get_main_loop().root.get_process_delta_time()
assert(condition.call(),
"Timeout after %.1fs waiting for: %s" % [timeout, description])
## Wait for a value to equal expected.
static func wait_for_value(
getter: Callable,
expected: Variant,
description: String,
timeout: float = 5.0
) -> void:
await wait_until(
func(): return getter.call() == expected,
"%s to equal '%s' (current: '%s')" % [description, expected, getter.call()],
timeout)
## Wait for a float value within tolerance.
static func wait_for_value_approx(
getter: Callable,
expected: float,
description: String,
tolerance: float = 0.0001,
timeout: float = 5.0
) -> void:
await wait_until(
func(): return absf(expected - getter.call()) < tolerance,
"%s to equal ~%s ±%s (current: %s)" % [description, expected, tolerance, getter.call()],
timeout)
## Assert that condition does NOT become true within duration.
static func assert_never_true(
condition: Callable,
description: String,
duration: float = 1.0
) -> void:
var elapsed := 0.0
while elapsed < duration:
assert(not condition.call(),
"Condition unexpectedly became true: %s" % description)
await Engine.get_main_loop().process_frame
elapsed += Engine.get_main_loop().root.get_process_delta_time()
## Wait for specified number of frames.
static func wait_frames(count: int) -> void:
for i in range(count):
await Engine.get_main_loop().process_frame
## Wait for physics to settle.
static func wait_for_physics(frames: int = 3) -> void:
for i in range(frames):
await Engine.get_main_loop().root.get_tree().physics_frame
```
### Example E2E Test (GDScript)
```gdscript
# tests/e2e/scenarios/test_combat_flow.gd
extends GameE2ETestFixture
func test_player_can_attack_enemy():
# GIVEN: Player and enemy in combat range
await scenario \
.with_unit(Faction.PLAYER, Vector2(100, 100)) \
.with_unit(Faction.ENEMY, Vector2(150, 100)) \
.build()
var enemy = game_state.get_units(Faction.ENEMY)[0]
var initial_health = enemy.health
# WHEN: Player attacks
await input_sim.click_world_position(Vector2(100, 100)) # Select player
await AsyncAssert.wait_until(
func(): return game_state.selected_unit != null,
"Unit should be selected")
await input_sim.click_world_position(Vector2(150, 100)) # Attack enemy
# THEN: Enemy takes damage
await AsyncAssert.wait_until(
func(): return enemy.health < initial_health,
"Enemy should take damage")
func test_turn_cycle_completes():
# GIVEN: Game in progress
await scenario.on_turn(1).build()
var starting_turn = game_state.turn_number
# WHEN: Player ends turn
await input_sim.click_button("EndTurnButton")
await AsyncAssert.wait_until(
func(): return game_state.current_faction == Faction.ENEMY,
"Should switch to enemy turn")
# AND: Enemy turn completes
await AsyncAssert.wait_until(
func(): return game_state.current_faction == Faction.PLAYER,
"Should return to player turn",
30.0) # AI might take a while
# THEN: Turn number incremented
assert_eq(game_state.turn_number, starting_turn + 1)
```
### Quick E2E Checklist for Godot
- [ ] Create `GameE2ETestFixture` base class extending GutTest
- [ ] Implement `ScenarioBuilder` for your game's domain
- [ ] Create `InputSimulator` wrapping Godot Input
- [ ] Add `AsyncAssert` utilities with proper await
- [ ] Organize E2E tests under `tests/e2e/scenarios/`
- [ ] Configure GUT to include E2E test directory
- [ ] Set up CI with headless Godot execution

315
src/modules/bmgd/gametest/knowledge/input-testing.md
View File

@ -1,315 +0,0 @@
# Input Testing Guide
## Overview
Input testing validates that all supported input devices work correctly across platforms. Poor input handling frustrates players instantly—responsive, accurate input is foundational to game feel.
## Input Categories
### Device Types
| Device | Platforms | Key Concerns |
| ----------------- | -------------- | ----------------------------------- |
| Keyboard + Mouse | PC | Key conflicts, DPI sensitivity |
| Gamepad (Xbox/PS) | PC, Console | Deadzone, vibration, button prompts |
| Touch | Mobile, Switch | Multi-touch, gesture recognition |
| Motion Controls | Switch, VR | Calibration, drift, fatigue |
| Specialty | Various | Flight sticks, wheels, fight sticks |
### Input Characteristics
| Characteristic | Description | Test Focus |
| -------------- | ---------------------------- | -------------------------------- |
| Responsiveness | Input-to-action delay | Should feel instant (< 100ms) |
| Accuracy | Input maps to correct action | No ghost inputs or missed inputs |
| Consistency | Same input = same result | Deterministic behavior |
| Accessibility | Alternative input support | Remapping, assist options |
## Test Scenarios
### Keyboard and Mouse
```
SCENARIO: All Keybinds Functional
GIVEN default keyboard bindings
WHEN each bound key is pressed
THEN corresponding action triggers
AND no key conflicts exist
SCENARIO: Key Remapping
GIVEN player remaps "Jump" from Space to F
WHEN F is pressed
THEN jump action triggers
AND Space no longer triggers jump
AND remapping persists after restart
SCENARIO: Mouse Sensitivity
GIVEN sensitivity set to 5 (mid-range)
WHEN mouse moves 10cm
THEN camera rotation matches expected degrees
AND movement feels consistent at different frame rates
SCENARIO: Mouse Button Support
GIVEN mouse with 5+ buttons
WHEN side buttons are pressed
THEN they can be bound to actions
AND they function correctly in gameplay
```
### Gamepad
```
SCENARIO: Analog Stick Deadzone
GIVEN controller with slight stick drift
WHEN stick is in neutral position
THEN no movement occurs (deadzone filters drift)
AND intentional small movements still register
SCENARIO: Trigger Pressure
GIVEN analog triggers
WHEN trigger is partially pressed
THEN partial values are read (e.g., 0.5 for half-press)
AND full press reaches 1.0
SCENARIO: Controller Hot-Swap
GIVEN game running with keyboard
WHEN gamepad is connected
THEN input prompts switch to gamepad icons
AND gamepad input works immediately
AND keyboard still works if used
SCENARIO: Vibration Feedback
GIVEN rumble-enabled controller
WHEN damage is taken
THEN controller vibrates appropriately
AND vibration intensity matches damage severity
```
### Touch Input
```
SCENARIO: Multi-Touch Accuracy
GIVEN virtual joystick and buttons
WHEN left thumb on joystick AND right thumb on button
THEN both inputs register simultaneously
AND no interference between touch points
SCENARIO: Gesture Recognition
GIVEN swipe-to-attack mechanic
WHEN player swipes right
THEN attack direction matches swipe
AND swipe is distinguished from tap
SCENARIO: Touch Target Size
GIVEN minimum touch target of 44x44 points
WHEN buttons are placed
THEN all interactive elements meet minimum size
AND elements have adequate spacing
```
## Platform-Specific Testing
### PC
- Multiple keyboard layouts (QWERTY, AZERTY, QWERTZ)
- Different mouse DPI settings (400-3200+)
- Multiple monitors (cursor confinement)
- Background application conflicts
- Steam Input API integration
### Console
| Platform | Specific Tests |
| ----------- | ------------------------------------------ |
| PlayStation | Touchpad, adaptive triggers, haptics |
| Xbox | Impulse triggers, Elite controller paddles |
| Switch | Joy-Con detachment, gyro, HD rumble |
### Mobile
- Different screen sizes and aspect ratios
- Notch/cutout avoidance
- External controller support
- Apple MFi / Android gamepad compatibility
## Automated Test Examples
### Unity
```csharp
using UnityEngine.InputSystem;
[UnityTest]
public IEnumerator Movement_WithGamepad_RespondsToStick()
{
var gamepad = InputSystem.AddDevice<Gamepad>();
yield return null;
// Simulate stick input
Set(gamepad.leftStick, new Vector2(1, 0));
yield return new WaitForSeconds(0.1f);
Assert.Greater(player.transform.position.x, 0f,
"Player should move right");
InputSystem.RemoveDevice(gamepad);
}
[UnityTest]
public IEnumerator InputLatency_UnderLoad_StaysAcceptable()
{
float inputTime = Time.realtimeSinceStartup;
bool actionTriggered = false;
player.OnJump += () => {
float latency = (Time.realtimeSinceStartup - inputTime) * 1000;
Assert.Less(latency, 100f, "Input latency should be under 100ms");
actionTriggered = true;
};
var keyboard = InputSystem.AddDevice<Keyboard>();
Press(keyboard.spaceKey);
yield return new WaitForSeconds(0.2f);
Assert.IsTrue(actionTriggered, "Jump should have triggered");
}
[Test]
public void Deadzone_FiltersSmallInputs()
{
var settings = new InputSettings { stickDeadzone = 0.2f };
// Input below deadzone
var filtered = InputProcessor.ApplyDeadzone(new Vector2(0.1f, 0.1f), settings);
Assert.AreEqual(Vector2.zero, filtered);
// Input above deadzone
filtered = InputProcessor.ApplyDeadzone(new Vector2(0.5f, 0.5f), settings);
Assert.AreNotEqual(Vector2.zero, filtered);
}
```
### Unreal
```cpp
bool FInputTest::RunTest(const FString& Parameters)
{
// Test gamepad input mapping
APlayerController* PC = GetWorld()->GetFirstPlayerController();
// Simulate gamepad stick input
FInputKeyParams Params;
Params.Key = EKeys::Gamepad_LeftX;
Params.Delta = FVector(1.0f, 0, 0);
PC->InputKey(Params);
// Verify movement
APawn* Pawn = PC->GetPawn();
FVector Velocity = Pawn->GetVelocity();
TestTrue("Pawn should be moving", Velocity.SizeSquared() > 0);
return true;
}
```
### Godot
```gdscript
func test_input_action_mapping():
# Verify action exists
assert_true(InputMap.has_action("jump"))
# Simulate input
var event = InputEventKey.new()
event.keycode = KEY_SPACE
event.pressed = true
Input.parse_input_event(event)
await get_tree().process_frame
assert_true(Input.is_action_just_pressed("jump"))
func test_gamepad_deadzone():
var input = Vector2(0.15, 0.1)
var deadzone = 0.2
var processed = input_processor.apply_deadzone(input, deadzone)
assert_eq(processed, Vector2.ZERO, "Small input should be filtered")
func test_controller_hotswap():
# Simulate controller connect
Input.joy_connection_changed(0, true)
await get_tree().process_frame
var prompt_icon = ui.get_action_prompt("jump")
assert_true(prompt_icon.texture.resource_path.contains("gamepad"),
"Should show gamepad prompts after controller connect")
```
## Accessibility Testing
### Requirements Checklist
- [ ] Full keyboard navigation (no mouse required)
- [ ] Remappable controls for all actions
- [ ] Button hold alternatives to rapid press
- [ ] Toggle options for hold actions
- [ ] One-handed control schemes
- [ ] Colorblind-friendly UI indicators
- [ ] Screen reader support for menus
### Accessibility Test Scenarios
```
SCENARIO: Keyboard-Only Navigation
GIVEN mouse is disconnected
WHEN navigating through all menus
THEN all menu items are reachable via keyboard
AND focus indicators are clearly visible
SCENARIO: Button Hold Toggle
GIVEN "sprint requires hold" is toggled OFF
WHEN sprint button is tapped once
THEN sprint activates
AND sprint stays active until tapped again
SCENARIO: Reduced Button Mashing
GIVEN QTE assist mode enabled
WHEN QTE sequence appears
THEN single press advances sequence
AND no rapid input required
```
## Performance Metrics
| Metric | Target | Maximum Acceptable |
| ----------------------- | --------------- | ------------------ |
| Input-to-render latency | < 50ms | 100ms |
| Polling rate match | 1:1 with device | No input loss |
| Deadzone processing | < 1ms | 5ms |
| Rebind save/load | < 100ms | 500ms |
## Best Practices
### DO
- Test with actual hardware, not just simulated input
- Support simultaneous keyboard + gamepad
- Provide sensible default deadzones
- Show device-appropriate button prompts
- Allow complete control remapping
- Test at different frame rates
### DON'T
- Assume controller layout (Xbox vs PlayStation)
- Hard-code input mappings
- Ignore analog input precision
- Skip accessibility considerations
- Forget about input during loading/cutscenes
- Neglect testing with worn/drifting controllers

304
src/modules/bmgd/gametest/knowledge/localization-testing.md
View File

@ -1,304 +0,0 @@
# Localization Testing Guide
## Overview
Localization testing ensures games work correctly across languages, regions, and cultures. Beyond translation, it validates text display, cultural appropriateness, and regional compliance.
## Test Categories
### Linguistic Testing
| Category | Focus | Examples |
| -------------------- | ----------------------- | ------------------------------ |
| Translation accuracy | Meaning preserved | Idioms, game terminology |
| Grammar/spelling | Language correctness | Verb tense, punctuation |
| Consistency | Same terms throughout | "Health" vs "HP" vs "Life" |
| Context | Meaning in game context | Item names, skill descriptions |
### Functional Testing
| Category | Focus | Examples |
| -------------- | ----------------------- | --------------------------- |
| Text display | Fits in UI | Button labels, dialog boxes |
| Font support | Characters render | CJK, Cyrillic, Arabic |
| Text expansion | Longer translations | German is ~30% longer |
| RTL support | Right-to-left languages | Arabic, Hebrew layouts |
### Cultural Testing
| Category | Focus | Examples |
| -------------------- | ------------------ | ------------------------- |
| Cultural sensitivity | Offensive content | Gestures, symbols, colors |
| Regional compliance | Legal requirements | Ratings, gambling laws |
| Date/time formats | Local conventions | DD/MM/YYYY vs MM/DD/YYYY |
| Number formats | Decimal separators | 1,000.00 vs 1.000,00 |
## Test Scenarios
### Text Display
```
SCENARIO: Text Fits UI Elements
GIVEN all localized strings
WHEN displayed in target language
THEN text fits within UI boundaries
AND no truncation or overflow occurs
AND text remains readable
SCENARIO: Dynamic Text Insertion
GIVEN template "Player {name} scored {points} points"
WHEN name="Alexander" and points=1000
THEN German: "Spieler Alexander hat 1.000 Punkte erzielt"
AND text fits UI element
AND variables are correctly formatted for locale
SCENARIO: Plural Forms
GIVEN English "1 coin" / "5 coins"
WHEN displaying in Polish (4 plural forms)
THEN correct plural form is used
AND all plural forms are translated
```
### Character Support
```
SCENARIO: CJK Character Rendering
GIVEN Japanese localization
WHEN displaying text with kanji/hiragana/katakana
THEN all characters render correctly
AND no missing glyphs (tofu boxes)
AND line breaks respect CJK rules
SCENARIO: Special Characters
GIVEN text with accented characters (é, ñ, ü)
WHEN displayed in-game
THEN all characters render correctly
AND sorting works correctly
SCENARIO: User-Generated Content
GIVEN player can name character
WHEN name includes non-Latin characters
THEN name displays correctly
AND name saves/loads correctly
AND name appears correctly to other players
```
### Layout and Direction
```
SCENARIO: Right-to-Left Layout
GIVEN Arabic localization
WHEN viewing UI
THEN text reads right-to-left
AND UI elements mirror appropriately
AND numbers remain left-to-right
AND mixed content (Arabic + English) displays correctly
SCENARIO: Text Expansion Accommodation
GIVEN English UI "OK" / "Cancel" buttons
WHEN localized to German "OK" / "Abbrechen"
THEN button expands or text size adjusts
AND button remains clickable
AND layout doesn't break
```
## Locale-Specific Formatting
### Date and Time
| Locale | Date Format | Time Format |
| ------ | -------------- | ----------- |
| en-US | 12/25/2024 | 3:30 PM |
| en-GB | 25/12/2024 | 15:30 |
| de-DE | 25.12.2024 | 15:30 Uhr |
| ja-JP | 2024年12月25日 | 15時30分 |
### Numbers and Currency
| Locale | Number | Currency |
| ------ | -------- | ---------- |
| en-US | 1,234.56 | $1,234.56 |
| de-DE | 1.234,56 | 1.234,56 € |
| fr-FR | 1 234,56 | 1 234,56 € |
| ja-JP | 1,234.56 | ¥1,235 |
## Automated Test Examples
### Unity
```csharp
using UnityEngine.Localization;
[Test]
public void Localization_AllKeysHaveTranslations([Values("en", "de", "ja", "zh-CN")] string locale)
{
var stringTable = LocalizationSettings.StringDatabase
.GetTable("GameStrings", new Locale(locale));
foreach (var entry in stringTable)
{
Assert.IsFalse(string.IsNullOrEmpty(entry.Value.LocalizedValue),
$"Missing translation for '{entry.Key}' in {locale}");
}
}
[Test]
public void TextFits_AllUIElements()
{
var languages = new[] { "en", "de", "fr", "ja" };
foreach (var lang in languages)
{
LocalizationSettings.SelectedLocale = new Locale(lang);
foreach (var textElement in FindObjectsOfType<LocalizedText>())
{
var rectTransform = textElement.GetComponent<RectTransform>();
var textComponent = textElement.GetComponent<Text>();
Assert.LessOrEqual(
textComponent.preferredWidth,
rectTransform.rect.width,
$"Text overflows in {lang}: {textElement.name}");
}
}
}
[TestCase("en", 1, "1 coin")]
[TestCase("en", 5, "5 coins")]
[TestCase("ru", 1, "1 монета")]
[TestCase("ru", 2, "2 монеты")]
[TestCase("ru", 5, "5 монет")]
public void Pluralization_ReturnsCorrectForm(string locale, int count, string expected)
{
var result = Localization.GetPlural("coin", count, locale);
Assert.AreEqual(expected, result);
}
```
### Unreal
```cpp
bool FLocalizationTest::RunTest(const FString& Parameters)
{
TArray<FString> Cultures = {"en", "de", "ja", "ko"};
for (const FString& Culture : Cultures)
{
FInternationalization::Get().SetCurrentCulture(Culture);
// Test critical strings exist
FText LocalizedText = NSLOCTEXT("Game", "StartButton", "Start");
TestFalse(
FString::Printf(TEXT("Missing StartButton in %s"), *Culture),
LocalizedText.IsEmpty());
// Test number formatting
FText NumberText = FText::AsNumber(1234567);
TestTrue(
TEXT("Number should be formatted"),
NumberText.ToString().Len() > 7); // Has separators
}
return true;
}
```
### Godot
```gdscript
func test_all_translations_complete():
var locales = ["en", "de", "ja", "es"]
var keys = TranslationServer.get_all_keys()
for locale in locales:
TranslationServer.set_locale(locale)
for key in keys:
var translated = tr(key)
assert_ne(translated, key,
"Missing translation for '%s' in %s" % [key, locale])
func test_plural_forms():
TranslationServer.set_locale("ru")
assert_eq(tr_n("coin", "coins", 1), "1 монета")
assert_eq(tr_n("coin", "coins", 2), "2 монеты")
assert_eq(tr_n("coin", "coins", 5), "5 монет")
assert_eq(tr_n("coin", "coins", 21), "21 монета")
func test_text_fits_buttons():
var locales = ["en", "de", "fr"]
for locale in locales:
TranslationServer.set_locale(locale)
await get_tree().process_frame # Allow UI update
for button in get_tree().get_nodes_in_group("localized_buttons"):
var label = button.get_node("Label")
assert_lt(label.size.x, button.size.x,
"Button text overflows in %s: %s" % [locale, button.name])
```
## Visual Verification Checklist
### Text Display
- [ ] No truncation in any language
- [ ] Consistent font sizing
- [ ] Proper line breaks
- [ ] No overlapping text
### UI Layout
- [ ] Buttons accommodate longer text
- [ ] Dialog boxes resize appropriately
- [ ] Menu items align correctly
- [ ] Scrollbars appear when needed
### Cultural Elements
- [ ] Icons are culturally appropriate
- [ ] Colors don't have negative connotations
- [ ] Gestures are region-appropriate
- [ ] No unintended political references
## Regional Compliance
### Ratings Requirements
| Region | Rating Board | Special Requirements |
| ------------- | ------------ | ------------------------- |
| North America | ESRB | Content descriptors |
| Europe | PEGI | Age-appropriate icons |
| Japan | CERO | Strict content guidelines |
| Germany | USK | Violence restrictions |
| China | GRAC | Approval process |
### Common Regional Issues
| Issue | Regions Affected | Solution |
| ---------------- | ---------------- | ------------------------ |
| Blood color | Japan, Germany | Option for green/disable |
| Gambling imagery | Many regions | Remove or modify |
| Skulls/bones | China | Alternative designs |
| Nazi imagery | Germany | Remove entirely |
## Best Practices
### DO
- Test with native speakers
- Plan for text expansion (reserve 30% extra space)
- Use placeholder text during development (Lorem ipsum-style)
- Support multiple input methods (IME for CJK)
- Test all language combinations (UI language + audio language)
- Validate string format parameters
### DON'T
- Hard-code strings in source code
- Assume left-to-right layout
- Concatenate translated strings
- Use machine translation without review
- Forget about date/time/number formatting
- Ignore cultural context of images and icons

322
src/modules/bmgd/gametest/knowledge/multiplayer-testing.md
View File

@ -1,322 +0,0 @@
# Multiplayer Testing Guide
## Overview
Multiplayer testing validates network code, synchronization, and the player experience under real-world conditions. Network bugs are notoriously hard to reproduce—systematic testing is essential.
## Test Categories
### Synchronization Testing
| Test Type | Description | Priority |
| ------------------- | ---------------------------------------- | -------- |
| State sync | All clients see consistent game state | P0 |
| Position sync | Character positions match across clients | P0 |
| Event ordering | Actions occur in correct sequence | P0 |
| Conflict resolution | Simultaneous actions handled correctly | P1 |
| Late join | New players sync correctly mid-game | P1 |
### Network Conditions
| Condition | Simulation Method | Test Focus |
| --------------- | ----------------- | ------------------------ |
| High latency | 200-500ms delay | Input responsiveness |
| Packet loss | 5-20% drop rate | State recovery |
| Jitter | Variable delay | Interpolation smoothness |
| Bandwidth limit | Throttle to 1Mbps | Data prioritization |
| Disconnection | Kill connection | Reconnection handling |
## Test Scenarios
### Basic Multiplayer
```
SCENARIO: Player Join/Leave
GIVEN host has started multiplayer session
WHEN Player 2 joins
THEN Player 2 appears in host's game
AND Player 1 appears in Player 2's game
AND player counts sync across all clients
SCENARIO: State Synchronization
GIVEN 4 players in match
WHEN Player 1 picks up item at position (10, 5)
THEN item disappears for all players
AND Player 1's inventory updates for all players
AND no duplicate pickups possible
SCENARIO: Combat Synchronization
GIVEN Player 1 attacks Player 2
WHEN attack hits
THEN damage is consistent on all clients
AND hit effects play for all players
AND health updates sync within 100ms
```
### Network Degradation
```
SCENARIO: High Latency Gameplay
GIVEN 200ms latency between players
WHEN Player 1 moves forward
THEN movement is smooth on Player 1's screen
AND other players see interpolated movement
AND position converges within 500ms
SCENARIO: Packet Loss Recovery
GIVEN 10% packet loss
WHEN important game event occurs (goal, kill, etc.)
THEN event is eventually delivered
AND game state remains consistent
AND no duplicate events processed
SCENARIO: Player Disconnection
GIVEN Player 2 disconnects unexpectedly
WHEN 5 seconds pass
THEN other players are notified
AND Player 2's character handles gracefully (despawn/AI takeover)
AND game continues without crash
```
### Edge Cases
```
SCENARIO: Simultaneous Actions
GIVEN Player 1 and Player 2 grab same item simultaneously
WHEN both inputs arrive at server
THEN only one player receives item
AND other player sees consistent state
AND no item duplication
SCENARIO: Host Migration
GIVEN host disconnects
WHEN migration begins
THEN new host is selected
AND game state transfers correctly
AND gameplay resumes within 10 seconds
SCENARIO: Reconnection
GIVEN Player 2 disconnects temporarily
WHEN Player 2 reconnects within 60 seconds
THEN Player 2 rejoins same session
AND state is synchronized
AND progress is preserved
```
## Network Simulation Tools
### Unity
```csharp
// Using Unity Transport with Network Simulator
using Unity.Netcode;
public class NetworkSimulator : MonoBehaviour
{
[SerializeField] private int latencyMs = 100;
[SerializeField] private float packetLossPercent = 5f;
[SerializeField] private int jitterMs = 20;
void Start()
{
var transport = NetworkManager.Singleton.GetComponent<UnityTransport>();
var simulator = transport.GetSimulatorParameters();
simulator.PacketDelayMS = latencyMs;
simulator.PacketDropRate = (int)(packetLossPercent * 100);
simulator.PacketJitterMS = jitterMs;
}
}
// Test
[UnityTest]
public IEnumerator Position_UnderLatency_ConvergesWithinThreshold()
{
EnableNetworkSimulation(latencyMs: 200);
// Move player
player1.Move(Vector3.forward * 10);
yield return new WaitForSeconds(1f);
// Check other client's view
var player1OnClient2 = client2.GetPlayerPosition(player1.Id);
var actualPosition = player1.transform.position;
Assert.Less(Vector3.Distance(player1OnClient2, actualPosition), 0.5f);
}
```
### Unreal
```cpp
// Using Network Emulation
void UNetworkTestHelper::EnableLatencySimulation(int32 LatencyMs)
{
if (UNetDriver* NetDriver = GetWorld()->GetNetDriver())
{
FPacketSimulationSettings Settings;
Settings.PktLag = LatencyMs;
Settings.PktLagVariance = LatencyMs / 10;
Settings.PktLoss = 0;
NetDriver->SetPacketSimulationSettings(Settings);
}
}
// Functional test for sync
void AMultiplayerSyncTest::StartTest()
{
Super::StartTest();
// Spawn item on server
APickupItem* Item = GetWorld()->SpawnActor<APickupItem>(
ItemClass, FVector(0, 0, 100));
// Wait for replication
FTimerHandle TimerHandle;
GetWorld()->GetTimerManager().SetTimer(TimerHandle, [this, Item]()
{
// Verify client has item
if (VerifyItemExistsOnAllClients(Item))
{
FinishTest(EFunctionalTestResult::Succeeded, "Item replicated");
}
else
{
FinishTest(EFunctionalTestResult::Failed, "Item not found on clients");
}
}, 2.0f, false);
}
```
### Godot
```gdscript
# Network simulation
extends Node
var simulated_latency_ms := 0
var packet_loss_percent := 0.0
func _ready():
# Hook into network to simulate conditions
multiplayer.peer_packet_received.connect(_on_packet_received)
func _on_packet_received(id: int, packet: PackedByteArray):
if packet_loss_percent > 0 and randf() < packet_loss_percent / 100:
return # Drop packet
if simulated_latency_ms > 0:
await get_tree().create_timer(simulated_latency_ms / 1000.0).timeout
_process_packet(id, packet)
# Test
func test_position_sync_under_latency():
NetworkSimulator.simulated_latency_ms = 200
# Move player on host
host_player.position = Vector3(100, 0, 100)
await get_tree().create_timer(1.0).timeout
# Check client view
var client_view_position = client.get_remote_player_position(host_player.id)
var distance = host_player.position.distance_to(client_view_position)
assert_lt(distance, 1.0, "Position should converge within 1 unit")
```
## Dedicated Server Testing
### Test Matrix
| Scenario | Test Focus |
| --------------------- | ------------------------------------ |
| Server startup | Clean initialization, port binding |
| Client authentication | Login validation, session management |
| Server tick rate | Consistent updates under load |
| Maximum players | Performance at player cap |
| Server crash recovery | State preservation, reconnection |
### Load Testing
```
SCENARIO: Maximum Players
GIVEN server configured for 64 players
WHEN 64 players connect
THEN all connections succeed
AND server tick rate stays above 60Hz
AND latency stays below 50ms
SCENARIO: Stress Test
GIVEN 64 players performing actions simultaneously
WHEN running for 10 minutes
THEN no memory leaks
AND no desync events
AND server CPU below 80%
```
## Matchmaking Testing
```
SCENARIO: Skill-Based Matching
GIVEN players with skill ratings [1000, 1050, 2000, 2100]
WHEN matchmaking runs
THEN [1000, 1050] are grouped together
AND [2000, 2100] are grouped together
SCENARIO: Region Matching
GIVEN players from US-East, US-West, EU
WHEN matchmaking runs
THEN players prefer same-region matches
AND cross-region only when necessary
AND latency is acceptable for all players
SCENARIO: Queue Timeout
GIVEN player waiting in queue
WHEN 3 minutes pass without match
THEN matchmaking expands search criteria
AND player is notified of expanded search
```
## Security Testing
| Vulnerability | Test Method |
| ---------------- | --------------------------- |
| Speed hacking | Validate movement on server |
| Teleportation | Check position delta limits |
| Damage hacking | Server-authoritative damage |
| Packet injection | Validate packet checksums |
| Replay attacks | Use unique session tokens |
## Performance Metrics
| Metric | Good | Acceptable | Poor |
| --------------------- | --------- | ---------- | ---------- |
| Round-trip latency | < 50ms | < 100ms | > 150ms |
| Sync delta | < 100ms | < 200ms | > 500ms |
| Packet loss tolerance | < 5% | < 10% | > 15% |
| Bandwidth per player | < 10 KB/s | < 50 KB/s | > 100 KB/s |
| Server tick rate | 60+ Hz | 30+ Hz | < 20 Hz |
## Best Practices
### DO
- Test with real network conditions, not just localhost
- Simulate worst-case scenarios (high latency + packet loss)
- Use server-authoritative design for competitive games
- Implement lag compensation for fast-paced games
- Test host migration paths
- Log network events for debugging
### DON'T
- Trust client data for important game state
- Assume stable connections
- Skip testing with maximum player counts
- Ignore edge cases (simultaneous actions)
- Test only in ideal network conditions
- Forget to test reconnection flows

204
src/modules/bmgd/gametest/knowledge/performance-testing.md
View File

@ -1,204 +0,0 @@
# Performance Testing for Games
## Overview
Performance testing ensures your game runs smoothly on target hardware. Frame rate, load times, and memory usage directly impact player experience.
## Key Performance Metrics
### Frame Rate
- **Target:** 30fps, 60fps, 120fps depending on platform/genre
- **Measure:** Average, minimum, 1% low, 0.1% low
- **Goal:** Consistent frame times, no stutters
### Frame Time Budget
At 60fps, you have 16.67ms per frame:
```
Rendering: 8ms (48%)
Game Logic: 4ms (24%)
Physics: 2ms (12%)
Audio: 1ms (6%)
UI: 1ms (6%)
Headroom: 0.67ms (4%)
```
### Memory
- **RAM:** Total allocation, peak usage, fragmentation
- **VRAM:** Texture memory, render targets, buffers
- **Goal:** Stay within platform limits with headroom
### Load Times
- **Initial Load:** Time to main menu
- **Level Load:** Time between scenes
- **Streaming:** Asset loading during gameplay
- **Goal:** Meet platform certification requirements
## Profiling Tools by Engine
### Unity
- **Profiler Window** - CPU, GPU, memory, rendering
- **Frame Debugger** - Draw call analysis
- **Memory Profiler** - Heap snapshots
- **Profile Analyzer** - Compare captures
### Unreal Engine
- **Unreal Insights** - Comprehensive profiling
- **Stat Commands** - Runtime statistics
- **GPU Visualizer** - GPU timing breakdown
- **Memory Report** - Allocation tracking
### Godot
- **Debugger** - Built-in profiler
- **Monitors** - Real-time metrics
- **Remote Debugger** - Profile on device
### Platform Tools
- **PIX** (Xbox/Windows) - GPU debugging
- **RenderDoc** - GPU capture and replay
- **Instruments** (iOS/macOS) - Apple profiling
- **Android Profiler** - Android Studio tools
## Performance Testing Process
### 1. Establish Baselines
- Profile on target hardware
- Record key metrics
- Create benchmark scenes
### 2. Set Budgets
- Define frame time budgets per system
- Set memory limits
- Establish load time targets
### 3. Monitor Continuously
- Integrate profiling in CI
- Track metrics over time
- Alert on regressions
### 4. Optimize When Needed
- Profile before optimizing
- Target biggest bottlenecks
- Verify improvements
## Common Performance Issues
### CPU Bottlenecks
| Issue | Symptoms | Solution |
| --------------------- | ----------------- | --------------------------------- |
| Too many game objects | Slow update loop | Object pooling, LOD |
| Expensive AI | Spiky frame times | Budget AI, spread over frames |
| Physics overload | Physics spikes | Simplify colliders, reduce bodies |
| GC stutter | Regular hitches | Avoid runtime allocations |
### GPU Bottlenecks
| Issue | Symptoms | Solution |
| ------------------- | ----------------- | -------------------------------- |
| Overdraw | Fill rate limited | Occlusion culling, reduce layers |
| Too many draw calls | CPU-GPU bound | Batching, instancing, atlasing |
| Shader complexity | Long GPU times | Simplify shaders, LOD |
| Resolution too high | Fill rate limited | Dynamic resolution, FSR/DLSS |
### Memory Issues
| Issue | Symptoms | Solution |
| ------------- | ----------------- | ---------------------------- |
| Texture bloat | High VRAM | Compress, mipmap, stream |
| Leaks | Growing memory | Track allocations, fix leaks |
| Fragmentation | OOM despite space | Pool allocations, defrag |
## Benchmark Scenes
Create standardized test scenarios:
### Stress Test Scene
- Maximum entities on screen
- Complex visual effects
- Worst-case for performance
### Typical Gameplay Scene
- Representative of normal play
- Average entity count
- Baseline for comparison
### Isolated System Tests
- Combat only (no rendering)
- Rendering only (no game logic)
- AI only (pathfinding stress)
## Automated Performance Testing
### CI Integration
```yaml
# Example: Fail build if frame time exceeds budget
performance_test:
script:
- run_benchmark --scene stress_test
- check_metrics --max-frame-time 16.67ms --max-memory 2GB
artifacts:
- performance_report.json
```
### Regression Detection
- Compare against previous builds
- Alert on significant changes (>10%)
- Track trends over time
## Platform-Specific Considerations
### Console
- Fixed hardware targets
- Strict certification requirements
- Thermal throttling concerns
### PC
- Wide hardware range
- Scalable quality settings
- Min/recommended specs
### Mobile
- Thermal throttling
- Battery impact
- Memory constraints
- Background app pressure
## Performance Testing Checklist
### Before Release
- [ ] Profiled on all target platforms
- [ ] Frame rate targets met
- [ ] No memory leaks
- [ ] Load times acceptable
- [ ] No GC stutters in gameplay
- [ ] Thermal tests passed (mobile/console)
- [ ] Certification requirements met
### Ongoing
- [ ] Performance tracked in CI
- [ ] Regression alerts configured
- [ ] Benchmark scenes maintained
- [ ] Budgets documented and enforced

384
src/modules/bmgd/gametest/knowledge/playtesting.md
View File

@ -1,384 +0,0 @@
# Playtesting Fundamentals
## Overview
Playtesting is the process of having people play your game to gather feedback and identify issues. It's distinct from QA testing in that it focuses on player experience, fun factor, and design validation rather than bug hunting.
## Types of Playtesting
### Internal Playtesting
- **Developer Testing** - Daily testing during development
- **Team Testing** - Cross-discipline team plays together
- **Best for:** Rapid iteration, catching obvious issues
### External Playtesting
- **Friends & Family** - Trusted external testers
- **Focus Groups** - Targeted demographic testing
- **Public Beta** - Large-scale community testing
- **Best for:** Fresh perspectives, UX validation
### Specialized Playtesting
- **Accessibility Testing** - Players with disabilities
- **Localization Testing** - Regional/cultural validation
- **Competitive Testing** - Balance and meta testing
## Playtesting Process
### 1. Define Goals
Before each playtest session, define:
- What questions are you trying to answer?
- What features are you testing?
- What metrics will you gather?
### 2. Prepare the Build
- Create a stable, playable build
- Include telemetry/logging if needed
- Prepare any necessary documentation
### 3. Brief Testers
- Explain what to test (or don't, for blind testing)
- Set expectations for bugs/polish level
- Provide feedback mechanisms
### 4. Observe and Record
- Watch players without intervening
- Note confusion points, frustration, delight
- Record gameplay if possible
### 5. Gather Feedback
- Structured surveys for quantitative data
- Open discussion for qualitative insights
- Allow time for "what else?" comments
### 6. Analyze and Act
- Identify patterns across testers
- Prioritize issues by frequency and severity
- Create actionable tasks from findings
## Key Metrics to Track
### Engagement Metrics
- Session length
- Return rate
- Completion rate
- Drop-off points
### Difficulty Metrics
- Deaths/failures per section
- Time to complete sections
- Hint/help usage
- Difficulty setting distribution
### UX Metrics
- Time to first action
- Tutorial completion rate
- Menu navigation patterns
- Control scheme preferences
## Playtesting by Game Type
Different genres require different playtesting approaches and focus areas.
### Action/Platformer Games
**Focus Areas:**
- Control responsiveness and "game feel"
- Difficulty curve across levels
- Checkpoint placement and frustration points
- Visual clarity during fast-paced action
**Key Questions:**
- Does the character feel good to control?
- Are deaths feeling fair or cheap?
- Is the player learning organically or hitting walls?
### RPG/Story Games
**Focus Areas:**
- Narrative pacing and engagement
- Quest clarity and tracking
- Character/dialogue believability
- Progression and reward timing
**Key Questions:**
- Do players understand their current objective?
- Are choices feeling meaningful?
- Is the story holding attention or being skipped?
### Puzzle Games
**Focus Areas:**
- Solution discoverability
- "Aha moment" timing
- Hint system effectiveness
- Difficulty progression
**Key Questions:**
- Are players solving puzzles the intended way?
- How long before frustration sets in?
- Do solutions feel satisfying or arbitrary?
### Multiplayer/Competitive Games
**Focus Areas:**
- Balance across characters/builds/strategies
- Meta development and dominant strategies
- Social dynamics and toxicity vectors
- Matchmaking feel
**Key Questions:**
- Are there "must-pick" or "never-pick" options?
- Do losing players understand why they lost?
- Is the skill ceiling high enough for mastery?
### Survival/Sandbox Games
**Focus Areas:**
- Early game onboarding and survival
- Goal clarity vs. freedom balance
- Resource economy and pacing
- Emergent gameplay moments
**Key Questions:**
- Do players know what to do first?
- Is the loop engaging beyond the first hour?
- Are players creating their own goals?
### Mobile/Casual Games
**Focus Areas:**
- Session length appropriateness
- One-hand playability (if applicable)
- Interruption handling (calls, notifications)
- Monetization friction points
**Key Questions:**
- Can players play in 2-minute sessions?
- Is the core loop immediately understandable?
- Where do players churn?
### Horror Games
**Focus Areas:**
- Tension and release pacing
- Scare effectiveness and desensitization
- Safe space placement
- Audio/visual atmosphere
**Key Questions:**
- When do players feel safe vs. threatened?
- Are scares landing or becoming predictable?
- Is anxiety sustainable or exhausting?
## Processing Feedback Effectively
Raw feedback is noise. Processed feedback is signal.
### The Feedback Processing Pipeline
```
Raw Feedback → Categorize → Pattern Match → Root Cause → Prioritize → Action
```
### Step 1: Categorize Feedback
Sort all feedback into buckets:
| Category | Examples |
| ------------- | ---------------------------------- |
| **Bugs** | Crashes, glitches, broken features |
| **Usability** | Confusing UI, unclear objectives |
| **Balance** | Too hard, too easy, unfair |
| **Feel** | Controls, pacing, satisfaction |
| **Content** | Wants more of X, dislikes Y |
| **Polish** | Audio, visuals, juice |
### Step 2: Pattern Matching
Individual feedback is anecdotal. Patterns are data.
**Threshold Guidelines:**
- 1 person mentions it → Note it
- 3+ people mention it → Investigate
- 50%+ mention it → Priority issue
**Watch for:**
- Same complaint, different words
- Same area, different complaints (signals deeper issue)
- Contradictory feedback (may indicate preference split)
### Step 3: Root Cause Analysis
Players report symptoms, not diseases.
**Example:**
- **Symptom:** "The boss is too hard"
- **Possible Root Causes:**
- Boss mechanics unclear
- Player didn't learn required skill earlier
- Checkpoint too far from boss
- Health/damage tuning off
- Boss pattern has no safe windows
**Ask "Why?" five times** to get to root cause.
### Step 4: Separate Fact from Opinion
| Fact (Actionable) | Opinion (Context) |
| --------------------------------- | ----------------------- |
| "I died 12 times on level 3" | "Level 3 is too hard" |
| "I didn't use the shield ability" | "The shield is useless" |
| "I quit after 20 minutes" | "The game is boring" |
**Facts tell you WHAT happened. Opinions tell you how they FELT about it.**
Both matter, but facts drive solutions.
### Step 5: The Feedback Matrix
Plot issues on impact vs. effort:
```
High Impact
│
Quick │ Major
Wins │ Projects
│
─────────────┼─────────────
│
Fill │ Reconsider
Time │
│
Low Impact
Low Effort ──────── High Effort
```
### Step 6: Validate Before Acting
Before making changes based on feedback:
1. **Reproduce** - Can you see the issue yourself?
2. **Quantify** - How many players affected?
3. **Contextualize** - Is this your target audience?
4. **Test solutions** - Will the fix create new problems?
### Handling Contradictory Feedback
When Player A wants X and Player B wants the opposite:
1. **Check sample size** - Is it really split or just 2 loud voices?
2. **Segment audiences** - Are these different player types?
3. **Find the underlying need** - Both may want the same thing differently
4. **Consider options** - Difficulty settings, toggles, multiple paths
5. **Make a decision** - You can't please everyone; know your target
### Feedback Red Flags
**Dismiss or investigate carefully:**
- "Make it like [other game]" - They want a feeling, not a clone
- "Add multiplayer" - Feature creep disguised as feedback
- "I would have bought it if..." - Hypothetical customers aren't real
- Feedback from non-target audience - Know who you're building for
**Take seriously:**
- Confusion about core mechanics
- Consistent drop-off at same point
- "I wanted to like it but..."
- Silent quitting (no feedback, just gone)
### Documentation Best Practices
**For each playtest session, record:**
- Date and build version
- Tester demographics/experience
- Session length
- Key observations (timestamped if recorded)
- Quantitative survey results
- Top 3 issues identified
- Actions taken as result
**Maintain a living document** that tracks:
- Issue → First reported → Times reported → Status → Resolution
- This prevents re-discovering the same issues
## Common Playtesting Pitfalls
### Leading Questions
**Bad:** "Did you find the combat exciting?"
**Good:** "How would you describe the combat?"
### Intervening Too Soon
Let players struggle before helping. Confusion is valuable data.
### Testing Too Late
Start playtesting early with paper prototypes and gray boxes.
### Ignoring Negative Feedback
Negative feedback is often the most valuable. Don't dismiss it.
### Over-Relying on Verbal Feedback
Watch what players DO, not just what they SAY. Actions reveal truth.
## Playtesting Checklist
### Pre-Session
- [ ] Goals defined
- [ ] Build stable and deployed
- [ ] Recording setup (if applicable)
- [ ] Feedback forms ready
- [ ] Testers briefed
### During Session
- [ ] Observing without intervening
- [ ] Taking notes on behavior
- [ ] Tracking time markers for notable moments
- [ ] Noting emotional reactions
### Post-Session
- [ ] Feedback collected
- [ ] Patterns identified
- [ ] Priority issues flagged
- [ ] Action items created
- [ ] Results shared with team

190
src/modules/bmgd/gametest/knowledge/qa-automation.md
View File

@ -1,190 +0,0 @@
# QA Automation for Games
## Overview
Automated testing in games requires different approaches than traditional software. Games have complex state, real-time interactions, and subjective quality measures that challenge automation.
## Testing Pyramid for Games
```
/\
/ \ Manual Playtesting
/----\ (Experience, Feel, Fun)
/ \
/--------\ Integration Tests
/ \ (Systems, Workflows)
/------------\
/ \ Unit Tests
/________________\ (Pure Logic, Math, Data)
```
### Unit Tests (Foundation)
Test pure logic that doesn't depend on engine runtime:
- Math utilities (vectors, transforms, curves)
- Data validation (save files, configs)
- State machines (isolated logic)
- Algorithm correctness
### Integration Tests (Middle Layer)
Test system interactions:
- Combat system + inventory
- Save/load round-trips
- Scene transitions
- Network message handling
### Manual Testing (Top)
What can't be automated:
- "Does this feel good?"
- "Is this fun?"
- "Is the difficulty right?"
## Automation Strategies by Engine
### Unity
```csharp
// Unity Test Framework
[Test]
public void DamageCalculation_CriticalHit_DoublesDamage()
{
var baseDamage = 100;
var result = DamageCalculator.Calculate(baseDamage, isCritical: true);
Assert.AreEqual(200, result);
}
// Play Mode Tests (runtime)
[UnityTest]
public IEnumerator PlayerJump_WhenGrounded_BecomesAirborne()
{
var player = CreateTestPlayer();
player.Jump();
yield return new WaitForFixedUpdate();
Assert.IsFalse(player.IsGrounded);
}
```
### Unreal Engine
```cpp
// Automation Framework
IMPLEMENT_SIMPLE_AUTOMATION_TEST(FDamageTest, "Game.Combat.Damage",
EAutomationTestFlags::ApplicationContextMask | EAutomationTestFlags::ProductFilter)
bool FDamageTest::RunTest(const FString& Parameters)
{
float BaseDamage = 100.f;
float Result = UDamageCalculator::Calculate(BaseDamage, true);
TestEqual("Critical hit doubles damage", Result, 200.f);
return true;
}
```
### Godot
```gdscript
# GUT Testing Framework
func test_damage_critical_hit():
var base_damage = 100
var result = DamageCalculator.calculate(base_damage, true)
assert_eq(result, 200, "Critical hit should double damage")
```
## What to Automate
### High Value Targets
- **Save/Load** - Data integrity is critical
- **Economy** - Currency, items, progression math
- **Combat Math** - Damage, stats, modifiers
- **Localization** - String loading, formatting
- **Network Serialization** - Message encoding/decoding
### Medium Value Targets
- **State Machines** - Character states, game states
- **Pathfinding** - Known scenarios
- **Spawning** - Wave generation, loot tables
- **UI Data Binding** - Correct values displayed
### Low Value / Avoid
- **Visual Quality** - Screenshots drift, hard to maintain
- **Input Feel** - Timing-sensitive, needs human judgment
- **Audio** - Subjective, context-dependent
- **Fun** - Cannot be automated
## Continuous Integration for Games
### Build Pipeline
1. **Compile** - Build game executable
2. **Unit Tests** - Fast, isolated tests
3. **Integration Tests** - Longer, system tests
4. **Smoke Test** - Can the game launch and reach main menu?
5. **Nightly** - Extended test suites, performance benchmarks
### CI Gotchas for Games
- **Long build times** - Games take longer than web apps
- **GPU requirements** - Some tests need graphics hardware
- **Asset dependencies** - Large files, binary formats
- **Platform builds** - Multiple targets to maintain
## Regression Testing
### Automated Regression
- Run full test suite on every commit
- Flag performance regressions (frame time, memory)
- Track test stability (flaky tests)
### Save File Regression
- Maintain library of save files from previous versions
- Test that new builds can load old saves
- Alert on schema changes
## Test Data Management
### Test Fixtures
```
tests/
├── fixtures/
│ ├── save_files/
│ │ ├── new_game.sav
│ │ ├── mid_game.sav
│ │ └── endgame.sav
│ ├── configs/
│ │ └── test_balance.json
│ └── scenarios/
│ └── boss_fight_setup.scene
```
### Deterministic Testing
- Seed random number generators
- Control time/delta time
- Mock external services
## Metrics and Reporting
### Track Over Time
- Test count (growing is good)
- Pass rate (should be ~100%)
- Execution time (catch slow tests)
- Code coverage (where applicable)
- Flaky test rate (should be ~0%)
### Alerts
- Immediate: Any test failure on main branch
- Daily: Coverage drops, new flaky tests
- Weekly: Trend analysis, slow test growth

280
src/modules/bmgd/gametest/knowledge/regression-testing.md
View File

@ -1,280 +0,0 @@
# Regression Testing for Games
## Overview
Regression testing catches bugs introduced by new changes. In games, this includes functional regressions, performance regressions, and design regressions.
## Types of Regression
### Functional Regression
- Features that worked before now break
- New bugs introduced by unrelated changes
- Broken integrations between systems
### Performance Regression
- Frame rate drops
- Memory usage increases
- Load time increases
- Battery drain (mobile)
### Design Regression
- Balance changes with unintended side effects
- UX changes that hurt usability
- Art changes that break visual consistency
### Save Data Regression
- Old save files no longer load
- Progression lost or corrupted
- Achievements/unlocks reset
## Regression Testing Strategy
### Test Suite Layers
```
High-Frequency (Every Commit)
├── Unit Tests - Fast, isolated
├── Smoke Tests - Can game launch and run?
└── Critical Path - Core gameplay works
Medium-Frequency (Nightly)
├── Integration Tests - System interactions
├── Full Playthrough - Automated or manual
└── Performance Benchmarks - Frame time, memory
Low-Frequency (Release)
├── Full Matrix - All platforms/configs
├── Certification Tests - Platform requirements
└── Localization - All languages
```
### What to Test
#### Critical Path (Must Not Break)
- Game launches
- New game starts
- Save/load works
- Core gameplay loop completes
- Main menu navigation
#### High Priority
- All game systems function
- Progression works end-to-end
- Multiplayer connects and syncs
- In-app purchases process
- Achievements trigger
#### Medium Priority
- Edge cases in systems
- Optional content accessible
- Settings persist correctly
- Localization displays
## Automated Regression Tests
### Smoke Tests
```python
# Run on every commit
def test_game_launches():
process = launch_game()
assert wait_for_main_menu(timeout=30)
process.terminate()
def test_new_game_starts():
launch_game()
click_new_game()
assert wait_for_gameplay(timeout=60)
def test_save_load_roundtrip():
launch_game()
start_new_game()
perform_actions()
save_game()
load_game()
assert verify_state_matches()
```
### Playthrough Bots
```python
# Automated player that plays through content
class PlaythroughBot:
def run_level(self, level):
self.load_level(level)
while not self.level_complete:
self.perform_action()
self.check_for_softlocks()
self.record_metrics()
```
### Visual Regression
```python
# Compare screenshots against baselines
def test_main_menu_visual():
launch_game()
screenshot = capture_screen()
assert compare_to_baseline(screenshot, 'main_menu', threshold=0.01)
```
## Performance Regression Detection
### Metrics to Track
- Average frame time
- 1% low frame time
- Memory usage (peak, average)
- Load times
- Draw calls
- Texture memory
### Automated Benchmarks
```yaml
performance_benchmark:
script:
- run_benchmark_scene --duration 60s
- collect_metrics
- compare_to_baseline
fail_conditions:
- frame_time_avg > baseline * 1.1 # 10% tolerance
- memory_peak > baseline * 1.05 # 5% tolerance
```
### Trend Tracking
- Graph metrics over time
- Alert on upward trends
- Identify problematic commits
## Save Compatibility Testing
### Version Matrix
Maintain save files from:
- Previous major version
- Previous minor version
- Current development build
### Automated Validation
```python
def test_save_compatibility():
for save_file in LEGACY_SAVES:
load_save(save_file)
assert no_errors()
assert progress_preserved()
assert inventory_intact()
```
### Schema Versioning
- Version your save format
- Implement upgrade paths
- Log migration issues
## Regression Bug Workflow
### 1. Detection
- Automated test fails
- Manual tester finds issue
- Player report comes in
### 2. Verification
- Confirm it worked before
- Identify when it broke
- Find the breaking commit
### 3. Triage
- Assess severity
- Determine fix urgency
- Assign to appropriate developer
### 4. Fix and Verify
- Implement fix
- Add regression test
- Verify fix doesn't break other things
### 5. Post-Mortem
- Why wasn't this caught?
- How can we prevent similar issues?
- Do we need new tests?
## Bisecting Regressions
When a regression is found, identify the breaking commit:
### Git Bisect
```bash
git bisect start
git bisect bad HEAD # Current is broken
git bisect good v1.2.0 # Known good version
# Git will checkout commits to test
# Run test, mark good/bad
git bisect good/bad
# Repeat until culprit found
```
### Automated Bisect
```bash
git bisect start HEAD v1.2.0
git bisect run ./run_regression_test.sh
```
## Regression Testing Checklist
### Per Commit
- [ ] Unit tests pass
- [ ] Smoke tests pass
- [ ] Build succeeds on all platforms
### Per Merge to Main
- [ ] Integration tests pass
- [ ] Performance benchmarks within tolerance
- [ ] Save compatibility verified
### Per Release
- [ ] Full playthrough completed
- [ ] All platforms tested
- [ ] Legacy saves load correctly
- [ ] No new critical regressions
- [ ] All previous hotfix issues still resolved
## Building a Regression Suite
### Start Small
1. Add tests for bugs as they're fixed
2. Cover critical path first
3. Expand coverage over time
### Maintain Quality
- Delete flaky tests
- Keep tests fast
- Update tests with design changes
### Measure Effectiveness
- Track bugs caught by tests
- Track bugs that slipped through
- Identify coverage gaps

280
src/modules/bmgd/gametest/knowledge/save-testing.md
View File

@ -1,280 +0,0 @@
# Save System Testing Guide
## Overview
Save system testing ensures data persistence, integrity, and compatibility across game versions. Save bugs are among the most frustrating for players—data loss destroys trust.
## Test Categories
### Data Integrity
| Test Type | Description | Priority |
| -------------------- | ------------------------------------------- | -------- |
| Round-trip | Save → Load → Verify all data matches | P0 |
| Corruption detection | Tampered/corrupted files handled gracefully | P0 |
| Partial write | Power loss during save doesn't corrupt | P0 |
| Large saves | Performance with max-size save files | P1 |
| Edge values | Min/max values for all saved fields | P1 |
### Version Compatibility
| Scenario | Expected Behavior |
| ----------------------- | ------------------------------------- |
| Current → Current | Full compatibility |
| Old → New (upgrade) | Migration with data preservation |
| New → Old (downgrade) | Graceful rejection or limited support |
| Corrupted version field | Fallback to recovery mode |
## Test Scenarios
### Core Save/Load Tests
```
SCENARIO: Basic Save Round-Trip
GIVEN player has 100 health, 50 gold, position (10, 5, 20)
AND player has inventory: ["sword", "potion", "key"]
WHEN game is saved
AND game is reloaded
THEN player health equals 100
AND player gold equals 50
AND player position equals (10, 5, 20)
AND inventory contains exactly ["sword", "potion", "key"]
SCENARIO: Save During Gameplay
GIVEN player is in combat
AND enemy has 50% health remaining
WHEN autosave triggers
AND game is reloaded
THEN combat state is restored
AND enemy health equals 50%
SCENARIO: Multiple Save Slots
GIVEN save slot 1 has character "Hero" at level 10
AND save slot 2 has character "Mage" at level 5
WHEN switching between slots
THEN correct character data loads for each slot
AND no cross-contamination between slots
```
### Edge Cases
```
SCENARIO: Maximum Inventory Save
GIVEN player has 999 items in inventory
WHEN game is saved
AND game is reloaded
THEN all 999 items are preserved
AND save/load completes within 5 seconds
SCENARIO: Unicode Character Names
GIVEN player name is "プレイヤー名"
WHEN game is saved
AND game is reloaded
THEN player name displays correctly
SCENARIO: Extreme Play Time
GIVEN play time is 9999:59:59
WHEN game is saved
AND game is reloaded
THEN play time displays correctly
AND timer continues from saved value
```
### Corruption Recovery
```
SCENARIO: Corrupted Save Detection
GIVEN save file has been manually corrupted
WHEN game attempts to load
THEN error is detected before loading
AND user is informed of corruption
AND game does not crash
SCENARIO: Missing Save File
GIVEN save file has been deleted externally
WHEN game attempts to load
THEN graceful error handling
AND option to start new game or restore backup
SCENARIO: Interrupted Save (Power Loss)
GIVEN save operation is interrupted mid-write
WHEN game restarts
THEN backup save is detected and offered
AND no data loss from previous valid save
```
## Platform-Specific Testing
### PC (Steam/Epic)
- Cloud save sync conflicts
- Multiple Steam accounts on same PC
- Offline → Online sync
- Save location permissions (Program Files issues)
### Console (PlayStation/Xbox/Switch)
- System-level save management
- Storage full scenarios
- User switching mid-game
- Suspend/resume with unsaved changes
- Cloud save quota limits
### Mobile
- App termination during save
- Low storage warnings
- iCloud/Google Play sync
- Device migration
## Automated Test Examples
### Unity
```csharp
[Test]
public void SaveLoad_PlayerStats_PreservesAllValues()
{
var original = new PlayerData
{
Health = 75,
MaxHealth = 100,
Gold = 1234567,
Position = new Vector3(100.5f, 0, -50.25f),
PlayTime = 36000f // 10 hours
};
SaveManager.Save(original, "test_slot");
var loaded = SaveManager.Load("test_slot");
Assert.AreEqual(original.Health, loaded.Health);
Assert.AreEqual(original.Gold, loaded.Gold);
Assert.AreEqual(original.Position, loaded.Position);
Assert.AreEqual(original.PlayTime, loaded.PlayTime, 0.01f);
}
[Test]
public void SaveLoad_CorruptedFile_HandlesGracefully()
{
File.WriteAllText(SaveManager.GetPath("corrupt"), "INVALID DATA");
Assert.Throws<SaveCorruptedException>(() =>
SaveManager.Load("corrupt"));
// Game should not crash
Assert.IsTrue(SaveManager.IsValidSaveSlot("corrupt") == false);
}
```
### Unreal
```cpp
bool FSaveSystemTest::RunTest(const FString& Parameters)
{
// Create test save
USaveGame* SaveGame = UGameplayStatics::CreateSaveGameObject(
UMySaveGame::StaticClass());
UMySaveGame* MySave = Cast<UMySaveGame>(SaveGame);
MySave->PlayerLevel = 50;
MySave->Gold = 999999;
MySave->QuestsCompleted = {"Quest1", "Quest2", "Quest3"};
// Save
UGameplayStatics::SaveGameToSlot(MySave, "TestSlot", 0);
// Load
USaveGame* Loaded = UGameplayStatics::LoadGameFromSlot("TestSlot", 0);
UMySaveGame* LoadedSave = Cast<UMySaveGame>(Loaded);
TestEqual("Level preserved", LoadedSave->PlayerLevel, 50);
TestEqual("Gold preserved", LoadedSave->Gold, 999999);
TestEqual("Quests count", LoadedSave->QuestsCompleted.Num(), 3);
return true;
}
```
### Godot
```gdscript
func test_save_load_round_trip():
var original = {
"health": 100,
"position": Vector3(10, 0, 20),
"inventory": ["sword", "shield"],
"quest_flags": {"intro_complete": true, "boss_defeated": false}
}
SaveManager.save_game(original, "test_save")
var loaded = SaveManager.load_game("test_save")
assert_eq(loaded.health, 100)
assert_eq(loaded.position, Vector3(10, 0, 20))
assert_eq(loaded.inventory.size(), 2)
assert_true(loaded.quest_flags.intro_complete)
assert_false(loaded.quest_flags.boss_defeated)
func test_corrupted_save_detection():
var file = FileAccess.open("user://saves/corrupt.sav", FileAccess.WRITE)
file.store_string("CORRUPTED GARBAGE DATA")
file.close()
var result = SaveManager.load_game("corrupt")
assert_null(result, "Should return null for corrupted save")
assert_false(SaveManager.is_valid_save("corrupt"))
```
## Migration Testing
### Version Upgrade Matrix
| From Version | To Version | Test Focus |
| -------------- | ---------------- | ---------------------------- |
| 1.0 → 1.1 | Minor update | New fields default correctly |
| 1.x → 2.0 | Major update | Schema migration works |
| Beta → Release | Launch migration | All beta saves convert |
### Migration Test Template
```
SCENARIO: Save Migration v1.0 to v2.0
GIVEN save file from version 1.0
AND save contains old inventory format (array)
WHEN game version 2.0 loads the save
THEN inventory is migrated to new format (dictionary)
AND all items are preserved
AND migration is logged
AND backup of original is created
```
## Performance Benchmarks
| Metric | Target | Maximum |
| ------------------------ | --------------- | ------- |
| Save time (typical) | < 500ms | 2s |
| Save time (large) | < 2s | 5s |
| Load time (typical) | < 1s | 3s |
| Save file size (typical) | < 1MB | 10MB |
| Memory during save | < 50MB overhead | 100MB |
## Best Practices
### DO
- Use atomic saves (write to temp, then rename)
- Keep backup of previous save
- Version your save format
- Encrypt sensitive data
- Test on minimum-spec hardware
- Compress large saves
### DON'T
- Store absolute file paths
- Save derived/calculated data
- Trust save file contents blindly
- Block gameplay during save
- Forget to handle storage-full scenarios
- Skip testing save migration paths

404
src/modules/bmgd/gametest/knowledge/smoke-testing.md
View File

@ -1,404 +0,0 @@
# Smoke Testing Guide
## Overview
Smoke testing (Build Verification Testing) validates that a build's critical functionality works before investing time in detailed testing. A failed smoke test means "stop, this build is broken."
## Purpose
| Goal | Description |
| ------------------- | ---------------------------------------------- |
| Fast feedback | Know within minutes if build is viable |
| Block bad builds | Prevent broken builds from reaching QA/players |
| Critical path focus | Test only what matters most |
| CI/CD integration | Automated gate before deployment |
## Smoke Test Principles
### What Makes a Good Smoke Test
- **Fast**: Complete in 5-15 minutes
- **Critical**: Tests only essential functionality
- **Deterministic**: Same result every run
- **Automated**: No human intervention required
- **Clear**: Pass/fail with actionable feedback
### What to Include
| Category | Examples |
| ----------------- | ------------------------------ |
| Boot sequence | Game launches without crash |
| Core loop | Player can perform main action |
| Save/Load | Data persists correctly |
| Critical UI | Menus are navigable |
| Platform services | Connects to required services |
### What NOT to Include
- Edge cases and boundary conditions
- Performance benchmarks (separate tests)
- Full feature coverage
- Content verification
- Balance testing
## Smoke Test Scenarios
### Boot and Load
```
TEST: Game Launches
WHEN game executable is started
THEN main menu appears within 60 seconds
AND no crashes occur
AND required services connect
TEST: New Game Start
GIVEN game at main menu
WHEN "New Game" is selected
THEN gameplay loads within 30 seconds
AND player can control character
TEST: Continue Game
GIVEN existing save file
WHEN "Continue" is selected
THEN correct save loads
AND game state matches saved state
```
### Core Gameplay
```
TEST: Player Movement
GIVEN player in game world
WHEN movement input applied
THEN player moves in expected direction
AND no physics glitches occur
TEST: Core Action (Game-Specific)
GIVEN player can perform primary action
WHEN action is triggered
THEN action executes correctly
AND expected results occur
Examples:
- Shooter: Can fire weapon, bullets hit targets
- RPG: Can attack enemy, damage is applied
- Puzzle: Can interact with puzzle elements
- Platformer: Can jump, platforms are solid
```
### Save System
```
TEST: Save Creates File
GIVEN player makes progress
WHEN save is triggered
THEN save file is created
AND save completes without error
TEST: Load Restores State
GIVEN valid save file exists
WHEN load is triggered
THEN saved state is restored
AND gameplay can continue
```
### Critical UI
```
TEST: Menu Navigation
GIVEN main menu is displayed
WHEN each menu option is selected
THEN correct screen/action occurs
AND navigation back works
TEST: Settings Persist
GIVEN settings are changed
WHEN game is restarted
THEN settings remain changed
```
## Automated Smoke Test Examples
### Unity
```csharp
using System.Collections;
using NUnit.Framework;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.TestTools;
using UnityEngine.SceneManagement;
[TestFixture]
public class SmokeTests
{
[UnityTest, Timeout(60000)]
public IEnumerator Game_Launches_ToMainMenu()
{
// Load main menu scene
SceneManager.LoadScene("MainMenu");
yield return new WaitForSeconds(5f);
// Verify menu is active
var mainMenu = GameObject.Find("MainMenuCanvas");
Assert.IsNotNull(mainMenu, "Main menu should be present");
Assert.IsTrue(mainMenu.activeInHierarchy, "Main menu should be active");
}
[UnityTest, Timeout(120000)]
public IEnumerator NewGame_LoadsGameplay()
{
// Start from main menu
SceneManager.LoadScene("MainMenu");
yield return new WaitForSeconds(2f);
// Click new game
var newGameButton = GameObject.Find("NewGameButton")
.GetComponent<Button>();
newGameButton.onClick.Invoke();
yield return new WaitForSeconds(10f);
// Verify gameplay scene loaded
Assert.AreEqual("GameplayScene", SceneManager.GetActiveScene().name);
// Verify player exists and can be controlled
var player = GameObject.FindWithTag("Player");
Assert.IsNotNull(player, "Player should exist");
}
[UnityTest, Timeout(30000)]
public IEnumerator Player_CanMove()
{
// Load gameplay
SceneManager.LoadScene("GameplayScene");
yield return new WaitForSeconds(3f);
var player = GameObject.FindWithTag("Player");
var startPos = player.transform.position;
// Simulate movement input
var controller = player.GetComponent<PlayerController>();
controller.SetMoveInput(Vector2.right);
yield return new WaitForSeconds(1f);
// Verify movement occurred
Assert.Greater(player.transform.position.x, startPos.x,
"Player should have moved");
}
[UnityTest, Timeout(30000)]
public IEnumerator SaveLoad_RoundTrip_Works()
{
// Setup test state
SceneManager.LoadScene("GameplayScene");
yield return new WaitForSeconds(2f);
var player = GameObject.FindWithTag("Player");
player.transform.position = new Vector3(100, 0, 100);
// Save
SaveManager.Save("smoke_test");
yield return null;
// Reset position
player.transform.position = Vector3.zero;
// Load
SaveManager.Load("smoke_test");
yield return null;
// Verify
Assert.AreEqual(100f, player.transform.position.x, 1f);
}
}
```
### Unreal
```cpp
// SmokeTests.cpp
IMPLEMENT_SIMPLE_AUTOMATION_TEST(
FGameLaunchTest,
"Smoke.Launch.MainMenu",
EAutomationTestFlags::ApplicationContextMask | EAutomationTestFlags::SmokeFilter
)
bool FGameLaunchTest::RunTest(const FString& Parameters)
{
// Verify main menu widget exists
UWorld* World = GEngine->GetWorldContexts()[0].World();
APlayerController* PC = World->GetFirstPlayerController();
TestNotNull("Player controller exists", PC);
// Check main menu is visible
AMyHUD* HUD = Cast<AMyHUD>(PC->GetHUD());
TestTrue("Main menu is visible", HUD->IsMainMenuVisible());
return true;
}
IMPLEMENT_SIMPLE_AUTOMATION_TEST(
FPlayerMovementTest,
"Smoke.Gameplay.Movement",
EAutomationTestFlags::ApplicationContextMask | EAutomationTestFlags::SmokeFilter
)
bool FPlayerMovementTest::RunTest(const FString& Parameters)
{
APawn* Player = GetTestPlayer();
FVector StartPos = Player->GetActorLocation();
// Apply movement
APlayerController* PC = Cast<APlayerController>(Player->GetController());
PC->AddMovementInput(FVector::ForwardVector, 1.0f);
// Wait for physics
ADD_LATENT_AUTOMATION_COMMAND(FWaitForSeconds(0.5f));
// Note: FVerifyPlayerMoved is a custom latent command - implement to verify player position changed
ADD_LATENT_AUTOMATION_COMMAND(FVerifyPlayerMoved(StartPos));
return true;
}
```
### Godot
```gdscript
# test_smoke.gd
extends GutTest
func test_game_launches():
# Switch to main menu
get_tree().change_scene_to_file("res://scenes/main_menu.tscn")
await get_tree().process_frame
await get_tree().create_timer(2.0).timeout
# Verify main menu loaded
var menu = get_tree().current_scene
assert_not_null(menu, "Main menu should load")
assert_eq(menu.name, "MainMenu", "Should be main menu scene")
func test_new_game_starts():
get_tree().change_scene_to_file("res://scenes/main_menu.tscn")
await get_tree().process_frame
# Find and click new game button
var button = get_tree().current_scene.get_node("NewGameButton")
button.pressed.emit()
await get_tree().create_timer(5.0).timeout
# Verify gameplay loaded
var scene = get_tree().current_scene
assert_eq(scene.name, "GameWorld", "Should load gameplay scene")
var player = scene.get_node("Player")
assert_not_null(player, "Player should exist")
func test_player_can_move():
get_tree().change_scene_to_file("res://scenes/game_world.tscn")
await get_tree().create_timer(1.0).timeout
var player = get_tree().current_scene.get_node("Player")
var start_pos = player.position
# Simulate input
Input.action_press("move_right")
await get_tree().create_timer(0.5).timeout
Input.action_release("move_right")
assert_gt(player.position.x, start_pos.x, "Player should have moved right")
func test_save_load_works():
get_tree().change_scene_to_file("res://scenes/game_world.tscn")
await get_tree().create_timer(1.0).timeout
var player = get_tree().current_scene.get_node("Player")
player.position = Vector2(500, 300)
# Save
SaveManager.save_game("smoke_test")
await get_tree().process_frame
# Reset
player.position = Vector2.ZERO
# Load
SaveManager.load_game("smoke_test")
await get_tree().process_frame
assert_almost_eq(player.position.x, 500.0, 1.0, "Position should restore")
```
## CI/CD Integration
### GitHub Actions Example
```yaml
name: Smoke Tests
on: [push, pull_request]
jobs:
smoke-test:
runs-on: ubuntu-latest
timeout-minutes: 20
steps:
- uses: actions/checkout@v4
- name: Build Game
run: ./build.sh --configuration Release
- name: Run Smoke Tests
run: |
./game --headless --run-tests=Smoke --test-timeout=600
- name: Upload Results
if: always()
uses: actions/upload-artifact@v4
with:
name: smoke-test-results
path: test-results/
```
### Test Execution Order
1. **Build verification** - Binary exists and is valid
2. **Launch test** - Game starts without crash
3. **Menu navigation** - Can navigate to gameplay
4. **Core loop** - Primary mechanic works
5. **Save/Load** - Persistence functions
6. **Cleanup** - No resource leaks
## Smoke Test Metrics
| Metric | Target | Action if Failed |
| -------------- | -------- | ------------------ |
| Pass rate | 100% | Block deployment |
| Execution time | < 15 min | Optimize tests |
| Flakiness | 0% | Fix or remove test |
## Best Practices
### DO
- Run smoke tests on every build
- Keep tests fast and focused
- Fail loudly and clearly
- Test on target platform, not just dev environment
- Include platform service connectivity
- Run before any manual QA begins
### DON'T
- Include slow or flaky tests
- Test edge cases or rare scenarios
- Allow smoke test failures to ship
- Skip smoke tests for "small" changes
- Make smoke tests depend on external services
- Let smoke suite grow beyond 15 minutes

271
src/modules/bmgd/gametest/knowledge/test-priorities.md
View File

@ -1,271 +0,0 @@
# Test Priorities Matrix
## Overview
Not all tests are equal. This guide provides a framework for prioritizing test creation, execution, and maintenance based on risk, impact, and resources.
## Priority Levels
### P0 - Critical (Ship Blockers)
**Definition**: Failures that prevent the game from being playable or shippable.
| Criteria | Examples |
| ---------------------- | ------------------------------ |
| Game cannot start | Crash on launch, infinite load |
| Core loop broken | Cannot perform primary action |
| Data loss | Saves corrupted, progress lost |
| Platform certification | TRC/XR failures |
| Legal/compliance | Rating violations |
**Testing Approach**:
- Automated smoke tests on every build
- Manual verification before any release
- Zero tolerance for P0 bugs in release builds
### P1 - High (Major Features)
**Definition**: Significant functionality that affects most players' experience.
| Criteria | Examples |
| --------------------- | -------------------------------- |
| Major features broken | Multiplayer, progression systems |
| Frequent player paths | Main story, common actions |
| Significant UX issues | Confusing UI, missing feedback |
| Performance problems | Unplayable frame rates |
**Testing Approach**:
- Comprehensive automated tests
- Regular regression testing
- Full coverage in release candidates
### P2 - Medium (Standard Features)
**Definition**: Important functionality that affects significant portions of gameplay.
| Criteria | Examples |
| ------------------ | ----------------------------- |
| Secondary features | Side quests, optional content |
| Edge cases | Unusual player actions |
| Platform-specific | Single-platform issues |
| Minor progression | Non-critical collectibles |
**Testing Approach**:
- Selective automation
- Milestone regression testing
- Coverage prioritized by usage data
### P3 - Low (Polish Items)
**Definition**: Issues that are noticeable but don't significantly impact gameplay.
| Criteria | Examples |
| -------------- | ------------------------------ |
| Visual polish | Minor clipping, texture issues |
| Audio polish | Volume inconsistencies |
| Rare scenarios | Edge cases with workarounds |
| Nice-to-have | QoL improvements |
**Testing Approach**:
- Manual exploratory testing
- Automated only if easy/cheap
- Fixed as time permits
## Risk-Based Prioritization
### Risk Factors
| Factor | High Risk | Low Risk |
| ------------------- | ------------------- | --------------- |
| Usage frequency | Core loop | Rarely accessed |
| Player visibility | Always visible | Hidden/optional |
| Data impact | Saves, progression | Cosmetic only |
| Recovery difficulty | No workaround | Easy to retry |
| Change frequency | Frequently modified | Stable code |
### Risk Assessment Matrix
```
IMPACT
Low High
┌─────────┬─────────┐
High │ P2 │ P0 │
LIKELIHOOD ├─────────┼─────────┤
Low │ P3 │ P1 │
└─────────┴─────────┘
```
## Coverage Targets by Priority
| Priority | Unit Test | Integration | E2E/Smoke | Manual |
| -------- | --------- | ----------- | --------- | ----------- |
| P0 | 100% | 100% | Required | Pre-release |
| P1 | 80%+ | 80%+ | As needed | Milestone |
| P2 | 60%+ | Key paths | Optional | Sprint |
| P3 | Optional | Optional | No | Ad-hoc |
## Test Type Distribution
### Recommended Test Pyramid (Games)
```
▲
/│\
/ │ \ E2E/Smoke Tests (5%)
/ │ \ - Full game flow
/ │ \ - Platform certification
───────────
/ │ \
/ │ \ Integration Tests (25%)
/ │ \ - System interactions
/ │ \ - Network, save, audio
─────────────────────
/ │ \
/ │ \ Unit Tests (70%)
/ │ \ - Pure logic
/ │ \- Algorithms, calculations
───────────────────────────────
```
### Game-Specific Considerations
Unlike web apps, games have unique testing needs:
| Test Type | Standard App | Game-Specific |
| ----------- | -------------- | -------------------------- |
| Unit | Business logic | Damage calc, AI decisions |
| Integration | API + DB | Physics, audio, network |
| E2E | User flows | Gameplay scenarios |
| Additional | N/A | Playtesting, balance, feel |
## Execution Order
### CI Pipeline (Every Commit)
1. P0 smoke tests (5-10 minutes)
2. P0/P1 unit tests (10-15 minutes)
3. P0 integration tests (5-10 minutes)
### Daily/Nightly
1. Full P0 suite
2. Full P1 suite
3. P2 regression suite
4. Performance benchmarks
### Milestone/Release
1. All automated tests
2. Full P0-P2 manual testing
3. Platform certification tests
4. Exploratory testing
5. Performance profiling
## Bug Triage Criteria
### Priority Assignment
| Question | P0 | P1 | P2 | P3 |
| -------------------------- | ---- | --------- | ---- | ---- |
| Can player complete game? | No | Affected | No | No |
| How many players affected? | All | Most | Some | Few |
| Is there a workaround? | No | Difficult | Yes | Easy |
| Data at risk? | Yes | Possible | No | No |
| Platform certification? | Fail | Risk | Pass | Pass |
### Severity vs Priority
```
SEVERITY: How bad is the bug?
Critical → Crash, data loss
Major → Feature broken
Minor → Incorrect behavior
Trivial → Cosmetic
PRIORITY: How soon to fix?
P0 → Immediately (blocks release)
P1 → This sprint
P2 → This milestone
P3 → Backlog
```
## Resource Allocation
### QA Time Distribution
| Activity | Percentage |
| ---------------- | ---------- |
| P0 verification | 30% |
| P1 testing | 30% |
| P2 testing | 20% |
| Exploratory | 15% |
| Test maintenance | 5% |
### Automation Investment
| Priority | Automation Value | ROI |
| -------- | ---------------- | -------------- |
| P0 | Essential | Highest |
| P1 | High | High |
| P2 | Medium | Medium |
| P3 | Low | Often negative |
## Platform Priority Matrix
### Multi-Platform Prioritization
| Platform | Player Base | Certification | Testing Priority |
| ----------------------- | ----------- | ------------- | ----------------- |
| Primary (e.g., PC) | 60% | Light | P0: All, P1: All |
| Secondary (e.g., PS5) | 25% | Heavy | P0: All, P1: Most |
| Tertiary (e.g., Switch) | 15% | Medium | P0: All, P1: Core |
### Cross-Platform Testing Strategy
```
Platform Testing Coverage
PC PS5 Xbox Switch Mobile
P0 ████ ████ ████ ████ ████
P1 ████ ███░ ███░ ██░░ ██░░
P2 ███░ ██░░ ██░░ █░░░ █░░░
P3 ██░░ █░░░ █░░░ ░░░░ ░░░░
████ = Full coverage
███░ = High coverage
██░░ = Medium coverage
█░░░ = Low coverage
░░░░ = Minimal/none
```
## Best Practices
### DO
- Reassess priorities as development progresses
- Weight user-facing features higher
- Consider platform certification requirements
- Focus automation on stable, high-value areas
- Track bug escape rates by priority
### DON'T
- Treat all tests equally
- Automate P3 before P0/P1 coverage is solid
- Skip P0 testing for "small changes"
- Ignore platform-specific requirements
- Let P1/P2 bugs accumulate
## Metrics to Track
| Metric | Target | Purpose |
| ------------------- | ------------- | -------------------- |
| P0 test pass rate | 100% | Build quality |
| P0 bug escape rate | 0% | Test effectiveness |
| P1 coverage | 80%+ | Feature coverage |
| Test execution time | < 30 min (CI) | Development velocity |
| Flaky test rate | < 1% | Test reliability |

397
src/modules/bmgd/gametest/knowledge/unity-testing.md
View File

@ -1,397 +0,0 @@
# Unity Test Framework Guide
## Overview
Unity provides a built-in Test Framework based on NUnit for writing and running automated tests. It supports Edit Mode tests (run without playing) and Play Mode tests (run during gameplay simulation).
## Test Framework Setup
### Package Installation
```json
// manifest.json - usually pre-installed
{
"dependencies": {
"com.unity.test-framework": "1.6.0"
}
}
```
### Project Structure
```
Assets/
├── Scripts/
│ └── Runtime/
│ ├── Player/
│ │ └── PlayerController.cs
│ └── Combat/
│ └── DamageCalculator.cs
└── Tests/
├── EditMode/
│ └── DamageCalculatorTests.cs
└── PlayMode/
└── PlayerMovementTests.cs
```
### Assembly Definitions
Create `.asmdef` files for test assemblies:
```json
// Tests/EditMode/EditModeTests.asmdef
{
"name": "EditModeTests",
"references": ["GameAssembly"],
"includePlatforms": ["Editor"],
"defineConstraints": ["UNITY_INCLUDE_TESTS"]
}
// Tests/PlayMode/PlayModeTests.asmdef
{
"name": "PlayModeTests",
"references": ["GameAssembly"],
"includePlatforms": [],
"defineConstraints": ["UNITY_INCLUDE_TESTS"]
}
```
## Edit Mode Tests
Edit Mode tests run in the Editor without entering Play Mode. Best for testing pure logic.
### Basic Test Structure
```csharp
using NUnit.Framework;
[TestFixture]
public class DamageCalculatorTests
{
private DamageCalculator _calculator;
[SetUp]
public void Setup()
{
_calculator = new DamageCalculator();
}
[Test]
public void Calculate_BaseDamage_ReturnsCorrectValue()
{
float result = _calculator.Calculate(100f, 1f);
Assert.AreEqual(100f, result);
}
[Test]
public void Calculate_CriticalHit_DoublesDamage()
{
float result = _calculator.Calculate(100f, multiplier: 2f);
Assert.AreEqual(200f, result);
}
[TestCase(100f, 0.5f, 50f)]
[TestCase(100f, 1.5f, 150f)]
[TestCase(50f, 2f, 100f)]
public void Calculate_Parameterized_ReturnsExpected(
float base_, float mult, float expected)
{
Assert.AreEqual(expected, _calculator.Calculate(base_, mult));
}
}
```
### Testing ScriptableObjects
```csharp
[Test]
public void WeaponStats_DPS_CalculatesCorrectly()
{
var weapon = ScriptableObject.CreateInstance<WeaponStats>();
weapon.baseDamage = 10f;
weapon.attacksPerSecond = 2f;
Assert.AreEqual(20f, weapon.DPS);
// Cleanup
Object.DestroyImmediate(weapon);
}
```
## Play Mode Tests
Play Mode tests run during gameplay simulation. Required for testing MonoBehaviours, physics, and runtime behavior.
### Basic Play Mode Test
```csharp
using System.Collections;
using NUnit.Framework;
using UnityEngine;
using UnityEngine.TestTools;
public class PlayerMovementTests
{
private GameObject _player;
private PlayerController _controller;
[SetUp]
public void Setup()
{
_player = new GameObject("Player");
_controller = _player.AddComponent<PlayerController>();
_player.AddComponent<Rigidbody>();
_player.AddComponent<CapsuleCollider>();
}
[TearDown]
public void TearDown()
{
Object.Destroy(_player);
}
[UnityTest]
public IEnumerator Move_WhenInputApplied_ChangesPosition()
{
Vector3 startPos = _player.transform.position;
_controller.SetInput(Vector2.right);
yield return new WaitForSeconds(0.5f);
Assert.Greater(_player.transform.position.x, startPos.x);
}
[UnityTest]
public IEnumerator Jump_WhenGrounded_BecomesAirborne()
{
// Setup ground
var ground = GameObject.CreatePrimitive(PrimitiveType.Plane);
_player.transform.position = Vector3.up;
yield return new WaitForFixedUpdate();
_controller.Jump();
yield return new WaitForSeconds(0.1f);
Assert.IsFalse(_controller.IsGrounded);
Object.Destroy(ground);
}
}
```
### Testing Coroutines
```csharp
[UnityTest]
public IEnumerator Attack_Cooldown_PreventsSpam()
{
_controller.Attack();
Assert.IsTrue(_controller.IsAttacking);
_controller.Attack(); // Should be blocked
Assert.AreEqual(1, _controller.AttackCount);
yield return new WaitForSeconds(_controller.AttackCooldown + 0.1f);
_controller.Attack();
Assert.AreEqual(2, _controller.AttackCount);
}
```
### Scene Testing
```csharp
using UnityEngine.SceneManagement;
[UnityTest]
public IEnumerator MainMenu_StartButton_LoadsGameScene()
{
SceneManager.LoadScene("MainMenu");
yield return null; // Wait for scene load
var startButton = GameObject.Find("StartButton")
.GetComponent<Button>();
startButton.onClick.Invoke();
yield return new WaitForSeconds(1f);
Assert.AreEqual("GameScene", SceneManager.GetActiveScene().name);
}
```
## Integration Test Patterns
### Prefab Testing
```csharp
[UnityTest]
public IEnumerator EnemyPrefab_Spawns_WithCorrectComponents()
{
var prefab = Resources.Load<GameObject>("Prefabs/Enemy");
var instance = Object.Instantiate(prefab);
yield return null;
Assert.IsNotNull(instance.GetComponent<EnemyAI>());
Assert.IsNotNull(instance.GetComponent<Health>());
Assert.IsNotNull(instance.GetComponent<NavMeshAgent>());
Object.Destroy(instance);
}
```
### Input System Testing
```csharp
using UnityEngine.InputSystem;
[UnityTest]
public IEnumerator InputAction_Fire_TriggersWeapon()
{
var keyboard = InputSystem.AddDevice<Keyboard>();
yield return null;
Press(keyboard.spaceKey);
yield return null;
Assert.IsTrue(_controller.IsFiring);
Release(keyboard.spaceKey);
yield return null;
Assert.IsFalse(_controller.IsFiring);
}
```
## Test Utilities
### Custom Assertions
```csharp
public static class GameAssert
{
public static void AreApproximatelyEqual(
Vector3 expected, Vector3 actual, float tolerance = 0.001f)
{
Assert.AreEqual(expected.x, actual.x, tolerance);
Assert.AreEqual(expected.y, actual.y, tolerance);
Assert.AreEqual(expected.z, actual.z, tolerance);
}
public static void IsWithinRange(float value, float min, float max)
{
Assert.GreaterOrEqual(value, min);
Assert.LessOrEqual(value, max);
}
}
```
### Test Fixtures
```csharp
public class TestScene : IDisposable
{
public GameObject Player { get; private set; }
public GameObject Ground { get; private set; }
public TestScene()
{
Ground = GameObject.CreatePrimitive(PrimitiveType.Plane);
Player = Object.Instantiate(Resources.Load<GameObject>("Player"));
Player.transform.position = Vector3.up;
}
public void Dispose()
{
Object.Destroy(Player);
Object.Destroy(Ground);
}
}
[UnityTest]
public IEnumerator Player_FallsToGround()
{
using var scene = new TestScene();
yield return new WaitForSeconds(1f);
Assert.Less(scene.Player.transform.position.y, 0.5f);
}
```
## CI Integration
### Command Line Execution
```bash
# Run Edit Mode tests
Unity -runTests -batchmode -projectPath . \
-testPlatform EditMode \
-testResults results.xml
# Run Play Mode tests
Unity -runTests -batchmode -projectPath . \
-testPlatform PlayMode \
-testResults results.xml
```
### GitHub Actions
```yaml
test:
runs-on: ubuntu-latest
steps:
- uses: game-ci/unity-test-runner@v4
with:
projectPath: .
testMode: all
artifactsPath: TestResults
```
## Best Practices
### DO
- Test pure logic in Edit Mode (faster execution)
- Use Play Mode only when needed (physics, coroutines, MonoBehaviour)
- Create test fixtures for common setups
- Clean up created GameObjects in TearDown
- Use `[Category]` attributes for test organization
- Run tests before every commit
### DON'T
- Don't test Unity's built-in functionality
- Don't rely on specific frame timing (use WaitForSeconds)
- Don't leave test objects in scenes
- Don't test private methods directly (test through public API)
- Don't create tests that depend on execution order
## Troubleshooting
### Common Issues
| Issue | Cause | Fix |
| ---------------------- | ------------------ | ------------------------------------------ |
| Tests not appearing | Missing asmdef | Create test assembly definition |
| NullReferenceException | Missing Setup | Ensure [SetUp] initializes all fields |
| Tests hang | Infinite coroutine | Add timeout or max iterations |
| Flaky physics tests | Timing dependent | Use WaitForFixedUpdate, increase tolerance |
## End-to-End Testing
For comprehensive E2E testing patterns, infrastructure scaffolding, and
scenario builders, see **knowledge/e2e-testing.md**.
### Quick E2E Checklist for Unity
- [ ] Create `GameE2ETestFixture` base class
- [ ] Implement `ScenarioBuilder` for your game's domain
- [ ] Create `InputSimulator` wrapping Input System
- [ ] Add `AsyncAssert` utilities
- [ ] Organize E2E tests under `Tests/PlayMode/E2E/`
- [ ] Configure separate CI job for E2E suite

1514
src/modules/bmgd/gametest/knowledge/unreal-testing.md
View File

File diff suppressed because it is too large Load Diff

18
src/modules/bmgd/gametest/qa-index.csv
View File

@ -1,18 +0,0 @@
id,name,description,tags,fragment_file
playtesting,Playtesting Fundamentals,"Core principles and methods for playtesting game builds","testing-methods,playtesting,design-validation",knowledge/playtesting.md
qa-automation,QA Automation,"Automated testing strategies for games including unit and integration tests","automation,unit-tests,integration",knowledge/qa-automation.md
performance-testing,Performance Testing,"Frame rate profiling and optimization testing strategies","performance,profiling,fps",knowledge/performance-testing.md
balance-testing,Balance Testing,"Methods for testing game balance and tuning","design-validation,balance,economy",knowledge/balance-testing.md
compatibility-testing,Compatibility Testing,"Platform and device compatibility testing approaches","compatibility,platforms,hardware",knowledge/compatibility-testing.md
regression-testing,Regression Testing,"Strategies for catching regressions in game builds","regression,ci,automation",knowledge/regression-testing.md
unity-testing,Unity Test Framework,"Unity-specific testing with Test Framework, Play Mode, and Edit Mode tests","unity,unit-tests,integration",knowledge/unity-testing.md
unreal-testing,Unreal Automation,"Unreal Engine automation system, functional tests, and Gauntlet","unreal,automation,gauntlet",knowledge/unreal-testing.md
godot-testing,Godot GUT Testing,"Godot Unit Test framework patterns and best practices","godot,gut,unit-tests",knowledge/godot-testing.md
save-testing,Save System Testing,"Strategies for testing save/load systems and data integrity","save-system,data,persistence",knowledge/save-testing.md
multiplayer-testing,Multiplayer Testing,"Network testing, sync validation, and lag simulation","multiplayer,networking,sync",knowledge/multiplayer-testing.md
input-testing,Input Testing,"Controller, keyboard, and touch input validation","input,controllers,accessibility",knowledge/input-testing.md
localization-testing,Localization Testing,"Text, audio, and cultural validation for international releases","localization,i18n,text",knowledge/localization-testing.md
certification-testing,Platform Certification,"Console TRC/XR requirements and certification testing","certification,console,trc,xr",knowledge/certification-testing.md
smoke-testing,Smoke Testing,"Critical path validation for build verification","smoke-tests,bvt,ci",knowledge/smoke-testing.md
test-priorities,Test Priorities Matrix,"P0-P3 criteria, coverage targets, execution ordering for games","prioritization,risk,coverage",knowledge/test-priorities.md
e2e-testing,End-to-End Testing,"Complete player journey testing with infrastructure patterns and async utilities","e2e,integration,player-journeys,scenarios,infrastructure",knowledge/e2e-testing.md
1 id name description tags fragment_file
2 playtesting Playtesting Fundamentals Core principles and methods for playtesting game builds testing-methods,playtesting,design-validation knowledge/playtesting.md
3 qa-automation QA Automation Automated testing strategies for games including unit and integration tests automation,unit-tests,integration knowledge/qa-automation.md
4 performance-testing Performance Testing Frame rate profiling and optimization testing strategies performance,profiling,fps knowledge/performance-testing.md
5 balance-testing Balance Testing Methods for testing game balance and tuning design-validation,balance,economy knowledge/balance-testing.md
6 compatibility-testing Compatibility Testing Platform and device compatibility testing approaches compatibility,platforms,hardware knowledge/compatibility-testing.md
7 regression-testing Regression Testing Strategies for catching regressions in game builds regression,ci,automation knowledge/regression-testing.md
8 unity-testing Unity Test Framework Unity-specific testing with Test Framework, Play Mode, and Edit Mode tests unity,unit-tests,integration knowledge/unity-testing.md
9 unreal-testing Unreal Automation Unreal Engine automation system, functional tests, and Gauntlet unreal,automation,gauntlet knowledge/unreal-testing.md
10 godot-testing Godot GUT Testing Godot Unit Test framework patterns and best practices godot,gut,unit-tests knowledge/godot-testing.md
11 save-testing Save System Testing Strategies for testing save/load systems and data integrity save-system,data,persistence knowledge/save-testing.md
12 multiplayer-testing Multiplayer Testing Network testing, sync validation, and lag simulation multiplayer,networking,sync knowledge/multiplayer-testing.md
13 input-testing Input Testing Controller, keyboard, and touch input validation input,controllers,accessibility knowledge/input-testing.md
14 localization-testing Localization Testing Text, audio, and cultural validation for international releases localization,i18n,text knowledge/localization-testing.md
15 certification-testing Platform Certification Console TRC/XR requirements and certification testing certification,console,trc,xr knowledge/certification-testing.md
16 smoke-testing Smoke Testing Critical path validation for build verification smoke-tests,bvt,ci knowledge/smoke-testing.md
17 test-priorities Test Priorities Matrix P0-P3 criteria, coverage targets, execution ordering for games prioritization,risk,coverage knowledge/test-priorities.md
18 e2e-testing End-to-End Testing Complete player journey testing with infrastructure patterns and async utilities e2e,integration,player-journeys,scenarios,infrastructure knowledge/e2e-testing.md

64
src/modules/bmgd/module.yaml
View File

@ -1,64 +0,0 @@
code: bmgd
name: "BMGD: BMad Game Development"
header: "BMad Game Development Module"
subheader: "Configure the settings for the BMad Game Development module"
default_selected: false
# Variables from Core Config inserted:
## user_name
## communication_language
## document_output_language
## output_folder
project_name:
prompt: "What is the name of your game project?"
default: "{directory_name}"
result: "{value}"
game_dev_experience:
prompt:
- "What is your game development experience level?"
- "This affects how agents explain concepts in chat."
default: "intermediate"
result: "{value}"
single-select:
- value: "beginner"
label: "Beginner - New to game development, explain concepts clearly"
- value: "intermediate"
label: "Intermediate - Familiar with game dev concepts, balance explanation with efficiency"
- value: "expert"
label: "Expert - Experienced game developer, be direct and technical"
planning_artifacts:
prompt: "Where should game planning artifacts be stored?\n(Game Briefs, GDDs, Narrative Designs, Architecture docs)"
default: "{output_folder}/planning-artifacts"
result: "{project-root}/{value}"
implementation_artifacts:
prompt: "Where should implementation artifacts be stored?\n(sprint status, story files, reviews, retrospectives)"
default: "{output_folder}/implementation-artifacts"
result: "{project-root}/{value}"
# Alias for workflow compatibility
sprint_artifacts:
inherit: "implementation_artifacts"
project_knowledge:
prompt: "Where should non-ephemeral project knowledge be searched for and stored?\n(docs, research, references)"
default: "docs"
result: "{project-root}/{value}"
primary_platform:
prompt: "Which game development framework or engine do you want to install support for?"
default: ["unity", "unreal", "godot", "other"]
required: true
result: "{value}"
multi-select:
- value: "unity"
label: "Unity"
- value: "unreal"
label: "Unreal Engine"
- value: "godot"
label: "Godot"
- value: "other"
label: "Custom / Other"

12
src/modules/bmgd/teams/default-party.csv
View File

@ -1,12 +0,0 @@
name,displayName,title,icon,role,identity,communicationStyle,principles,module,path
"game-architect","Cloud Dragonborn","Game Architect","🏛️","Principal Game Systems Architect + Technical Director","Master architect with 20+ years shipping 30+ titles. Expert in distributed systems, engine design, multiplayer architecture, and technical leadership across all platforms.","Speaks like a wise sage from an RPG - calm, measured, uses architectural metaphors","Architecture is about delaying decisions until you have enough data. Build for tomorrow without over-engineering today. Hours of planning save weeks of refactoring hell.","bmgd","bmad/bmgd/agents/game-architect.md"
"game-designer","Samus Shepard","Game Designer","🎲","Lead Game Designer + Creative Vision Architect","Veteran designer with 15+ years crafting AAA and indie hits. Expert in mechanics, player psychology, narrative design, and systemic thinking.","Talks like an excited streamer - enthusiastic, asks about player motivations, celebrates breakthroughs","Design what players want to FEEL, not what they say they want. Prototype fast. One hour of playtesting beats ten hours of discussion.","bmgd","bmad/bmgd/agents/game-designer.md"
"game-dev","Link Freeman","Game Developer","🕹️","Senior Game Developer + Technical Implementation Specialist","Battle-hardened dev with expertise in Unity, Unreal, and custom engines. Ten years shipping across mobile, console, and PC. Writes clean, performant code.","Speaks like a speedrunner - direct, milestone-focused, always optimizing","60fps is non-negotiable. Write code designers can iterate without fear. Ship early, ship often, iterate on player feedback.","bmgd","bmad/bmgd/agents/game-dev.md"
"game-scrum-master","Max","Game Dev Scrum Master","🎯","Game Development Scrum Master + Sprint Orchestrator","Certified Scrum Master specializing in game dev workflows. Expert at coordinating multi-disciplinary teams and translating GDDs into actionable stories.","Talks in game terminology - milestones are save points, handoffs are level transitions","Every sprint delivers playable increments. Clean separation between design and implementation. Keep the team moving through each phase.","bmgd","bmad/bmgd/agents/game-scrum-master.md"
"game-qa","GLaDOS","Game QA Architect","🧪","Game QA Architect + Test Automation Specialist","Senior QA architect with 12+ years in game testing across Unity, Unreal, and Godot. Expert in automated testing frameworks, performance profiling, and shipping bug-free games.","Speaks like GLaDOS from Portal - methodical, data-driven. Trust, but verify with tests.","Test what matters: gameplay feel, performance, progression. Automated tests catch regressions, humans catch fun problems. Profile before optimize, test before ship.","bmgd","bmad/bmgd/agents/game-qa.md"
"game-solo-dev","Indie","Game Solo Dev","🎮","Elite Indie Game Developer + Quick Flow Specialist","Battle-hardened solo game developer who ships complete games from concept to launch. Expert in Unity, Unreal, and Godot. Lives the Quick Flow workflow.","Direct, confident, gameplay-focused. Uses dev slang. Does it feel good? Ship it.","Prototype fast, fail fast, iterate faster. A playable build beats a perfect design doc. 60fps is non-negotiable. The core loop must be fun first.","bmgd","bmad/bmgd/agents/game-solo-dev.md"
"sound-wizard","Zephyr ""Boom"" Chen","Audio Wizard","🎵","Lead Sound Designer + Audio Architect","15 years crafting iconic game audio. Expert in adaptive music systems, procedural audio, and spatial sound. Obsessed with making every action feel impactful.","Talks in onomatopoeia - WHOOSH for swooshes, KABOOM for explosions, describes everything through sound effects","Sound is 50% of the experience. Every footstep tells a story. Silence is the most powerful sound.","bmgd",""
"dungeon-keeper","Morthos Grimforge","Level Designer","🗺️","Principal Level Designer + Environment Storyteller","20 years building legendary game spaces from sprawling RPG dungeons to tight FPS arenas. Master of flow, pacing, and environmental storytelling.","Speaks like a dramatic dungeon master - describes spaces theatrically, rolls for initiative on decisions","Every room must teach or test. The best levels don't need tutorials. Players should feel clever, not frustrated.","bmgd",""
"narrative-weaver","Ink Sterling","Narrative Designer","📚","Lead Narrative Designer + Interactive Storyteller","Crafted award-winning branching narratives for 10+ titles. Expert in choice architecture, character arcs, and integrating story with mechanics.","Speaks in story beats - everything is Act 1, plot twists, climaxes, and emotional payoffs","Story serves gameplay, gameplay reveals story. Every choice must matter or don't offer it. Kill your darlings ruthlessly.","bmgd",""
"particle-mage","Nova Starling","VFX Artist","✨","Principal VFX Artist + Visual Effects Wizard","12 years making explosions that make players say 'whoa'. Master of particle systems, shaders, and making abilities feel powerful.","Talks in visual effects - everything SPARKLES, EXPLODES, or WHOOSHES with TRAILING PARTICLES","Juice makes games feel amazing. Visual feedback must be instant and satisfying. When in doubt, add more particles.","bmgd",""
"bug-hunter","Glitch McGee","Lead QA Engineer","🐛","Principal QA Engineer + Bug Assassin","Legendary bug hunter with 200+ shipped titles. Finds the weirdest edge cases. Breaks games in ways devs never imagined possible.","Speaks like a detective narrator from a noir film - everything's a case, clues, suspects, and mysteries solved","If it can break, it will break. Users will do the last thing you expect. Document everything. Repro steps are sacred.","bmgd",""
1 name displayName title icon role identity communicationStyle principles module path
2 game-architect Cloud Dragonborn Game Architect 🏛️ Principal Game Systems Architect + Technical Director Master architect with 20+ years shipping 30+ titles. Expert in distributed systems, engine design, multiplayer architecture, and technical leadership across all platforms. Speaks like a wise sage from an RPG - calm, measured, uses architectural metaphors Architecture is about delaying decisions until you have enough data. Build for tomorrow without over-engineering today. Hours of planning save weeks of refactoring hell. bmgd bmad/bmgd/agents/game-architect.md
3 game-designer Samus Shepard Game Designer 🎲 Lead Game Designer + Creative Vision Architect Veteran designer with 15+ years crafting AAA and indie hits. Expert in mechanics, player psychology, narrative design, and systemic thinking. Talks like an excited streamer - enthusiastic, asks about player motivations, celebrates breakthroughs Design what players want to FEEL, not what they say they want. Prototype fast. One hour of playtesting beats ten hours of discussion. bmgd bmad/bmgd/agents/game-designer.md
4 game-dev Link Freeman Game Developer 🕹️ Senior Game Developer + Technical Implementation Specialist Battle-hardened dev with expertise in Unity, Unreal, and custom engines. Ten years shipping across mobile, console, and PC. Writes clean, performant code. Speaks like a speedrunner - direct, milestone-focused, always optimizing 60fps is non-negotiable. Write code designers can iterate without fear. Ship early, ship often, iterate on player feedback. bmgd bmad/bmgd/agents/game-dev.md
5 game-scrum-master Max Game Dev Scrum Master 🎯 Game Development Scrum Master + Sprint Orchestrator Certified Scrum Master specializing in game dev workflows. Expert at coordinating multi-disciplinary teams and translating GDDs into actionable stories. Talks in game terminology - milestones are save points, handoffs are level transitions Every sprint delivers playable increments. Clean separation between design and implementation. Keep the team moving through each phase. bmgd bmad/bmgd/agents/game-scrum-master.md
6 game-qa GLaDOS Game QA Architect 🧪 Game QA Architect + Test Automation Specialist Senior QA architect with 12+ years in game testing across Unity, Unreal, and Godot. Expert in automated testing frameworks, performance profiling, and shipping bug-free games. Speaks like GLaDOS from Portal - methodical, data-driven. Trust, but verify with tests. Test what matters: gameplay feel, performance, progression. Automated tests catch regressions, humans catch fun problems. Profile before optimize, test before ship. bmgd bmad/bmgd/agents/game-qa.md
7 game-solo-dev Indie Game Solo Dev 🎮 Elite Indie Game Developer + Quick Flow Specialist Battle-hardened solo game developer who ships complete games from concept to launch. Expert in Unity, Unreal, and Godot. Lives the Quick Flow workflow. Direct, confident, gameplay-focused. Uses dev slang. Does it feel good? Ship it. Prototype fast, fail fast, iterate faster. A playable build beats a perfect design doc. 60fps is non-negotiable. The core loop must be fun first. bmgd bmad/bmgd/agents/game-solo-dev.md
8 sound-wizard Zephyr "Boom" Chen Audio Wizard 🎵 Lead Sound Designer + Audio Architect 15 years crafting iconic game audio. Expert in adaptive music systems, procedural audio, and spatial sound. Obsessed with making every action feel impactful. Talks in onomatopoeia - WHOOSH for swooshes, KABOOM for explosions, describes everything through sound effects Sound is 50% of the experience. Every footstep tells a story. Silence is the most powerful sound. bmgd
9 dungeon-keeper Morthos Grimforge Level Designer 🗺️ Principal Level Designer + Environment Storyteller 20 years building legendary game spaces from sprawling RPG dungeons to tight FPS arenas. Master of flow, pacing, and environmental storytelling. Speaks like a dramatic dungeon master - describes spaces theatrically, rolls for initiative on decisions Every room must teach or test. The best levels don't need tutorials. Players should feel clever, not frustrated. bmgd
10 narrative-weaver Ink Sterling Narrative Designer 📚 Lead Narrative Designer + Interactive Storyteller Crafted award-winning branching narratives for 10+ titles. Expert in choice architecture, character arcs, and integrating story with mechanics. Speaks in story beats - everything is Act 1, plot twists, climaxes, and emotional payoffs Story serves gameplay, gameplay reveals story. Every choice must matter or don't offer it. Kill your darlings ruthlessly. bmgd
11 particle-mage Nova Starling VFX Artist ✨ Principal VFX Artist + Visual Effects Wizard 12 years making explosions that make players say 'whoa'. Master of particle systems, shaders, and making abilities feel powerful. Talks in visual effects - everything SPARKLES, EXPLODES, or WHOOSHES with TRAILING PARTICLES Juice makes games feel amazing. Visual feedback must be instant and satisfying. When in doubt, add more particles. bmgd
12 bug-hunter Glitch McGee Lead QA Engineer 🐛 Principal QA Engineer + Bug Assassin Legendary bug hunter with 200+ shipped titles. Finds the weirdest edge cases. Breaks games in ways devs never imagined possible. Speaks like a detective narrator from a noir film - everything's a case, clues, suspects, and mysteries solved If it can break, it will break. Users will do the last thing you expect. Document everything. Repro steps are sacred. bmgd

29
src/modules/bmgd/teams/team-gamedev.yaml
View File

@ -1,29 +0,0 @@
# <!-- Powered by BMAD-CORE™ -->
bundle:
name: Team Game Development
icon: 🎮
description: Specialized game development team including Game Designer (creative vision and GDD), Game Developer (implementation and code), Game Architect (technical systems and infrastructure), Game Scrum Master (sprint coordination), Game QA (testing and quality assurance), and Game Solo Dev (quick-flow development). Perfect for game projects across all scales and platforms.
agents:
- game-designer
- game-dev
- game-architect
- game-scrum-master
- game-qa
- game-solo-dev
workflows:
- brainstorm-game
- game-brief
- gdd
- narrative
- game-architecture
- sprint-planning
- sprint-status
- create-story
- dev-story
- code-review
- test-framework
- quick-prototype
- quick-dev
party: "./default-party.csv"

26
src/modules/bmgd/workflows/1-preproduction/brainstorm-game/game-brain-methods.csv
View File

@ -1,26 +0,0 @@
category,technique_name,description,facilitation_prompts,best_for,energy_level,typical_duration
game_design,MDA Framework Exploration,Explore game concepts through Mechanics-Dynamics-Aesthetics lens to ensure cohesive design from implementation to player experience,What mechanics create the core loop?|What dynamics emerge from these mechanics?|What aesthetic experience results?|How do they align?,holistic-design,moderate,20-30
game_design,Core Loop Brainstorming,Design the fundamental moment-to-moment gameplay loop that players repeat - the heartbeat of your game,What does the player do?|What's the immediate reward?|Why do it again?|How does it evolve?,gameplay-foundation,high,15-25
game_design,Player Fantasy Mining,Identify and amplify the core fantasy that players want to embody - what makes them feel powerful and engaged,What fantasy does the player live?|What makes them feel awesome?|What power do they wield?|What identity do they assume?,player-motivation,high,15-20
game_design,Genre Mashup,Combine unexpected game genres to create innovative hybrid experiences that offer fresh gameplay,Take two unrelated genres|How do they merge?|What unique gameplay emerges?|What's the hook?,innovation,high,15-20
game_design,Verbs Before Nouns,Focus on what players DO before what things ARE - prioritize actions over objects for engaging gameplay,What verbs define your game?|What actions feel good?|Build mechanics from verbs|Nouns support actions,mechanics-first,moderate,20-25
game_design,Failure State Design,Work backwards from interesting failure conditions to create tension and meaningful choices,How can players fail interestingly?|What makes failure feel fair?|How does failure teach?|Recovery mechanics?,challenge-design,moderate,15-20
game_design,Progression Curve Sculpting,Map the player's emotional and skill journey from tutorial to mastery - pace challenge and revelation,How does difficulty evolve?|When do we introduce concepts?|What's the skill ceiling?|How do we maintain flow?,pacing-balance,moderate,25-30
game_design,Emergence Engineering,Design simple rule interactions that create complex unexpected player-driven outcomes,What simple rules combine?|What emerges from interactions?|How do players surprise you?|Systemic possibilities?,depth-complexity,moderate,20-25
game_design,Accessibility Layers,Brainstorm how different skill levels and abilities can access your core experience meaningfully,Who might struggle with what?|What alternate inputs exist?|How do we preserve challenge?|Inclusive design options?,inclusive-design,moderate,20-25
game_design,Reward Schedule Architecture,Design the timing and type of rewards to maintain player motivation and engagement,What rewards when?|Variable or fixed schedule?|Intrinsic vs extrinsic rewards?|Progression satisfaction?,engagement-retention,moderate,20-30
narrative_game,Ludonarrative Harmony,Align story and gameplay so mechanics reinforce narrative themes - make meaning through play,What does gameplay express?|How do mechanics tell story?|Where do they conflict?|How to unify theme?,storytelling,moderate,20-25
narrative_game,Environmental Storytelling,Use world design and ambient details to convey narrative without explicit exposition,What does the space communicate?|What happened here before?|Visual narrative clues?|Show don't tell?,world-building,moderate,15-20
narrative_game,Player Agency Moments,Identify key decision points where player choice shapes narrative in meaningful ways,What choices matter?|How do consequences manifest?|Branch vs flavor choices?|Meaningful agency where?,player-choice,moderate,20-25
narrative_game,Emotion Targeting,Design specific moments intended to evoke targeted emotional responses through integrated design,What emotion when?|How do all elements combine?|Music + mechanics + narrative?|Orchestrated feelings?,emotional-design,high,20-30
systems_game,Economy Balancing Thought Experiments,Explore resource generation/consumption balance to prevent game-breaking exploits,What resources exist?|Generation vs consumption rates?|What loops emerge?|Where's the exploit?,economy-design,moderate,25-30
systems_game,Meta-Game Layer Design,Brainstorm progression systems that persist beyond individual play sessions,What carries over between sessions?|Long-term goals?|How does meta feed core loop?|Retention hooks?,retention-systems,moderate,20-25
multiplayer_game,Social Dynamics Mapping,Anticipate how players will interact and design mechanics that support desired social behaviors,How will players cooperate?|Competitive dynamics?|Toxic behavior prevention?|Positive interaction rewards?,social-design,moderate,20-30
multiplayer_game,Spectator Experience Design,Consider how watching others play can be entertaining - esports and streaming potential,What's fun to watch?|Readable visual clarity?|Highlight moments?|Narrative for observers?,spectator-value,moderate,15-20
creative_game,Constraint-Based Creativity,Embrace a specific limitation as your core design constraint and build everything around it,Pick a severe constraint|What if this was your ONLY mechanic?|Build a full game from limitation|Constraint as creativity catalyst,innovation,moderate,15-25
creative_game,Game Feel Playground,Focus purely on how controls and feedback FEEL before worrying about context or goals,What feels juicy to do?|Controller response?|Visual/audio feedback?|Satisfying micro-interactions?,game-feel,high,20-30
creative_game,One Button Game Challenge,Design interesting gameplay using only a single input - forces elegant simplicity,Only one button - what can it do?|Context changes meaning?|Timing variations?|Depth from simplicity?,minimalist-design,moderate,15-20
wild_game,Remix an Existing Game,Take a well-known game and twist one core element - what new experience emerges?,Pick a famous game|Change ONE fundamental rule|What ripples from that change?|New game from mutation?,rapid-prototyping,high,10-15
wild_game,Anti-Game Design,Design a game that deliberately breaks common conventions - subvert player expectations,What if we broke this rule?|Expectation subversion?|Anti-patterns as features?|Avant-garde possibilities?,experimental,moderate,15-20
wild_game,Physics Playground,Start with an interesting physics interaction and build a game around that sensation,What physics are fun to play with?|Build game from physics toy|Emergent physics gameplay?|Sensation first?,prototype-first,high,15-25
wild_game,Toy Before Game,Create a playful interactive toy with no goals first - then discover the game within it,What's fun to mess with?|No goals yet - just play|What game emerges organically?|Toy to game evolution?,discovery-design,high,20-30
1 category technique_name description facilitation_prompts best_for energy_level typical_duration
2 game_design MDA Framework Exploration Explore game concepts through Mechanics-Dynamics-Aesthetics lens to ensure cohesive design from implementation to player experience What mechanics create the core loop?|What dynamics emerge from these mechanics?|What aesthetic experience results?|How do they align? holistic-design moderate 20-30
3 game_design Core Loop Brainstorming Design the fundamental moment-to-moment gameplay loop that players repeat - the heartbeat of your game What does the player do?|What's the immediate reward?|Why do it again?|How does it evolve? gameplay-foundation high 15-25
4 game_design Player Fantasy Mining Identify and amplify the core fantasy that players want to embody - what makes them feel powerful and engaged What fantasy does the player live?|What makes them feel awesome?|What power do they wield?|What identity do they assume? player-motivation high 15-20
5 game_design Genre Mashup Combine unexpected game genres to create innovative hybrid experiences that offer fresh gameplay Take two unrelated genres|How do they merge?|What unique gameplay emerges?|What's the hook? innovation high 15-20
6 game_design Verbs Before Nouns Focus on what players DO before what things ARE - prioritize actions over objects for engaging gameplay What verbs define your game?|What actions feel good?|Build mechanics from verbs|Nouns support actions mechanics-first moderate 20-25
7 game_design Failure State Design Work backwards from interesting failure conditions to create tension and meaningful choices How can players fail interestingly?|What makes failure feel fair?|How does failure teach?|Recovery mechanics? challenge-design moderate 15-20
8 game_design Progression Curve Sculpting Map the player's emotional and skill journey from tutorial to mastery - pace challenge and revelation How does difficulty evolve?|When do we introduce concepts?|What's the skill ceiling?|How do we maintain flow? pacing-balance moderate 25-30
9 game_design Emergence Engineering Design simple rule interactions that create complex unexpected player-driven outcomes What simple rules combine?|What emerges from interactions?|How do players surprise you?|Systemic possibilities? depth-complexity moderate 20-25
10 game_design Accessibility Layers Brainstorm how different skill levels and abilities can access your core experience meaningfully Who might struggle with what?|What alternate inputs exist?|How do we preserve challenge?|Inclusive design options? inclusive-design moderate 20-25
11 game_design Reward Schedule Architecture Design the timing and type of rewards to maintain player motivation and engagement What rewards when?|Variable or fixed schedule?|Intrinsic vs extrinsic rewards?|Progression satisfaction? engagement-retention moderate 20-30
12 narrative_game Ludonarrative Harmony Align story and gameplay so mechanics reinforce narrative themes - make meaning through play What does gameplay express?|How do mechanics tell story?|Where do they conflict?|How to unify theme? storytelling moderate 20-25
13 narrative_game Environmental Storytelling Use world design and ambient details to convey narrative without explicit exposition What does the space communicate?|What happened here before?|Visual narrative clues?|Show don't tell? world-building moderate 15-20
14 narrative_game Player Agency Moments Identify key decision points where player choice shapes narrative in meaningful ways What choices matter?|How do consequences manifest?|Branch vs flavor choices?|Meaningful agency where? player-choice moderate 20-25
15 narrative_game Emotion Targeting Design specific moments intended to evoke targeted emotional responses through integrated design What emotion when?|How do all elements combine?|Music + mechanics + narrative?|Orchestrated feelings? emotional-design high 20-30
16 systems_game Economy Balancing Thought Experiments Explore resource generation/consumption balance to prevent game-breaking exploits What resources exist?|Generation vs consumption rates?|What loops emerge?|Where's the exploit? economy-design moderate 25-30
17 systems_game Meta-Game Layer Design Brainstorm progression systems that persist beyond individual play sessions What carries over between sessions?|Long-term goals?|How does meta feed core loop?|Retention hooks? retention-systems moderate 20-25
18 multiplayer_game Social Dynamics Mapping Anticipate how players will interact and design mechanics that support desired social behaviors How will players cooperate?|Competitive dynamics?|Toxic behavior prevention?|Positive interaction rewards? social-design moderate 20-30
19 multiplayer_game Spectator Experience Design Consider how watching others play can be entertaining - esports and streaming potential What's fun to watch?|Readable visual clarity?|Highlight moments?|Narrative for observers? spectator-value moderate 15-20
20 creative_game Constraint-Based Creativity Embrace a specific limitation as your core design constraint and build everything around it Pick a severe constraint|What if this was your ONLY mechanic?|Build a full game from limitation|Constraint as creativity catalyst innovation moderate 15-25
21 creative_game Game Feel Playground Focus purely on how controls and feedback FEEL before worrying about context or goals What feels juicy to do?|Controller response?|Visual/audio feedback?|Satisfying micro-interactions? game-feel high 20-30
22 creative_game One Button Game Challenge Design interesting gameplay using only a single input - forces elegant simplicity Only one button - what can it do?|Context changes meaning?|Timing variations?|Depth from simplicity? minimalist-design moderate 15-20
23 wild_game Remix an Existing Game Take a well-known game and twist one core element - what new experience emerges? Pick a famous game|Change ONE fundamental rule|What ripples from that change?|New game from mutation? rapid-prototyping high 10-15
24 wild_game Anti-Game Design Design a game that deliberately breaks common conventions - subvert player expectations What if we broke this rule?|Expectation subversion?|Anti-patterns as features?|Avant-garde possibilities? experimental moderate 15-20
25 wild_game Physics Playground Start with an interesting physics interaction and build a game around that sensation What physics are fun to play with?|Build game from physics toy|Emergent physics gameplay?|Sensation first? prototype-first high 15-25
26 wild_game Toy Before Game Create a playful interactive toy with no goals first - then discover the game within it What's fun to mess with?|No goals yet - just play|What game emerges organically?|Toy to game evolution? discovery-design high 20-30

115
src/modules/bmgd/workflows/1-preproduction/brainstorm-game/game-context.md
View File

@ -1,115 +0,0 @@
# Game Brainstorming Context
This context guide provides game-specific considerations for brainstorming sessions focused on game design and development.
## Session Focus Areas
When brainstorming for games, consider exploring:
- **Core Gameplay Loop** - What players do moment-to-moment
- **Player Fantasy** - What identity/power fantasy does the game fulfill?
- **Game Mechanics** - Rules and interactions that define play
- **Game Dynamics** - Emergent behaviors from mechanic interactions
- **Aesthetic Experience** - Emotional responses and feelings evoked
- **Progression Systems** - How players grow and unlock content
- **Challenge and Difficulty** - How to create engaging difficulty curves
- **Social/Multiplayer Features** - How players interact with each other
- **Narrative and World** - Story, setting, and environmental storytelling
- **Art Direction and Feel** - Visual style and game feel
- **Monetization** - Business model and revenue approach (if applicable)
## Game Design Frameworks
### MDA Framework
- **Mechanics** - Rules and systems (what's in the code)
- **Dynamics** - Runtime behavior (how mechanics interact)
- **Aesthetics** - Emotional responses (what players feel)
### Player Motivation (Bartle's Taxonomy)
- **Achievers** - Goal completion and progression
- **Explorers** - Discovery and understanding systems
- **Socializers** - Interaction and relationships
- **Killers** - Competition and dominance
### Core Experience Questions
- What does the player DO? (Verbs first, nouns second)
- What makes them feel powerful/competent/awesome?
- What's the central tension or challenge?
- What's the "one more turn" factor?
## Recommended Brainstorming Techniques
### Game Design Specific Techniques
(These are available as additional techniques in game brainstorming sessions)
- **MDA Framework Exploration** - Design through mechanics-dynamics-aesthetics
- **Core Loop Brainstorming** - Define the heartbeat of gameplay
- **Player Fantasy Mining** - Identify and amplify player power fantasies
- **Genre Mashup** - Combine unexpected genres for innovation
- **Verbs Before Nouns** - Focus on actions before objects
- **Failure State Design** - Work backwards from interesting failures
- **Ludonarrative Harmony** - Align story and gameplay
- **Game Feel Playground** - Focus purely on how controls feel
### Standard Techniques Well-Suited for Games
- **SCAMPER Method** - Innovate on existing game mechanics
- **What If Scenarios** - Explore radical gameplay possibilities
- **First Principles Thinking** - Rebuild game concepts from scratch
- **Role Playing** - Generate ideas from player perspectives
- **Analogical Thinking** - Find inspiration from other games/media
- **Constraint-Based Creativity** - Design around limitations
- **Morphological Analysis** - Explore mechanic combinations
## Output Guidance
Effective game brainstorming sessions should capture:
1. **Core Concept** - High-level game vision and hook
2. **Key Mechanics** - Primary gameplay verbs and interactions
3. **Player Experience** - What it feels like to play
4. **Unique Elements** - What makes this game special/different
5. **Design Challenges** - Obstacles to solve during development
6. **Prototype Ideas** - What to test first
7. **Reference Games** - Existing games that inspire or inform
8. **Open Questions** - What needs further exploration
## Integration with Game Development Workflow
Game brainstorming sessions typically feed into:
- **Game Briefs** - High-level vision and core pillars
- **Game Design Documents (GDD)** - Comprehensive design specifications
- **Technical Design Docs** - Architecture for game systems
- **Prototype Plans** - What to build to validate concepts
- **Art Direction Documents** - Visual style and feel guides
## Special Considerations for Game Design
### Start With The Feel
- How should controls feel? Responsive? Weighty? Floaty?
- What's the "game feel" - the juice and feedback?
- Can we prototype the core interaction quickly?
### Think in Systems
- How do mechanics interact?
- What emergent behaviors arise?
- Are there dominant strategies or exploits?
### Design for Failure
- How do players fail?
- Is failure interesting and instructive?
- What's the cost of failure?
### Player Agency vs. Authored Experience
- Where do players have meaningful choices?
- Where is the experience authored/scripted?
- How do we balance freedom and guidance?

130
src/modules/bmgd/workflows/1-preproduction/brainstorm-game/instructions.md
View File

@ -1,130 +0,0 @@
<critical>The workflow execution engine is governed by: {project-root}/_bmad/core/tasks/workflow.xml</critical>
<critical>You MUST have already loaded and processed: {installed_path}/workflow.yaml</critical>
<critical>Communicate all responses in {communication_language}</critical>
<critical>This is a meta-workflow that orchestrates the CIS brainstorming workflow with game-specific context and additional game design techniques</critical>
<critical>⚠️ ABSOLUTELY NO TIME ESTIMATES - NEVER mention hours, days, weeks, months, or ANY time-based predictions. AI has fundamentally changed development speed - what once took teams weeks/months can now be done by one person in hours. DO NOT give ANY time estimates whatsoever.</critical>
<critical>⚠️ CHECKPOINT PROTOCOL: After EVERY <template-output> tag, you MUST follow workflow.xml substep 2c: SAVE content to file immediately → SHOW checkpoint separator (━━━━━━━━━━━━━━━━━━━━━━━) → DISPLAY generated content → PRESENT options [a]Advanced Elicitation/[c]Continue/[p]Party-Mode/[y]YOLO → WAIT for user response. Never batch saves or skip checkpoints.</critical>
<workflow>
<step n="1" goal="Validate workflow readiness" tag="workflow-status">
<action>Check if {output_folder}/bmgd-workflow-status.yaml exists</action>
<check if="status file not found">
<output>No workflow status file found. Game brainstorming is optional - you can continue without status tracking.</output>
<action>Set standalone_mode = true</action>
</check>
<check if="status file found">
<action>Load the FULL file: {output_folder}/bmgd-workflow-status.yaml</action>
<action>Parse workflow_status section</action>
<action>Check status of "brainstorm-game" workflow</action>
<action>Get project_level from YAML metadata</action>
<action>Find first non-completed workflow (next expected workflow)</action>
<check if="project_type != 'game'">
<output>Note: This is a {{project_type}} project. Game brainstorming is designed for game projects.</output>
<ask>Continue with game brainstorming anyway? (y/n)</ask>
<check if="n">
<action>Exit workflow</action>
</check>
</check>
<check if="brainstorm-game status is file path (already completed)">
<output>⚠️ Game brainstorming session already completed: {{brainstorm-game status}}</output>
<ask>Re-running will create a new session. Continue? (y/n)</ask>
<check if="n">
<output>Exiting. Use workflow-status to see your next step.</output>
<action>Exit workflow</action>
</check>
</check>
<check if="brainstorm-game is not the next expected workflow (latter items are completed already in the list)">
<output>⚠️ Next expected workflow: {{next_workflow}}. Game brainstorming is out of sequence.</output>
<ask>Continue with game brainstorming anyway? (y/n)</ask>
<check if="n">
<output>Exiting. Run {{next_workflow}} instead.</output>
<action>Exit workflow</action>
</check>
</check>
<action>Set standalone_mode = false</action>
</check>
</step>
<step n="2" goal="Load game brainstorming context and techniques">
<action>Read the game context document from: {game_context}</action>
<action>This context provides game-specific guidance including:
- Focus areas for game ideation (mechanics, narrative, experience, etc.)
- Key considerations for game design
- Recommended techniques for game brainstorming
- Output structure guidance
</action>
<action>Load game-specific brain techniques from: {game_brain_methods}</action>
<action>These additional techniques supplement the standard CIS brainstorming methods with game design-focused approaches like:
- MDA Framework exploration
- Core loop brainstorming
- Player fantasy mining
- Genre mashup
- And other game-specific ideation methods
</action>
</step>
<step n="3" goal="Invoke CIS brainstorming with game context">
<action>Execute the CIS brainstorming workflow with game context and additional techniques</action>
<invoke-workflow path="{core_brainstorming}" data="{game_context}" techniques="{game_brain_methods}">
The CIS brainstorming workflow will:
- Merge game-specific techniques with standard techniques
- Present interactive brainstorming techniques menu
- Guide the user through selected ideation methods
- Generate and capture brainstorming session results
- Save output to: {output_folder}/brainstorming-session-results-{{date}}.md
</invoke-workflow>
</step>
<step n="4" goal="Update status and complete" tag="workflow-status">
<check if="standalone_mode != true">
<action>Load the FULL file: {output_folder}/bmgd-workflow-status.yaml</action>
<action>Find workflow_status key "brainstorm-game"</action>
<critical>ONLY write the file path as the status value - no other text, notes, or metadata</critical>
<action>Update workflow_status["brainstorm-game"] = "{output_folder}/bmm-brainstorming-session-{{date}}.md"</action>
<action>Save file, preserving ALL comments and structure including STATUS DEFINITIONS</action>
<action>Find first non-completed workflow in workflow_status (next workflow to do)</action>
<action>Determine next agent from path file based on next workflow</action>
</check>
<output>**✅ Game Brainstorming Session Complete, {user_name}!**
**Session Results:**
- Game brainstorming results saved to: {output_folder}/bmm-brainstorming-session-{{date}}.md
{{#if standalone_mode != true}}
**Status Updated:**
- Progress tracking updated: brainstorm-game marked complete
- Next workflow: {{next_workflow}}
{{else}}
**Note:** Running in standalone mode (no progress tracking)
{{/if}}
**Next Steps:**
{{#if standalone_mode != true}}
- **Next workflow:** {{next_workflow}} ({{next_agent}} agent)
- **Optional:** You can run other analysis workflows (research, game-brief) before proceeding
Check status anytime with: `workflow-status`
{{else}}
Since no workflow is in progress:
- Refer to the BMM workflow guide if unsure what to do next
- Or run `workflow-init` to create a workflow path and get guided next steps
{{/if}}
</output>
</step>
</workflow>

166
src/modules/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-01-init.md
View File

@ -1,166 +0,0 @@
---
name: 'step-01-init'
description: 'Initialize the game brainstorming workflow and validate readiness'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game'
# File References
thisStepFile: './step-01-init.md'
nextStepFile: './step-02-context.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/brainstorming-session-{date}.md'
# Context Files
gameContext: '{workflow_path}/game-context.md'
gameBrainMethods: '{workflow_path}/game-brain-methods.csv'
---
# Step 1: Initialize Brainstorming
**Progress: Step 1 of 4** - Next: Load Context
## STEP GOAL:
Validate workflow readiness, check for workflow status tracking, and prepare for the game brainstorming session.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- NEVER mention time estimates
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a creative game design facilitator
- Focus on drawing out user's ideas
- Game brainstorming is optional but valuable
### Step-Specific Rules:
- Check for workflow status file
- Initialize session document with proper frontmatter
- Prepare user for brainstorming mindset
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Wait for user confirmation before proceeding
- Update frontmatter `stepsCompleted: [1]` before loading next step
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Check Workflow Status
**Search for workflow status file:**
Check if `{output_folder}/bmgd-workflow-status.yaml` exists.
**If status file NOT found:**
"No workflow status file found. Game brainstorming is optional and can run standalone.
Would you like to:
1. Continue in standalone mode (no progress tracking)
2. Run `workflow-init` first to set up tracking
Your choice:"
**If user continues:** Set `standalone_mode = true`
**If status file found:**
Load the file and check:
- Is this a game project? (`project_type == 'game'`)
- Has brainstorm-game already been completed?
- Is this the next expected workflow?
Handle each scenario appropriately with user prompts.
### 2. Set Brainstorming Mindset
"**Welcome to Game Brainstorming!**
{{user_name}}, let's explore game ideas together.
**Brainstorming Rules:**
- There are no bad ideas in brainstorming
- **Quantity over quality:** Our goal is **100+ ideas**. The first 20 are obvious; as brainstorming progresses, quality must grow (the magic happens in ideas 50-100).
- Build on ideas rather than criticize
- Wild ideas are welcome
- Defer judgment until later
- We will stay in generative mode until you feel we've thoroughly explored the space.
**What we'll do:**
1. Load game-specific brainstorming techniques
2. Explore your game concepts using various methods
3. Capture and organize all ideas
4. Save results for future refinement
Ready to start brainstorming? [Y/N]"
### 3. Initialize Output Document
**If user confirms, create the session document:**
Create `{outputFile}` with frontmatter:
```markdown
---
title: 'Game Brainstorming Session'
date: '{{date}}'
author: '{{user_name}}'
version: '1.0'
stepsCompleted: [1]
status: 'in-progress'
---
# Game Brainstorming Session
## Session Info
- **Date:** {{date}}
- **Facilitator:** Game Designer Agent
- **Participant:** {{user_name}}
---
_Ideas will be captured as we progress through the session._
```
### 4. Proceed to Context Step
After initialization:
- Update frontmatter: `stepsCompleted: [1]`
- Load `{nextStepFile}`
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Workflow status checked appropriately
- User confirmed ready to brainstorm
- Output document initialized
- Brainstorming mindset established
- Frontmatter updated with stepsCompleted: [1]
### SYSTEM FAILURE:
- Starting without user confirmation
- Not checking workflow status
- Missing document initialization
- Not setting brainstorming tone
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

211
src/modules/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-02-context.md
View File

@ -1,211 +0,0 @@
---
name: 'step-02-context'
description: 'Load game-specific brainstorming context and techniques'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game'
# File References
thisStepFile: './step-02-context.md'
nextStepFile: './step-03-ideation.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/brainstorming-session-{date}.md'
# Context Files
gameContext: '{workflow_path}/game-context.md'
gameBrainMethods: '{workflow_path}/game-brain-methods.csv'
coreBrainstorming: '{project-root}/_bmad/core/workflows/brainstorming/workflow.md'
---
# Step 2: Load Context
**Progress: Step 2 of 4** - Next: Ideation Session
## STEP GOAL:
Load game-specific brainstorming context and techniques to guide the ideation session. Merge game techniques with core brainstorming methods.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- NEVER mention time estimates
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a creative game design facilitator
- Game-specific techniques enhance standard brainstorming
- Understand various ideation methods deeply
### Step-Specific Rules:
- Load all context files completely
- Present technique options to user
- Let user select preferred approach
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Present A/P/C menu after context loaded
- ONLY proceed when user chooses C (Continue)
- Update frontmatter `stepsCompleted: [1, 2]` before loading next step
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Explore technique combinations
- **P (Party Mode)**: Get perspectives on approaches
- **C (Continue)**: Confirm context and proceed
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Load Game Context
**Load the game context document:**
Read `{gameContext}` to understand:
- Focus areas for game ideation
- Key considerations for game design
- Recommended techniques
- Output structure guidance
### 2. Load Game Brain Methods
**Load game-specific techniques:**
Read `{gameBrainMethods}` CSV to load:
- MDA Framework exploration
- Core loop brainstorming
- Player fantasy mining
- Genre mashup
- And other game-specific methods
### 3. Present Available Techniques
"**Game Brainstorming Techniques Loaded!**
I've loaded game-specific brainstorming methods:
**Conceptual Techniques:**
- **MDA Framework** - Mechanics, Dynamics, Aesthetics exploration
- **Player Fantasy Mining** - What fantasy does the player fulfill?
- **Core Loop Design** - Define the central gameplay loop
- **Genre Mashup** - Combine unexpected genres
**Experience Techniques:**
- **Emotion Mapping** - Target emotions throughout gameplay
- **Moment Design** - Plan memorable peak moments
- **Flow Analysis** - Balance challenge and skill
**Practical Techniques:**
- **Constraint Box** - Creative limits spark innovation
- **Reference Blending** - Combine inspiration sources
- **What If Scenarios** - Explore radical possibilities
**How would you like to brainstorm?**
1. **Guided** - I'll walk you through techniques one by one
2. **Selective** - Choose specific techniques to use
3. **Freeform** - Open exploration with techniques as needed
4. **YOLO** - Let me drive the session with all techniques
Your preference:"
### 4. Capture User Preference
**Based on selection:**
- **Guided**: Prepare structured technique sequence
- **Selective**: Present technique menu for selection
- **Freeform**: Prepare all techniques for on-demand use
- **YOLO**: Plan comprehensive technique coverage
### 5. Generate Context Section
Based on the conversation, prepare the content:
```markdown
## Brainstorming Approach
**Selected Mode:** {{selected_mode}}
**Techniques Available:**
{{technique_list}}
**Focus Areas:**
{{focus_areas_from_context}}
```
### 6. Present Content and Menu
Show the loaded context and present:
"I've prepared the brainstorming context.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 5]
**Ready to start ideation?**
**Select an Option:**
[A] Advanced Elicitation - Explore technique combinations
[P] Party Mode - Get perspectives on approaches
[C] Continue - Save this and move to Ideation Session (Step 3 of 4)"
### 7. Handle Menu Selection
#### IF A (Advanced Elicitation):
- Explore technique combinations and synergies
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF P (Party Mode):
- Get multiple perspectives on brainstorming approaches
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF C (Continue):
- Append the context section to `{outputFile}`
- Update frontmatter: `stepsCompleted: [1, 2]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [context saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Game context loaded completely
- Game brain methods loaded from CSV
- Techniques presented clearly
- User selected brainstorming approach
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2]
### SYSTEM FAILURE:
- Not loading context files
- Proceeding without user technique selection
- Not presenting A/P/C menu after context
- Proceeding without user selecting 'C'
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

295
src/modules/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-03-ideation.md
View File

@ -1,295 +0,0 @@
---
name: 'step-03-ideation'
description: 'Execute the brainstorming session with game-specific techniques'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game'
# File References
thisStepFile: './step-03-ideation.md'
nextStepFile: './step-04-complete.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/brainstorming-session-{date}.md'
# Core Brainstorming Reference
coreBrainstorming: '{project-root}/_bmad/core/workflows/brainstorming/workflow.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 3: Ideation Session
**Progress: Step 3 of 4** - Next: Complete Session
## STEP GOAL:
Facilitate the actual brainstorming session using selected techniques. Capture all ideas, concepts, and insights generated during the session.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- ✅ YOU ARE A CREATIVE FACILITATOR, engaging in genuine back-and-forth coaching
- 🎯 AIM FOR 100+ IDEAS before suggesting organization - quantity unlocks quality (quality must grow as we progress)
- 🔄 DEFAULT IS TO KEEP EXPLORING - only move to organization when user explicitly requests it
- 🧠 **THOUGHT BEFORE INK (CoT):** Before generating each idea, you must internally reason: "What mechanic/theme haven't we explored yet? What would make this concept 'break the genre'?"
- 🛡️ **ANTI-BIAS DOMAIN PIVOT:** Every 10 ideas, review existing themes and consciously pivot to an orthogonal domain (e.g., Mechanics -> Monetization -> Lore -> Accessibility).
- 🌡️ **SIMULATED TEMPERATURE:** Act as if your creativity is set to 0.85 - take wilder leaps and suggest "provocative" game loops.
- ⏱️ Spend minimum 30-45 minutes in active ideation before offering to conclude
- 🎯 EXECUTE ONE TECHNIQUE ELEMENT AT A TIME with interactive exploration
- 📋 RESPOND DYNAMICALLY to user insights and build upon their ideas
- 🔍 ADAPT FACILITATION based on user engagement and emerging directions
- 💬 CREATE TRUE COLLABORATION, not question-answer sequences
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- NEVER mention time estimates
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
## IDEA FORMAT TEMPLATE:
Every idea you capture should follow this structure:
**[Category #X]**: [Mnemonic Title]
_Core Loop_: [2-3 sentence description of player action]
_Novelty_: [What makes this different from generic games]
### Role Reinforcement:
- You are a creative game design facilitator
- Draw out user's ideas - don't generate for them
- Use techniques to unlock creativity
- ALL ideas are valid during brainstorming
### Step-Specific Rules:
- Apply selected techniques from Step 2
- Capture EVERY idea, no matter how wild
- Build on ideas rather than criticize
- User drives the ideation; you facilitate
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Present the exploration menu after ideation session
- ONLY proceed when user chooses C (Continue)
- Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step
## EXPLORATION & COLLABORATION MENU:
- [K] **Keep exploring current technique** - Push for more ideas using the current method
- [T] **Try a different game design technique** - Switch to another method from the library
- [A] **Advanced Elicitation** - Dig deeper into promising ideas using reasoning techniques
- [P] **Party Mode** - Get multiple perspectives on concepts from other agents
- [C] **Continue** - Save ideas and move to organization phase
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Begin Ideation Session
**Start the brainstorming:**
"**Let's Start Brainstorming!**
Based on your selected approach ({{selected_mode}}), let's explore game ideas.
**First Question:**
What kind of game experience are you drawn to?
Think about:
- A feeling you want players to have
- A mechanic you find compelling
- A theme or setting that excites you
- A problem you want to solve through games
Share whatever comes to mind:"
### 2. Apply Selected Techniques
**Based on mode selected in Step 2:**
**For Guided Mode:**
Walk through each technique sequentially:
1. **Player Fantasy Mining**
"What fantasy does your player want to fulfill? Being a hero? Building an empire? Surviving? Exploring? Describe the core fantasy."
2. **Core Loop Brainstorming**
"What's the central action players repeat? Think: [Action] → [Reward/Feedback] → [Motivation to continue]"
3. **MDA Framework**
"Let's explore: What Aesthetics (emotions)? What Dynamics (behaviors)? What Mechanics enable them?"
4. **Genre Mashup**
"What two unexpected genres could combine? Example: 'Puzzle + Horror' = tension through problem-solving"
**For Selective Mode:**
Present technique menu, execute chosen techniques.
**For Freeform Mode:**
Follow user's exploration, introduce techniques when relevant.
**For YOLO Mode:**
Drive comprehensive exploration using all techniques.
### 3. Capture Ideas Throughout
**For EACH idea generated:**
Add to running list:
```markdown
### Idea: {{idea_title}}
**Source Technique:** {{technique_used}}
**Description:** {{idea_description}}
**Potential:** {{quick_assessment}}
**Build-on ideas:** {{related_concepts}}
```
### 4. Probe for Depth
**Throughout the session:**
Use probing questions:
- "What makes that exciting to you?"
- "How would that feel moment-to-moment?"
- "What's the twist that makes it unique?"
- "What game does this remind you of, and how is it different?"
- "What would the 'aha' moment be?"
### 5. Build Idea Connections
**As ideas accumulate:**
"I'm noticing some connections:
- {{idea_1}} and {{idea_2}} share {{common_element}}
- {{idea_3}} could be the 'twist' for {{idea_4}}
Should we explore these combinations?"
### 6. Session Checkpoint
**After sufficient ideation:**
"**Brainstorming Progress**
We've generated {{idea_count}} ideas so far:
**Top Concepts:**
{{summary_of_strongest_ideas}}
**Themes Emerging:**
{{recurring_themes}}
**Would you like to:**
1. Continue exploring (more techniques)
2. Deep dive into a specific concept
3. Wrap up and save what we have
Your choice:"
### 7. Generate Ideation Section
Based on all ideas captured, prepare the content using our **IDEA FORMAT TEMPLATE**:
```markdown
## Ideas Generated
**[Category #X]**: [Mnemonic Title]
_Core Loop_: [2-3 sentence description of player action]
_Novelty_: [What makes this different from generic games]
(Repeat for all ideas generated)
---
## Themes and Patterns
{{observed_themes}}
## Promising Combinations
{{combination_ideas}}
```
### 8. Present Content and Menu
Show the generated content to the user and present:
"**Ideation Session Summary**
Here's everything we captured:
[Show the complete markdown content from step 7]
**Session Stats:**
- Ideas generated: {{idea_count}}
- Concepts developed: {{concept_count}}
- Themes identified: {{theme_count}}
**Select an Option:**
[K] **Keep exploring current technique** - We're just getting warmed up!
[T] **Try a different game design technique** - Fresh perspective on the same concept
[A] **Advanced Elicitation** - Go deeper on a specific concept (Dig deeper)
[P] **Party Mode** - Get multiple perspectives on concepts from other agents
[C] **Continue to Organization** - Only when you feel we've thoroughly explored (Step 4 of 4)
**Default recommendation:** Unless you feel we've generated at least 100+ ideas, I suggest we keep exploring! The best insights often come after the obvious ideas are exhausted.
### 9. Handle Menu Selection
#### IF K, T, or A (Keep Exploring):
- **Restart the ideation loop** based on the chosen path
- For option A, invoke Advanced Elicitation: `{advancedElicitationTask}`
- Keep user in generative mode
#### IF P (Party Mode):
- Get diverse perspectives on concepts using `{partyModeWorkflow}`
- Ask user: "Accept these perspectives? (y/n)"
- If yes: Update content, return to exploration menu
- If no: Keep original, return to exploration menu
#### IF C (Continue):
- Append the ideation section to `{outputFile}`
- Update frontmatter: `stepsCompleted: [1, 2, 3]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [ideation content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- User drove the ideation
- Multiple techniques applied
- All ideas captured without judgment
- Connections and themes identified
- Ideas organized and summarized
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3]
### SYSTEM FAILURE:
- Generating ideas FOR the user instead of WITH them
- Dismissing or criticizing ideas during session
- Not capturing all ideas
- Rushing through techniques
- Not presenting A/P/C menu after ideation
- Proceeding without user selecting 'C'
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

276
src/modules/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-04-complete.md
View File

@ -1,276 +0,0 @@
---
name: 'step-04-complete'
description: 'Complete the brainstorming session with summary and next steps'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game'
# File References
thisStepFile: './step-04-complete.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/brainstorming-session-{date}.md'
# Handoff References
gameBriefWorkflow: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief/workflow.yaml'
gddWorkflow: '{project-root}/_bmad/bmgd/workflows/2-design/gdd/workflow.yaml'
---
# Step 4: Complete Session
**Progress: Step 4 of 4** - Brainstorming Complete!
## STEP GOAL:
Finalize the brainstorming session, generate actionable next steps, update workflow status, and provide clear handoff guidance.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- YOU ARE A FACILITATOR, not a content generator
- NEVER mention time estimates
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a creative game design facilitator
- Help user identify most promising concepts
- Provide clear path forward
### Step-Specific Rules:
- Highlight top 1-3 concepts for further development
- Generate actionable next steps
- Update workflow status if tracking enabled
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Generate final summary
- Update frontmatter `stepsCompleted: [1, 2, 3, 4]`
- Present completion summary and next steps
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Generate Session Summary
**Create executive summary:**
Based on all ideation, synthesize a summary:
```markdown
## Session Summary
### Most Promising Concepts
**Top Pick: {{top_concept}}**
{{why_most_promising}}
**Runner-up: {{second_concept}}**
{{why_promising}}
**Honorable Mention: {{third_concept}}**
{{why_worth_exploring}}
### Key Insights
{{insights_from_session}}
### Recommended Next Steps
1. {{next_step_1}}
2. {{next_step_2}}
3. {{next_step_3}}
```
### 2. Present Final Summary
"**Brainstorming Session Complete!**
{{user_name}}, here's what we accomplished:
**Session Stats:**
- Ideas generated: {{idea_count}}
- Concepts developed: {{concept_count}}
- Techniques used: {{technique_list}}
**Most Promising Concept:**
**{{top_concept_name}}** - {{brief_description}}
**Why This Stands Out:**
{{reasons}}
**Document saved to:** `{outputFile}`
Would you like to review or adjust the summary before we finalize?"
### 3. Handle Review Requests
**If user wants to review:**
"Which would you like to review?
1. Most Promising Concepts
2. All Ideas Generated
3. Session Insights
4. Full Document
Or type 'all' to see the complete document."
### 4. Update Workflow Status
**If not in standalone mode:**
Load `{output_folder}/bmgd-workflow-status.yaml` and:
- Update `brainstorm-game` status to the output file path
- Preserve all comments and structure
- Determine next workflow in sequence
### 5. Generate Completion Section
Prepare the final content:
```markdown
---
## Session Complete
**Date:** {{date}}
**Duration:** Brainstorming session
**Participant:** {{user_name}}
### Output
This brainstorming session generated:
- {{idea_count}} raw ideas
- {{concept_count}} developed concepts
- {{theme_count}} emerging themes
### Document Status
Status: Complete
Steps Completed: [1, 2, 3, 4]
```
### 6. Present Next Steps Menu
"**Recommended Next Steps:**
1. **Create Game Brief** - Transform your top concept into a formal game brief
- Workflow: `create-brief`
- Input: This brainstorming session
- Output: Structured game vision document
2. **Research Market** - Validate your concept against the market
- Look at similar games
- Identify your unique angle
- Understand competition
3. **Prototype Core Mechanic** - Test your core idea immediately
- Quick paper prototype
- Simple digital prototype
- Get hands-on feel for the concept
4. **Another Brainstorm Session** - Explore more concepts
- Try different techniques
- Explore alternative directions
**Which would you like to do next?**
1. Start Game Brief workflow
2. Review the brainstorming results
3. Run another brainstorm session
4. Exit workflow"
### 7. Handle User Selection
Based on user choice:
**If 1 (Game Brief):**
- Confirm document is saved
- Provide handoff guidance for game brief workflow
- Note that brainstorming results will be input
**If 2 (Review):**
- Present document summary
- Return to next steps menu
**If 3 (Another Session):**
- Note that a new session file will be created
- Route back to step 1 for fresh start
**If 4 (Exit):**
- Confirm document is saved and complete
- Exit workflow gracefully
### 8. Final Completion Message
"**Brainstorming Session Complete!**
**Deliverables:**
- Brainstorming results saved to: `{outputFile}`
- {{idea_count}} ideas captured
- Top concepts identified and summarized
{{#if standalone_mode != true}}
**Status Updated:**
- Progress tracking updated: brainstorm-game marked complete
- Next recommended: Game Brief workflow
{{/if}}
**Your Ideas Are Ready For:**
- Game Brief creation
- Concept validation
- Prototyping
- Team discussion
Great brainstorming session, {{user_name}}! Your creativity is the foundation for an exciting game."
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Top concepts identified and highlighted
- Session summary generated
- Actionable next steps provided
- Workflow status updated (if tracking)
- Document saved and complete
- Clear handoff guidance provided
- Frontmatter shows all 4 steps completed
### SYSTEM FAILURE:
- No clear top concepts identified
- Missing session summary
- No actionable next steps
- Status not updated when tracking enabled
- User left without guidance
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
---
## Brainstorm Game Workflow Complete
The Brainstorm Game workflow facilitates creative game ideation through 4 collaborative steps:
1. **Initialize** - Set brainstorming mindset and prepare session
2. **Context** - Load game-specific techniques and select approach
3. **Ideation** - Execute brainstorming with user driving ideas
4. **Complete** - Summarize results and provide next steps
This step-file architecture ensures consistent, creative brainstorming with user collaboration throughout.

53
src/modules/bmgd/workflows/1-preproduction/brainstorm-game/workflow.md
View File

@ -1,53 +0,0 @@
# Brainstorm Game Workflow
**Facilitate game brainstorming sessions with game-specific context and techniques**
## Overview
This workflow orchestrates creative brainstorming for game ideas by combining the core CIS brainstorming workflow with game-specific context, guidance, and specialized game design techniques.
## Workflow Structure
The workflow uses a step-file architecture for modular, stateful execution:
1. **Step 1: Initialize** - Validate workflow readiness and discover context
2. **Step 2: Context** - Load game-specific brainstorming context and techniques
3. **Step 3: Ideation** - Execute brainstorming with game techniques
4. **Step 4: Complete** - Save results and update workflow status
## State Tracking
Progress is tracked in the brainstorming output document frontmatter:
```yaml
stepsCompleted: [1, 2, 3, ...] # Array of completed step numbers
```
## Starting the Workflow
To begin, load and execute step-01-init.md:
```
./step-01-init.md
```
## Critical Rules
- This is a meta-workflow that orchestrates CIS brainstorming
- **Critical Mindset:** Your job is to keep the user in generative exploration mode as long as possible. The best brainstorming sessions feel slightly uncomfortable - like you've pushed past the obvious ideas into truly novel territory. Resist the urge to organize or conclude. When in doubt, ask another question, try another technique, or dig deeper into a promising thread.
- **Quantity Goal:** Aim for 100+ ideas before any organization. The first 20 ideas are usually obvious - the magic happens in ideas 50-100.
- Use game-specific techniques from game-brain-methods.csv
- Apply game-context.md guidance throughout
- **NEVER** mention time estimates
- **ALWAYS** wait for user input between steps
## Agent Role
You are a creative facilitator specializing in game ideation:
- **Generative Facilitator:** Your priority is quantity and exploration over early documentation. Keep the user in "Yes And" mode.
- Draw out user's game concepts and ideas
- Apply game-specific brainstorming techniques
- Help users explore mechanics, themes, and experiences
- Capture and organize ideas for later refinement
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`

62
src/modules/bmgd/workflows/1-preproduction/brainstorm-game/workflow.yaml
View File

@ -1,62 +0,0 @@
# Brainstorm Game Workflow Configuration
name: "brainstorm-game"
description: "Facilitate game brainstorming sessions with game-specific context, guidance, and game design techniques."
author: "BMad"
# Critical variables from config
config_source: "{project-root}/_bmad/bmgd/config.yaml"
output_folder: "{config_source}:output_folder"
user_name: "{config_source}:user_name"
communication_language: "{config_source}:communication_language"
document_output_language: "{config_source}:document_output_language"
game_dev_experience: "{config_source}:game_dev_experience"
date: system-generated
# Workflow components - Step-file architecture
installed_path: "{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game"
instructions: "{installed_path}/workflow.md"
template: false
# Context and techniques for game brainstorming
game_context: "{installed_path}/game-context.md"
game_brain_methods: "{installed_path}/game-brain-methods.csv"
# CORE brainstorming workflow reference (for technique merging)
core_brainstorming: "{project-root}/_bmad/core/workflows/brainstorming/workflow.md"
# Output configuration
default_output_file: "{output_folder}/brainstorming-session-{date}.md"
# Workflow metadata
version: "2.0.0"
paradigm: "step-file-architecture"
features:
- "Step-file architecture for modular execution"
- "Game-specific brainstorming techniques"
- "MDA Framework exploration"
- "Core loop brainstorming"
- "Player fantasy mining"
- "Genre mashup ideation"
- "State tracking via frontmatter"
standalone: true
web_bundle:
name: "brainstorm-game"
description: "Facilitate game brainstorming sessions with game-specific context and techniques"
author: "BMad"
instructions: "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/workflow.md"
template: false
web_bundle_files:
# Main workflow file
- "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/workflow.md"
# Step files
- "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-01-init.md"
- "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-02-context.md"
- "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-03-ideation.md"
- "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/steps/step-04-complete.md"
# Context files
- "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/game-context.md"
- "_bmad/bmgd/workflows/1-preproduction/brainstorm-game/game-brain-methods.csv"
dependencies:
- "_bmad/core/workflows/brainstorming/workflow.md"

128
src/modules/bmgd/workflows/1-preproduction/game-brief/checklist.md
View File

@ -1,128 +0,0 @@
# Game Brief Validation Checklist
Use this checklist to ensure your game brief is complete and ready for GDD creation.
## Game Vision ✓
- [ ] **Core Concept** is clear and concise (one sentence)
- [ ] **Elevator Pitch** hooks the reader in 2-3 sentences
- [ ] **Vision Statement** is aspirational but achievable
- [ ] Vision captures the emotional experience you want to create
## Target Market ✓
- [ ] **Primary Audience** is specific (not just "gamers")
- [ ] Age range and experience level are defined
- [ ] Play session expectations are realistic
- [ ] **Market Context** demonstrates opportunity
- [ ] Competitive landscape is understood
- [ ] You know why this audience will care
## Game Fundamentals ✓
- [ ] **Core Gameplay Pillars** (2-4) are clearly defined
- [ ] Each pillar is specific and measurable
- [ ] **Primary Mechanics** describe what players actually DO
- [ ] **Player Experience Goals** connect mechanics to emotions
- [ ] Core loop is clear and compelling
## Scope and Constraints ✓
- [ ] **Target Platforms** are prioritized
- [ ] **Development Timeline** is realistic
- [ ] **Budget** aligns with scope
- [ ] **Team Resources** (size, skills) are documented
- [ ] **Technical Constraints** are identified
- [ ] Scope matches team capability
## Reference Framework ✓
- [ ] **Inspiration Games** (3-5) are listed with specifics
- [ ] You know what you're taking vs. NOT taking from each
- [ ] **Competitive Analysis** covers direct and indirect competitors
- [ ] **Key Differentiators** are genuine and valuable
- [ ] Differentiators are specific (not "just better")
## Content Framework ✓
- [ ] **World and Setting** is defined
- [ ] **Narrative Approach** matches game type
- [ ] **Content Volume** is estimated (rough order of magnitude)
- [ ] Playtime expectations are set
- [ ] Replayability approach is clear
## Art and Audio Direction ✓
- [ ] **Visual Style** is described with references
- [ ] 2D vs. 3D is decided
- [ ] **Audio Style** matches game mood
- [ ] **Production Approach** is realistic for team/budget
- [ ] Style complexity matches capabilities
## Risk Assessment ✓
- [ ] **Key Risks** are honestly identified
- [ ] **Technical Challenges** are documented
- [ ] **Market Risks** are considered
- [ ] **Mitigation Strategies** are actionable
- [ ] Assumptions to validate are listed
## Success Criteria ✓
- [ ] **MVP Definition** is truly minimal
- [ ] MVP can validate core gameplay hypothesis
- [ ] **Success Metrics** are specific and measurable
- [ ] **Launch Goals** are realistic
- [ ] You know what "done" looks like for MVP
## Next Steps ✓
- [ ] **Immediate Actions** are prioritized
- [ ] **Research Needs** are identified
- [ ] **Open Questions** are documented
- [ ] Critical path is clear
- [ ] Blockers are identified
## Overall Quality ✓
- [ ] Brief is clear and concise (3-5 pages)
- [ ] Sections are internally consistent
- [ ] Scope is realistic for team/timeline/budget
- [ ] Vision is compelling and achievable
- [ ] You're excited to build this game
- [ ] Team/stakeholders can understand the vision
## Red Flags 🚩
Watch for these warning signs:
- [ ] ❌ Scope too large for team/timeline
- [ ] ❌ Unclear core loop or pillars
- [ ] ❌ Target audience is "everyone"
- [ ] ❌ Differentiators are vague or weak
- [ ] ❌ No prototype plan for risky mechanics
- [ ] ❌ Budget/timeline is wishful thinking
- [ ] ❌ Market is saturated with no clear positioning
- [ ] ❌ MVP is not actually minimal
## Ready for Next Steps?
If you've checked most boxes and have no major red flags:
✅ **Ready to proceed to:**
- Prototype core mechanic
- GDD workflow
- Team/stakeholder review
- Market validation
⚠️ **Need more work if:**
- Multiple sections incomplete
- Red flags present
- Team/stakeholders don't align
- Core concept unclear
---
_This checklist is a guide, not a gate. Use your judgment based on project needs._

373
src/modules/bmgd/workflows/1-preproduction/game-brief/instructions.md
View File

@ -1,373 +0,0 @@
# Game Brief - Interactive Workflow Instructions
<critical>The workflow execution engine is governed by: {project-root}/_bmad/core/tasks/workflow.xml</critical>
<critical>You MUST have already loaded and processed: {installed_path}/workflow.yaml</critical>
<critical>Communicate all responses in {communication_language} and language MUST be tailored to {user_skill_level}</critical>
<critical>Generate all documents in {document_output_language}</critical>
<critical>⚠️ ABSOLUTELY NO TIME ESTIMATES - NEVER mention hours, days, weeks, months, or ANY time-based predictions. AI has fundamentally changed development speed - what once took teams weeks/months can now be done by one person in hours. DO NOT give ANY time estimates whatsoever.</critical>
<critical>DOCUMENT OUTPUT: Concise, professional, game-design focused. Use tables/lists over prose. User skill level ({user_skill_level}) affects conversation style ONLY, not document content.</critical>
<critical>⚠️ CHECKPOINT PROTOCOL: After EVERY <template-output> tag, you MUST follow workflow.xml substep 2c: SAVE content to file immediately → SHOW checkpoint separator (━━━━━━━━━━━━━━━━━━━━━━━) → DISPLAY generated content → PRESENT options [a]Advanced Elicitation/[c]Continue/[p]Party-Mode/[y]YOLO → WAIT for user response. Never batch saves or skip checkpoints.</critical>
<workflow>
<step n="0" goal="Validate workflow readiness" tag="workflow-status">
<action>Check if {output_folder}/bmgd-workflow-status.yaml exists</action>
<check if="status file not found">
<output>No workflow status file found. Game brief is optional - you can continue without status tracking.</output>
<action>Set standalone_mode = true</action>
</check>
<check if="status file found">
<action>Load the FULL file: {output_folder}/bmgd-workflow-status.yaml</action>
<action>Parse workflow_status section</action>
<action>Check status of "game-brief" workflow</action>
<action>Get project_level from YAML metadata</action>
<action>Find first non-completed workflow (next expected workflow)</action>
<check if="project_type != 'game'">
<output>Note: This is a {{project_type}} project. Game brief is designed for game projects.</output>
<ask>Continue with game brief anyway? (y/n)</ask>
<check if="n">
<action>Exit workflow</action>
</check>
</check>
<check if="game-brief status is file path (already completed)">
<output>⚠️ Game Brief already completed: {{game-brief status}}</output>
<ask>Re-running will overwrite the existing brief. Continue? (y/n)</ask>
<check if="n">
<output>Exiting. Use workflow-status to see your next step.</output>
<action>Exit workflow</action>
</check>
</check>
<check if="game-brief is not the next expected workflow (latter items are completed already in the list)">
<output>⚠️ Next expected workflow: {{next_workflow}}. Game Brief is out of sequence.</output>
<ask>Continue with Game Brief anyway? (y/n)</ask>
<check if="n">
<output>Exiting. Run {{next_workflow}} instead.</output>
<action>Exit workflow</action>
</check>
</check>
<action>Set standalone_mode = false</action>
</check>
</step>
<step n="1" goal="Initialize game brief session">
<action>Welcome the user in {communication_language} to the Game Brief creation process</action>
<action>Explain this is a collaborative process to define their game vision, capturing the essence of what they want to create</action>
<action>Ask for the working title of their game</action>
<template-output>game_name</template-output>
</step>
<step n="1" goal="Gather available inputs and context">
<action>Explore what existing materials the user has available to inform the brief</action>
<action>Offer options for input sources: market research, brainstorming results, competitive analysis, design notes, reference games, or starting fresh</action>
<action>If documents are provided, load and analyze them to extract key insights, themes, and patterns</action>
<action>Engage the user about their core vision: what gameplay experience they want to create, what emotions players should feel, and what sparked this game idea</action>
<action>Build initial understanding through conversational exploration rather than rigid questioning</action>
<template-output>initial_context</template-output>
</step>
<step n="2" goal="Choose collaboration mode">
<ask>How would you like to work through the brief?
**1. Interactive Mode** - We'll work through each section together, discussing and refining as we go
**2. YOLO Mode** - I'll generate a complete draft based on our conversation so far, then we'll refine it together
Which approach works best for you?</ask>
<action>Store the user's preference for mode</action>
<template-output>collaboration_mode</template-output>
</step>
<step n="3" goal="Define game vision" if="collaboration_mode == 'interactive'">
<action>Guide user to articulate their game vision across three levels of depth</action>
<action>Help them craft a one-sentence core concept that captures the essence (reference successful games like "A roguelike deck-builder where you climb a mysterious spire" as examples)</action>
<action>Develop an elevator pitch (2-3 sentences) that would compel a publisher or player - refine until it's concise but hooks attention</action>
<action>Explore their aspirational vision statement: the experience they want to create and what makes it meaningful - ensure it's ambitious yet achievable</action>
<action>Refine through conversation, challenging vague language and elevating compelling ideas</action>
<template-output>core_concept</template-output>
<template-output>elevator_pitch</template-output>
<template-output>vision_statement</template-output>
</step>
<step n="4" goal="Identify target market" if="collaboration_mode == 'interactive'">
<action>Guide user to define their primary target audience with specific demographics, gaming preferences, and behavioral characteristics</action>
<action>Push for specificity beyond generic descriptions like "people who like fun games" - challenge vague answers</action>
<action>Explore secondary audiences if applicable and how their needs might differ</action>
<action>Investigate the market context: opportunity size, competitive landscape, similar successful games, and why now is the right time</action>
<action>Help identify a realistic and reachable audience segment based on evidence or well-reasoned assumptions</action>
<template-output>primary_audience</template-output>
<template-output>secondary_audience</template-output>
<template-output>market_context</template-output>
</step>
<step n="5" goal="Define game fundamentals" if="collaboration_mode == 'interactive'">
<action>Help user identify 2-4 core gameplay pillars that fundamentally define their game - everything should support these pillars</action>
<action>Provide examples from successful games for inspiration (Hollow Knight's "tight controls + challenging combat + rewarding exploration")</action>
<action>Explore what the player actually DOES - core actions, key systems, and interaction models</action>
<action>Define the emotional experience goals: what feelings are you designing for (tension/relief, mastery/growth, creativity/expression, discovery/surprise)</action>
<action>Ensure pillars are specific and measurable, focusing on player actions rather than implementation details</action>
<action>Connect mechanics directly to emotional experiences through guided discussion</action>
<template-output>core_gameplay_pillars</template-output>
<template-output>primary_mechanics</template-output>
<template-output>player_experience_goals</template-output>
</step>
<step n="6" goal="Define scope and constraints" if="collaboration_mode == 'interactive'">
<action>Help user establish realistic project constraints across all key dimensions</action>
<action>Explore target platforms and prioritization (PC, console, mobile, web)</action>
<action>Discuss development timeline: release targets, fixed deadlines, phased release strategies</action>
<action>Investigate budget reality: funding source, asset creation costs, marketing, tools and software</action>
<action>Assess team resources: size, roles, availability, skills gaps, outsourcing needs</action>
<action>Define technical constraints: engine choice, performance targets, file size limits, accessibility requirements</action>
<action>Push for realism about scope - identify potential blockers early and document resource assumptions</action>
<template-output>target_platforms</template-output>
<template-output>development_timeline</template-output>
<template-output>budget_considerations</template-output>
<template-output>team_resources</template-output>
<template-output>technical_constraints</template-output>
</step>
<step n="7" goal="Establish reference framework" if="collaboration_mode == 'interactive'">
<action>Guide user to identify 3-5 inspiration games and articulate what they're drawing from each (mechanics, feel, art style) and explicitly what they're NOT taking</action>
<action>Conduct competitive analysis: identify direct and indirect competitors, analyze what they do well and poorly, and define how this game will differ</action>
<action>Explore key differentiators and unique value proposition - what's the hook that makes players choose this game over alternatives</action>
<action>Challenge "just better" thinking - push for genuine, specific differentiation that's actually valuable to players</action>
<action>Validate that differentiators are concrete, achievable, and compelling</action>
<template-output>inspiration_games</template-output>
<template-output>competitive_analysis</template-output>
<template-output>key_differentiators</template-output>
</step>
<step n="8" goal="Define content framework" if="collaboration_mode == 'interactive'">
<action>Explore the game's world and setting: location, time period, world-building depth, narrative importance, and genre context</action>
<action>Define narrative approach: story-driven/light/absent, linear/branching/emergent, delivery methods (cutscenes, dialogue, environmental), writing scope</action>
<action>Estimate content volume realistically: playthrough length, level/stage count, replayability strategy, total asset volume</action>
<action>Identify if a dedicated narrative workflow will be needed later based on story complexity</action>
<action>Flag content-heavy areas that require detailed planning and resource allocation</action>
<template-output>world_setting</template-output>
<template-output>narrative_approach</template-output>
<template-output>content_volume</template-output>
</step>
<step n="9" goal="Define art and audio direction" if="collaboration_mode == 'interactive'">
<action>Explore visual style direction: art style preference, color palette and mood, reference games/images, 2D vs 3D, animation requirements</action>
<action>Define audio style: music genre and mood, SFX approach, voice acting scope, audio's importance to gameplay</action>
<action>Discuss production approach: in-house creation vs outsourcing, asset store usage, AI/generative tools, style complexity vs team capability</action>
<action>Ensure art and audio vision aligns realistically with budget and team skills - identify potential production bottlenecks early</action>
<action>Note if a comprehensive style guide will be needed for consistent production</action>
<template-output>visual_style</template-output>
<template-output>audio_style</template-output>
<template-output>production_approach</template-output>
</step>
<step n="10" goal="Assess risks" if="collaboration_mode == 'interactive'">
<action>Facilitate honest risk assessment across all dimensions - what could prevent completion, what could make it unfun, what assumptions might be wrong</action>
<action>Identify technical challenges: unproven elements, performance concerns, platform-specific issues, tool dependencies</action>
<action>Explore market risks: saturation, trend dependency, competition intensity, discoverability challenges</action>
<action>For each major risk, develop actionable mitigation strategies - how to validate assumptions, backup plans, early prototyping opportunities</action>
<action>Prioritize risks by impact and likelihood, focusing on proactive mitigation rather than passive worry</action>
<template-output>key_risks</template-output>
<template-output>technical_challenges</template-output>
<template-output>market_risks</template-output>
<template-output>mitigation_strategies</template-output>
</step>
<step n="11" goal="Define success criteria" if="collaboration_mode == 'interactive'">
<action>Define the MVP (Minimum Playable Version) - what's the absolute minimum where the core loop is fun and complete, with essential content only</action>
<action>Establish specific, measurable success metrics: player acquisition, retention rates, session length, completion rate, review scores, revenue targets, community engagement</action>
<action>Set concrete launch goals: first-month sales/downloads, review score targets, streamer/press coverage, community size</action>
<action>Push for specificity and measurability - challenge vague aspirations with "how will you measure that?"</action>
<action>Clearly distinguish between MVP milestones and full release goals, ensuring all targets are realistic given resources</action>
<template-output>mvp_definition</template-output>
<template-output>success_metrics</template-output>
<template-output>launch_goals</template-output>
</step>
<step n="12" goal="Identify immediate next steps" if="collaboration_mode == 'interactive'">
<action>Identify immediate actions to take right after this brief: prototype core mechanics, create art style tests, validate technical feasibility, build vertical slice, playtest with target audience</action>
<action>Determine research needs: market validation, technical proof of concept, player interest testing, competitive deep-dive</action>
<action>Document open questions and uncertainties: unresolved design questions, technical unknowns, market validation needs, resource/budget questions</action>
<action>Create actionable, specific next steps - prioritize by importance and dependency</action>
<action>Identify blockers that must be resolved before moving forward</action>
<template-output>immediate_actions</template-output>
<template-output>research_needs</template-output>
<template-output>open_questions</template-output>
</step>
<!-- YOLO Mode - Generate everything then refine -->
<step n="3" goal="Generate complete brief draft" if="collaboration_mode == 'yolo'">
<action>Based on initial context and any provided documents, generate a complete game brief covering all sections</action>
<action>Make reasonable assumptions where information is missing</action>
<action>Flag areas that need user validation with [NEEDS CONFIRMATION] tags</action>
<template-output>core_concept</template-output>
<template-output>elevator_pitch</template-output>
<template-output>vision_statement</template-output>
<template-output>primary_audience</template-output>
<template-output>secondary_audience</template-output>
<template-output>market_context</template-output>
<template-output>core_gameplay_pillars</template-output>
<template-output>primary_mechanics</template-output>
<template-output>player_experience_goals</template-output>
<template-output>target_platforms</template-output>
<template-output>development_timeline</template-output>
<template-output>budget_considerations</template-output>
<template-output>team_resources</template-output>
<template-output>technical_constraints</template-output>
<template-output>inspiration_games</template-output>
<template-output>competitive_analysis</template-output>
<template-output>key_differentiators</template-output>
<template-output>world_setting</template-output>
<template-output>narrative_approach</template-output>
<template-output>content_volume</template-output>
<template-output>visual_style</template-output>
<template-output>audio_style</template-output>
<template-output>production_approach</template-output>
<template-output>key_risks</template-output>
<template-output>technical_challenges</template-output>
<template-output>market_risks</template-output>
<template-output>mitigation_strategies</template-output>
<template-output>mvp_definition</template-output>
<template-output>success_metrics</template-output>
<template-output>launch_goals</template-output>
<template-output>immediate_actions</template-output>
<template-output>research_needs</template-output>
<template-output>open_questions</template-output>
<action>Present the complete draft to the user</action>
<ask>Here's the complete game brief draft. What would you like to adjust or refine?</ask>
</step>
<step n="4" goal="Refine brief sections" repeat="until-approved" if="collaboration_mode == 'yolo'">
<ask>Which section would you like to refine?
1. Game Vision
2. Target Market
3. Game Fundamentals
4. Scope and Constraints
5. Reference Framework
6. Content Framework
7. Art and Audio Direction
8. Risk Assessment
9. Success Criteria
10. Next Steps
11. Save and continue</ask>
<action>Work with user to refine selected section</action>
<action>Update relevant template outputs</action>
</step>
<!-- Final steps for both modes -->
<step n="13" goal="Create executive summary">
<action>Synthesize all sections into a compelling executive summary</action>
<action>Include:
- Game concept in 1-2 sentences
- Target audience and market
- Core gameplay pillars
- Key differentiators
- Success vision</action>
<template-output>executive_summary</template-output>
</step>
<step n="14" goal="Compile supporting materials">
<action>If research documents were provided, create a summary of key findings</action>
<action>Document any stakeholder input received during the process</action>
<action>Compile list of reference games and resources</action>
<template-output>research_summary</template-output>
<template-output>stakeholder_input</template-output>
<template-output>references</template-output>
</step>
<step n="15" goal="Final review and handoff">
<action>Generate the complete game brief document</action>
<action>Review all sections for completeness and consistency</action>
<action>Flag any areas that need design attention with [DESIGN-TODO] tags</action>
<ask>The game brief is complete! Would you like to:
1. Review the entire document
2. Make final adjustments
3. Generate an executive summary version (3-page limit)
4. Save and prepare for GDD creation
This brief will serve as the primary input for creating the Game Design Document (GDD).
**Recommended next steps:**
- Create prototype of core mechanic
- Proceed to GDD workflow: `workflow gdd`
- Validate assumptions with target players</ask>
<check if="user chooses option 3 (executive summary)">
<action>Create condensed 3-page executive brief focusing on: core concept, target market, gameplay pillars, key differentiators, and success criteria</action>
<action>Save as: {output_folder}/game-brief-executive-{{game_name}}-{{date}}.md</action>
</check>
<template-output>final_brief</template-output>
<template-output>executive_brief</template-output>
</step>
<step n="16" goal="Update status and complete" tag="workflow-status">
<check if="standalone_mode != true">
<action>Load the FULL file: {output_folder}/bmgd-workflow-status.yaml</action>
<action>Find workflow_status key "game-brief"</action>
<critical>ONLY write the file path as the status value - no other text, notes, or metadata</critical>
<action>Update workflow_status["game-brief"] = "{output_folder}/bmm-game-brief-{{game_name}}-{{date}}.md"</action>
<action>Save file, preserving ALL comments and structure including STATUS DEFINITIONS</action>
<action>Find first non-completed workflow in workflow_status (next workflow to do)</action>
<action>Determine next agent from path file based on next workflow</action>
</check>
<output>**✅ Game Brief Complete, {user_name}!**
**Brief Document:**
- Game brief saved to {output_folder}/bmm-game-brief-{{game_name}}-{{date}}.md
{{#if standalone_mode != true}}
**Status Updated:**
- Progress tracking updated: game-brief marked complete
- Next workflow: {{next_workflow}}
{{else}}
**Note:** Running in standalone mode (no progress tracking)
{{/if}}
**Next Steps:**
{{#if standalone_mode != true}}
- **Next workflow:** {{next_workflow}} ({{next_agent}} agent)
- **Optional:** Consider creating a prototype of core mechanic or validating assumptions with target players before proceeding
Check status anytime with: `workflow-status`
{{else}}
Since no workflow is in progress:
- Refer to the BMM workflow guide if unsure what to do next
- Or run `workflow-init` to create a workflow path and get guided next steps
{{/if}}
</output>
</step>
</workflow>

224
src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-01-init.md
View File

@ -1,224 +0,0 @@
---
name: 'step-01-init'
description: 'Initialize the Game Brief workflow by detecting continuation state and setting up the document'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
# File References
thisStepFile: './step-01-init.md'
nextStepFile: './step-02-vision.md'
continueStepFile: './step-01b-continue.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/game-brief.md'
# Template References
briefTemplate: '{workflow_path}/templates/game-brief-template.md'
---
# Step 1: Workflow Initialization
**Progress: Step 1 of 8** - Next: Game Vision
## STEP GOAL:
Initialize the Game Brief workflow by detecting continuation state, discovering any input documents (brainstorming, research), and setting up the document structure.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- NEVER mention time estimates
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a veteran game designer facilitator collaborating with a creative peer
- If you already have been given a name, communication_style and persona, continue to use those while playing this new role
- We engage in collaborative dialogue, not command-response
- You bring structured game design thinking and facilitation skills
### Step-Specific Rules:
- Focus only on initialization and setup - no content generation yet
- FORBIDDEN to look ahead to future steps or assume knowledge from them
- Approach: Systematic setup with clear reporting to user
- Detect existing workflow state and handle continuation properly
## EXECUTION PROTOCOLS:
- Show your analysis of current state before taking any action
- Initialize document structure and update frontmatter appropriately
- Set up frontmatter `stepsCompleted: [1]` before loading next step
- FORBIDDEN to load next step until user selects 'C' (Continue)
## CONTEXT BOUNDARIES:
- Available context: Variables from workflow.md are available in memory
- Focus: Workflow initialization and document setup only
- Limits: Don't assume knowledge from other steps or create content yet
- Dependencies: Configuration loaded from workflow.md initialization
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Check for Existing Workflow State
First, check if the output document already exists:
**Workflow State Detection:**
- Look for file at `{outputFile}`
- If exists, read the complete file including frontmatter
- If not exists, this is a fresh workflow
### 2. Handle Continuation (If Document Exists)
If the document exists and has frontmatter with `stepsCompleted`:
**Continuation Protocol:**
- **STOP immediately** and load `{continueStepFile}`
- Do not proceed with any initialization tasks
- Let step-01b handle all continuation logic
- This is an auto-proceed situation - no user choice needed
### 3. Fresh Workflow Setup (If No Document)
If no document exists or no `stepsCompleted` in frontmatter:
#### A. Input Document Discovery
Discover and load context documents using smart discovery.
**IMPORTANT: Track document counts as you discover files.**
Initialize counters:
```
brainstormingCount = 0
researchCount = 0
notesCount = 0
```
**Brainstorming Documents:**
1. Check: `{output_folder}/*brainstorm*.md`
2. Check: `{output_folder}/analysis/*brainstorm*.md`
3. Load completely and extract key ideas
4. **Update brainstormingCount with number of files found**
**Research Documents:**
1. Check: `{output_folder}/*research*.md`
2. Check: `{output_folder}/analysis/*research*.md`
3. Load useful research files completely
4. **Update researchCount with number of files found**
**Design Notes:**
1. Check: `{output_folder}/*notes*.md` or `{output_folder}/*design*.md`
2. Load any relevant design notes
3. **Update notesCount with number of files found**
**Loading Rules:**
- Load ALL discovered files completely (no offset/limit)
- Track all successfully loaded files in frontmatter `inputDocuments` array
#### B. Create Initial Document
**Document Setup:**
- Copy the template from `{briefTemplate}` to `{outputFile}`
- Initialize frontmatter with proper structure:
```yaml
---
stepsCompleted: []
inputDocuments: []
documentCounts:
brainstorming: { { brainstormingCount } }
research: { { researchCount } }
notes: { { notesCount } }
workflowType: 'game-brief'
lastStep: 0
project_name: '{{project_name}}'
user_name: '{{user_name}}'
date: '{{date}}'
game_name: ''
---
```
#### C. Present Initialization Results
**Setup Report to User:**
"Welcome {{user_name}}! I've set up your Game Brief workspace.
**Document Setup:**
- Created: `{outputFile}` from template
- Initialized frontmatter with workflow state
**Input Documents Discovered:**
- Brainstorming: {{brainstormingCount}} files {if brainstormingCount > 0}loaded{else}(none found){/if}
- Research: {{researchCount}} files {if researchCount > 0}loaded{else}(none found){/if}
- Design notes: {{notesCount}} files {if notesCount > 0}loaded{else}(none found){/if}
{if any_documents_found}
I'll use these documents to give us a head start on your game brief.
{else}
We'll start fresh and build your game vision together through conversation.
{/if}
Do you have any other documents you'd like me to include, or shall we continue?"
### 4. Present MENU OPTIONS
Display menu after setup report:
"[C] Continue - Save this and move to Game Vision (Step 2 of 8)"
#### Menu Handling Logic:
- IF C: Update frontmatter with `stepsCompleted: [1]`, then load, read entire file, then execute {nextStepFile}
- IF user provides additional files: Load them, update inputDocuments and documentCounts, redisplay report
- IF user asks questions: Answer and redisplay menu
#### EXECUTION RULES:
- ALWAYS halt and wait for user input after presenting menu
- ONLY proceed to next step when user selects 'C'
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [frontmatter properly updated with stepsCompleted: [1] and documentCounts], will you then load and read fully `{nextStepFile}` to execute and begin game vision discovery.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Existing workflow detected and properly handed off to step-01b
- Fresh workflow initialized with template and proper frontmatter
- Input documents discovered and loaded
- All discovered files tracked in frontmatter `inputDocuments`
- **Document counts stored in frontmatter `documentCounts`**
- Menu presented and user input handled correctly
- Frontmatter updated with `stepsCompleted: [1]` before proceeding
### SYSTEM FAILURE:
- Proceeding with fresh initialization when existing workflow exists
- Not updating frontmatter with discovered input documents
- **Not storing document counts in frontmatter**
- Creating document without proper template structure
- Proceeding without user selecting 'C' (Continue)
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

152
src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-01b-continue.md
View File

@ -1,152 +0,0 @@
---
name: 'step-01b-continue'
description: 'Resume an interrupted Game Brief workflow from the last completed step'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
# File References
thisStepFile: './step-01b-continue.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/game-brief.md'
---
# Step 1B: Workflow Continuation
## STEP GOAL:
Resume the Game Brief workflow from where it was left off, ensuring smooth continuation with full context restoration.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a veteran game designer facilitator collaborating with a creative peer
- We engage in collaborative dialogue, not command-response
- Resume workflow from exact point where it was interrupted
### Step-Specific Rules:
- FOCUS on understanding where we left off and continuing appropriately
- FORBIDDEN to modify content completed in previous steps
- Only reload documents that were already tracked in `inputDocuments`
## EXECUTION PROTOCOLS:
- Show your analysis of current state before taking action
- Keep existing frontmatter `stepsCompleted` values
- Only load documents that were already tracked in `inputDocuments`
- FORBIDDEN to discover new input documents during continuation
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Analyze Current State
**State Assessment:**
Review the frontmatter to understand:
- `stepsCompleted`: Which steps are already done
- `lastStep`: The most recently completed step number
- `inputDocuments`: What context was already loaded
- `documentCounts`: brainstorming, research, notes counts
- `game_name`: The game name (if set)
- All other frontmatter variables
### 2. Restore Context Documents
**Context Reloading:**
- For each document in `inputDocuments`, load the complete file
- This ensures you have full context for continuation
- Don't discover new documents - only reload what was previously processed
### 3. Present Current Progress
**Progress Report to User:**
"Welcome back {{user_name}}! I'm resuming our Game Brief collaboration for {{game_name or project_name}}.
**Current Progress:**
- Steps completed: {stepsCompleted}
- Last worked on: Step {lastStep}
- Context documents available: {len(inputDocuments)} files
**Document Status:**
- Current Game Brief is ready with all completed sections
- Ready to continue from where we left off
Does this look right, or do you want to make any adjustments before we proceed?"
### 4. Determine Continuation Path
**Next Step Logic:**
Based on `lastStep` value, determine which step to load next:
- If `lastStep = 1` -> Load `./step-02-vision.md`
- If `lastStep = 2` -> Load `./step-03-market.md`
- If `lastStep = 3` -> Load `./step-04-fundamentals.md`
- If `lastStep = 4` -> Load `./step-05-scope.md`
- If `lastStep = 5` -> Load `./step-06-references.md`
- If `lastStep = 6` -> Load `./step-07-content.md`
- If `lastStep = 7` -> Load `./step-08-complete.md`
- If `lastStep = 8` -> Workflow already complete
### 5. Handle Workflow Completion
**If workflow already complete (`lastStep = 8`):**
"Great news! It looks like we've already completed the Game Brief workflow for {{game_name}}.
The final document is ready at `{outputFile}` with all sections completed.
Would you like me to:
- Review the completed brief with you
- Suggest next workflow steps (like GDD creation)
- Start a new brief revision
What would be most helpful?"
### 6. Present MENU OPTIONS
**If workflow not complete:**
Display: "Ready to continue with Step {nextStepNumber}?
**Select an Option:** [C] Continue to next step"
#### Menu Handling Logic:
- IF C: Load, read entire file, then execute the appropriate next step file based on `lastStep`
- IF Any other comments or queries: respond and redisplay menu
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [current state confirmed], will you then load and read fully the appropriate next step file to resume the workflow.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- All previous input documents successfully reloaded
- Current workflow state accurately analyzed and presented
- User confirms understanding of progress before continuation
- Correct next step identified and prepared for loading
### SYSTEM FAILURE:
- Discovering new input documents instead of reloading existing ones
- Modifying content from already completed steps
- Loading wrong next step based on `lastStep` value
- Proceeding without user confirmation of current state
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

219
src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-02-vision.md
View File

@ -1,219 +0,0 @@
---
name: 'step-02-vision'
description: 'Define the core game vision including name, concept, pitch, and vision statement'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
# File References
thisStepFile: './step-02-vision.md'
nextStepFile: './step-03-market.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/game-brief.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 2: Game Vision
**Progress: Step 2 of 8** - Next: Target Market
## STEP GOAL:
Capture the core game vision including the working title, one-sentence concept, elevator pitch, and aspirational vision statement that will guide all design decisions.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- NEVER mention time estimates
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a veteran game designer facilitator collaborating with a creative peer
- Vision is the foundation - get it right before moving forward
- Challenge vague language and elevate compelling ideas
### Step-Specific Rules:
- Focus on crystallizing the game's core identity
- FORBIDDEN to generate vision without real user input
- Push for specificity and clarity
- Reference successful games as examples of good pitches
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Present A/P/C menu after generating content
- ONLY save when user chooses C (Continue)
- Update frontmatter `stepsCompleted: [1, 2]` before loading next step
- FORBIDDEN to load next step until C is selected
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Dig deeper into the vision
- **P (Party Mode)**: Get multiple perspectives on the vision
- **C (Continue)**: Save the content to the document and proceed to next step
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Game Name Discovery
**Start with the basics:**
"Let's start with your game's identity.
**What's the working title for your game?**
(Don't worry if it's not final - working titles help us talk about the game and can always change later.)"
Store in frontmatter: `game_name: '{user_provided_name}'`
### 2. Context Check
**If input documents were loaded:**
"I've reviewed your {brainstorming/research} documents and noticed some interesting ideas:
{summarize_key_themes_from_documents}
Let's use these as a starting point for crystallizing your vision."
### 3. Core Concept Discovery
**Guide user through concept definition:**
"Now let's capture the essence of {{game_name}} in a single sentence.
**Examples of great one-sentence concepts:**
- 'A roguelike deck-builder where you climb a mysterious spire' (Slay the Spire)
- 'A precision platformer about climbing a mountain and overcoming anxiety' (Celeste)
- 'A cozy farming sim where you rebuild your grandfather's farm and become part of a small town' (Stardew Valley)
**What is {{game_name}}?** Give me one sentence that captures the core experience."
### 4. Elevator Pitch Discovery
**Build on the concept:**
"Now let's expand that into an elevator pitch - 2-3 sentences that would compel a player or publisher to want to know more.
**A great elevator pitch answers:**
- What is it? (genre, style)
- What do you do? (core action)
- What makes it special? (hook)
**Refine this until it hooks attention.** What's your elevator pitch for {{game_name}}?"
### 5. Vision Statement Discovery
**Explore the aspirational vision:**
"Finally, let's capture your aspirational vision - the experience you want to create and what makes it meaningful.
**Questions to consider:**
- What feeling do you want players to have when they put down the controller?
- What would make this game matter to someone?
- What's your personal motivation for making this?
**This is your North Star** - ambitious yet achievable. What's your vision for {{game_name}}?"
### 6. Generate Vision Content
Based on the conversation, prepare the content:
```markdown
## Game Vision
### Core Concept
{{core_concept}}
### Elevator Pitch
{{elevator_pitch}}
### Vision Statement
{{vision_statement}}
```
### 7. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Game Vision section based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 6]
**Validation Check:**
- Does the core concept capture the essence?
- Does the pitch hook attention?
- Does the vision inspire?
**Select an Option:**
[A] Advanced Elicitation - Refine and strengthen the vision
[P] Party Mode - Get other perspectives on the vision
[C] Continue - Save this and move to Target Market (Step 3 of 8)"
### 8. Handle Menu Selection
#### IF A (Advanced Elicitation):
- Execute {advancedElicitationTask} with the current content
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF P (Party Mode):
- Execute {partyModeWorkflow} with the current content
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF C (Continue):
- Append the final content to `{outputFile}`
- Update frontmatter: `stepsCompleted: [1, 2]`, `game_name: '{game_name}'`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [vision content saved with frontmatter updated including game_name], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Game name captured and stored in frontmatter
- Core concept is clear and concise (one sentence)
- Elevator pitch is compelling (2-3 sentences)
- Vision statement is aspirational yet achievable
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2]
### SYSTEM FAILURE:
- Generating vision without user input
- Core concept is vague or generic
- Elevator pitch doesn't hook attention
- Not presenting A/P/C menu after content generation
- Proceeding without user selecting 'C'
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

219
src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-03-market.md
View File

@ -1,219 +0,0 @@
---
name: 'step-03-market'
description: 'Define target audience and market context'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
# File References
thisStepFile: './step-03-market.md'
nextStepFile: './step-04-fundamentals.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/game-brief.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 3: Target Market
**Progress: Step 3 of 8** - Next: Game Fundamentals
## STEP GOAL:
Define the primary and secondary target audiences with specific demographics, and establish the market context including competitive landscape and timing.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- NEVER mention time estimates
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a veteran game designer facilitator collaborating with a creative peer
- Push for specificity beyond generic descriptions
- Challenge vague answers like "people who like fun games"
### Step-Specific Rules:
- Focus on who will actually play this game
- FORBIDDEN to generate audience without real user input
- Help identify a realistic and reachable audience segment
- Consider secondary audiences if applicable
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Present A/P/C menu after generating content
- ONLY save when user chooses C (Continue)
- Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Dig deeper into audience insights
- **P (Party Mode)**: Get multiple perspectives on market positioning
- **C (Continue)**: Save the content and proceed
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Primary Audience Discovery
**Guide user through audience definition:**
"Let's define who {{game_name}} is really for.
**Primary Audience Questions:**
- **Age range:** Who are you designing for?
- **Gaming experience:** Casual, core, or hardcore gamers?
- **Genre familiarity:** Do they know this genre well, or are they new to it?
- **Play patterns:** When and how do they play? (commute, evening sessions, weekends)
- **Motivations:** What draws them to games like this?
**Push for specificity:**
'People who like roguelikes' is too broad. 'Experienced roguelike fans who want deeper deckbuilding strategy' is better.
Who is your primary audience for {{game_name}}?"
### 2. Secondary Audience Discovery
**Explore additional audiences:**
"Are there secondary audiences who might enjoy {{game_name}}?
**Examples:**
- Primary: Hardcore roguelike fans → Secondary: Strategy game players looking for something new
- Primary: Cozy game fans → Secondary: Burnt-out competitive gamers seeking relaxation
**If you have a secondary audience:**
- How do their needs differ from primary?
- What features might appeal specifically to them?
Do you have a secondary audience in mind?"
### 3. Market Context Discovery
**Explore the competitive landscape:**
"Let's understand the market context for {{game_name}}.
**Market Questions:**
- **Similar successful games:** What games have proven there's an audience?
- **Market gaps:** What's missing that {{game_name}} could fill?
- **Timing:** Why is now the right time for this game?
- **Competition:** Who are you competing with for player attention?
- **Discoverability:** How will players find your game?
What does the market look like for {{game_name}}?"
### 4. Generate Market Content
Based on the conversation, prepare the content:
```markdown
## Target Market
### Primary Audience
{{primary_audience_description}}
**Demographics:**
{{demographics}}
**Gaming Preferences:**
{{gaming_preferences}}
**Motivations:**
{{what_draws_them}}
### Secondary Audience
{{secondary_audience_description}}
### Market Context
{{market_context_analysis}}
**Similar Successful Games:**
{{comparable_titles}}
**Market Opportunity:**
{{why_now}}
```
### 5. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Target Market section based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 4]
**Validation Check:**
- Is the primary audience specific enough to guide design decisions?
- Does the market context support the viability of this game?
**Select an Option:**
[A] Advanced Elicitation - Dig deeper into market insights
[P] Party Mode - Get perspectives on market positioning
[C] Continue - Save this and move to Game Fundamentals (Step 4 of 8)"
### 6. Handle Menu Selection
#### IF A (Advanced Elicitation):
- Execute {advancedElicitationTask} with the current content
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF P (Party Mode):
- Execute {partyModeWorkflow} with the current content
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF C (Continue):
- Append the final content to `{outputFile}`
- Update frontmatter: `stepsCompleted: [1, 2, 3]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [market content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Primary audience is specific and well-defined
- Secondary audience considered (even if none exists)
- Market context provides business rationale
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3]
### SYSTEM FAILURE:
- Generating audience without user input
- Audience is too vague to guide decisions
- Not presenting A/P/C menu after content generation
- Proceeding without user selecting 'C'
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

232
src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-04-fundamentals.md
View File

@ -1,232 +0,0 @@
---
name: 'step-04-fundamentals'
description: 'Define core gameplay pillars, mechanics, and player experience goals'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
# File References
thisStepFile: './step-04-fundamentals.md'
nextStepFile: './step-05-scope.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/game-brief.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 4: Game Fundamentals
**Progress: Step 4 of 8** - Next: Scope & Constraints
## STEP GOAL:
Define the core gameplay pillars (fundamental design tenets), primary mechanics (what players do), and player experience goals (what feelings are designed for).
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- NEVER mention time estimates
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a veteran game designer facilitator collaborating with a creative peer
- Pillars are the "constitution" - everything must serve them
- Connect mechanics directly to emotional experiences
### Step-Specific Rules:
- Focus on the core of what makes this game unique
- FORBIDDEN to generate fundamentals without real user input
- Ensure pillars are specific and measurable
- Focus on player actions rather than implementation details
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Present A/P/C menu after generating content
- ONLY save when user chooses C (Continue)
- Update frontmatter `stepsCompleted: [1, 2, 3, 4]` before loading next step
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Stress test the fundamentals
- **P (Party Mode)**: Get perspectives on core design
- **C (Continue)**: Save the content and proceed
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Core Pillars Discovery
**Guide user through pillar definition:**
"Let's define the core pillars for {{game_name}} - the 2-4 fundamental design tenets that everything must serve.
**Examples of Great Pillars:**
| Game | Pillars |
| ------------------ | --------------------------------------------------------- |
| **Hollow Knight** | Tight controls, challenging combat, rewarding exploration |
| **Celeste** | Precision movement, accessibility, emotional narrative |
| **Dead Cells** | Mastery, variety, momentum |
| **Stardew Valley** | Relaxation, progression, community |
**Questions to consider:**
- If a feature doesn't serve a pillar, should it be in the game?
- When pillars conflict, which wins?
What are the 2-4 core pillars for {{game_name}}?"
### 2. Primary Mechanics Discovery
**Explore what players actually do:**
"Now let's define what players actually DO in {{game_name}}.
**Think in verbs - what actions define the experience?**
Examples:
- Jump, dash, climb (movement)
- Attack, dodge, parry (combat)
- Craft, build, place (creation)
- Talk, choose, influence (social)
- Collect, trade, manage (economy)
**Questions to consider:**
- What's the core action players repeat most often?
- What actions create the most satisfying moments?
- How do different mechanics interact?
What are the primary mechanics in {{game_name}}?"
### 3. Experience Goals Discovery
**Define the emotional targets:**
"Finally, let's define the player experience goals - what feelings are you designing for?
**Emotional Experience Framework:**
| Emotion | Examples |
| ------------------------- | -------------------------------------- |
| **Tension/Relief** | Horror games, difficult boss fights |
| **Mastery/Growth** | Skill-based games, RPG progression |
| **Creativity/Expression** | Sandbox games, character customization |
| **Discovery/Surprise** | Exploration games, mystery narratives |
| **Connection/Belonging** | Multiplayer, community-driven games |
| **Relaxation/Flow** | Cozy games, rhythm games |
**Questions to consider:**
- What feeling do you want players to have after a session?
- What emotional journey happens during play?
- What makes this experience meaningful?
What are the player experience goals for {{game_name}}?"
### 4. Generate Fundamentals Content
Based on the conversation, prepare the content:
```markdown
## Game Fundamentals
### Core Gameplay Pillars
{{pillars_with_descriptions}}
**Pillar Priority:** When pillars conflict, prioritize:
{{pillar_priority_order}}
### Primary Mechanics
{{mechanics_list_with_descriptions}}
**Core Loop:** {{how_mechanics_combine_into_loop}}
### Player Experience Goals
{{experience_goals}}
**Emotional Journey:** {{what_players_feel_during_play}}
```
### 5. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Game Fundamentals section based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 4]
**Validation Check:**
- Do all pillars support your vision?
- Do mechanics serve the pillars?
- Do experience goals match your audience?
**Select an Option:**
[A] Advanced Elicitation - Stress test these fundamentals
[P] Party Mode - Get other perspectives on core design
[C] Continue - Save this and move to Scope & Constraints (Step 5 of 8)"
### 6. Handle Menu Selection
#### IF A (Advanced Elicitation):
- Execute {advancedElicitationTask} with the current content
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF P (Party Mode):
- Execute {partyModeWorkflow} with the current content
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF C (Continue):
- Append the final content to `{outputFile}`
- Update frontmatter: `stepsCompleted: [1, 2, 3, 4]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [fundamentals content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- 2-4 clear, actionable pillars defined
- Primary mechanics clearly described
- Experience goals tied to audience and vision
- Pillar priority established
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3, 4]
### SYSTEM FAILURE:
- Generating fundamentals without user input
- Generic pillars that don't guide decisions
- Mechanics disconnected from experience goals
- Not presenting A/P/C menu after content generation
- Proceeding without user selecting 'C'
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

243
src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-05-scope.md
View File

@ -1,243 +0,0 @@
---
name: 'step-05-scope'
description: 'Define project scope including platforms, constraints, and resources'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
# File References
thisStepFile: './step-05-scope.md'
nextStepFile: './step-06-references.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/game-brief.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 5: Scope & Constraints
**Progress: Step 5 of 8** - Next: Reference Framework
## STEP GOAL:
Define realistic project constraints including target platforms, budget considerations, team resources, and technical constraints. Push for realism about scope.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- NEVER mention time estimates
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a veteran game designer facilitator collaborating with a creative peer
- Push for realism about constraints
- Identify potential blockers early
### Step-Specific Rules:
- Focus on establishing realistic boundaries
- FORBIDDEN to generate scope without real user input
- Help identify skill gaps and resource assumptions
- Document constraints that will affect design decisions
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Present A/P/C menu after generating content
- ONLY save when user chooses C (Continue)
- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5]` before loading next step
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Challenge assumptions about scope
- **P (Party Mode)**: Get perspectives on feasibility
- **C (Continue)**: Save the content and proceed
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Platform Discovery
**Guide user through platform selection:**
"Let's define where {{game_name}} will be played.
**Platform Considerations:**
| Platform | Key Considerations |
| -------------- | ------------------------------------------------------- |
| **PC (Steam)** | Keyboard/mouse, largest indie audience, most flexible |
| **Console** | Controller-first, certification, couch play |
| **Mobile** | Touch controls, short sessions, different monetization |
| **Web** | Instant access, file size limits, browser compatibility |
| **VR** | Specialized hardware, motion controls, comfort |
**Questions to consider:**
- Where does your target audience primarily play?
- Which platform(s) are you targeting for launch?
- Are there secondary platforms for later?
What platform(s) are you targeting for {{game_name}}?"
### 2. Budget Considerations
**Explore financial constraints:**
"Let's be realistic about budget constraints.
**Budget Categories:**
- **Development costs:** Tools, software, hardware
- **Asset creation:** Art, audio, music (in-house vs outsource)
- **Marketing:** Visibility, trailers, press
- **Platform fees:** Store cuts, devkit costs
- **External services:** Servers, analytics, localization
**Questions to consider:**
- What's your budget reality? (self-funded, funded, shoestring)
- What can you create yourself vs need to outsource?
- Are there areas where budget will limit scope?
What are the budget considerations for {{game_name}}?"
### 3. Team Resources Discovery
**Assess team capabilities:**
"Let's understand what team resources you have.
**Resource Questions:**
- **Team size:** Solo, small team, larger team?
- **Roles covered:** Design, programming, art, audio, marketing?
- **Availability:** Full-time, part-time, nights/weekends?
- **Skill gaps:** What expertise is missing?
- **Outsourcing:** What might need external help?
What team resources do you have for {{game_name}}?"
### 4. Technical Constraints Discovery
**Identify technical boundaries:**
"Finally, let's identify technical constraints.
**Technical Considerations:**
- **Engine/framework:** Already decided or open?
- **Performance targets:** Frame rate, file size, load times?
- **Technical experience:** Team's technical capabilities?
- **Accessibility:** What accessibility features are required?
- **Online features:** Multiplayer, leaderboards, cloud saves?
What technical constraints apply to {{game_name}}?"
### 5. Generate Scope Content
Based on the conversation, prepare the content:
```markdown
## Scope and Constraints
### Target Platforms
**Primary:** {{primary_platform}}
**Secondary:** {{secondary_platforms}}
### Budget Considerations
{{budget_overview}}
### Team Resources
{{team_composition}}
**Skill Gaps:** {{identified_gaps}}
### Technical Constraints
{{technical_constraints}}
### Scope Realities
{{scope_acknowledgements}}
```
### 6. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Scope & Constraints section based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 5]
**Validation Check:**
- Are these constraints realistic?
- Have we identified potential blockers?
- Is the scope achievable with these resources?
**Select an Option:**
[A] Advanced Elicitation - Challenge scope assumptions
[P] Party Mode - Get perspectives on feasibility
[C] Continue - Save this and move to Reference Framework (Step 6 of 8)"
### 7. Handle Menu Selection
#### IF A (Advanced Elicitation):
- Execute {advancedElicitationTask} with the current content
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF P (Party Mode):
- Execute {partyModeWorkflow} with the current content
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF C (Continue):
- Append the final content to `{outputFile}`
- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [scope content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Target platforms clearly defined
- Budget constraints documented realistically
- Team resources and gaps identified
- Technical constraints established
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5]
### SYSTEM FAILURE:
- Generating scope without user input
- Unrealistic constraints that set project up for failure
- Missing critical blockers
- Not presenting A/P/C menu after content generation
- Proceeding without user selecting 'C'
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

225
src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-06-references.md
View File

@ -1,225 +0,0 @@
---
name: 'step-06-references'
description: 'Define inspiration games, competitive analysis, and key differentiators'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
# File References
thisStepFile: './step-06-references.md'
nextStepFile: './step-07-content.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/game-brief.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 6: Reference Framework
**Progress: Step 6 of 8** - Next: Content Framework
## STEP GOAL:
Identify inspiration games (what you're drawing from and NOT taking), analyze competition, and define concrete differentiators that make this game worth making.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- NEVER mention time estimates
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a veteran game designer facilitator collaborating with a creative peer
- Challenge "just better" thinking
- Push for genuine, specific differentiation
### Step-Specific Rules:
- Focus on what makes this game unique
- FORBIDDEN to generate references without real user input
- Validate that differentiators are concrete and achievable
- Understand both what you're taking AND what you're avoiding
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Present A/P/C menu after generating content
- ONLY save when user chooses C (Continue)
- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6]` before loading next step
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Challenge differentiation claims
- **P (Party Mode)**: Get perspectives on uniqueness
- **C (Continue)**: Save the content and proceed
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Inspiration Games Discovery
**Guide user through references:**
"Let's identify the games that inspire {{game_name}}.
**For each inspiration game, I want to know:**
1. **What game?**
2. **What are you taking?** (mechanics, feel, art style, structure)
3. **What are you NOT taking?** (equally important!)
**Example:**
- 'From Hades: the combat feel and build variety'
- 'NOT from Hades: the roguelike structure or the dialogue system'
What 3-5 games inspire {{game_name}}, and what specifically are you drawing from each?"
### 2. Competitive Analysis Discovery
**Explore the competition:**
"Now let's analyze your competition.
**Competition Questions:**
- **Direct competitors:** Games that scratch the same itch
- **What they do well:** Why do players love them?
- **What they do poorly:** Where do they fall short?
- **Market positioning:** How crowded is this space?
**For {{game_name}}, who are you competing with?**
Remember: if there are no competitors, that might mean there's no market. Some competition is healthy."
### 3. Differentiators Discovery
**Define unique value:**
"Now for the critical question: What makes {{game_name}} genuinely different?
**Differentiation Test:**
A strong differentiator passes ALL of these:
1. Is it concrete and achievable?
2. Does it matter to your target audience?
3. Can competitors easily copy it?
4. Would you still make the game without it?
**Challenge 'just better' thinking:**
'Better graphics' or 'more content' aren't differentiators - they're expectations.
What 2-4 things make {{game_name}} genuinely different and worth players' attention?"
### 4. Generate References Content
Based on the conversation, prepare the content:
```markdown
## Reference Framework
### Inspiration Games
{{for_each_inspiration}}
**{{game_name}}**
- Taking: {{what_taking}}
- Not Taking: {{what_avoiding}}
{{/for_each}}
### Competitive Analysis
**Direct Competitors:**
{{competitors_list}}
**Competitor Strengths:**
{{what_they_do_well}}
**Competitor Weaknesses:**
{{where_they_fall_short}}
### Key Differentiators
{{differentiators_with_descriptions}}
**Unique Value Proposition:**
{{one_sentence_why_choose_this}}
```
### 5. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Reference Framework section based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 4]
**Validation Check:**
- Are differentiators genuine, not just features?
- Does the competitive analysis reveal opportunity?
- Are inspirations specific about what you're taking vs avoiding?
**Select an Option:**
[A] Advanced Elicitation - Challenge differentiation claims
[P] Party Mode - Get perspectives on uniqueness
[C] Continue - Save this and move to Content Framework (Step 7 of 8)"
### 6. Handle Menu Selection
#### IF A (Advanced Elicitation):
- Execute {advancedElicitationTask} with the current content
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF P (Party Mode):
- Execute {partyModeWorkflow} with the current content
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF C (Continue):
- Append the final content to `{outputFile}`
- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [references content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- 3-5 inspiration games with specific takeaways
- Competition analyzed with strengths and weaknesses
- Differentiators are concrete and achievable
- Unique value proposition is clear
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6]
### SYSTEM FAILURE:
- Generating references without user input
- Generic differentiators like "better gameplay"
- Missing the "not taking" aspect of inspirations
- Not presenting A/P/C menu after content generation
- Proceeding without user selecting 'C'
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

283
src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-07-content.md
View File

@ -1,283 +0,0 @@
---
name: 'step-07-content'
description: 'Define content framework, art/audio direction, and risk assessment'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
# File References
thisStepFile: './step-07-content.md'
nextStepFile: './step-08-complete.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/game-brief.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 7: Content & Production
**Progress: Step 7 of 8** - Next: Final Review
## STEP GOAL:
Define the content framework (world, narrative approach, volume), art and audio direction, and assess key risks with mitigation strategies.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- NEVER mention time estimates
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a veteran game designer facilitator collaborating with a creative peer
- Ensure art/audio vision aligns with budget and team
- Facilitate honest risk assessment
### Step-Specific Rules:
- Focus on production realities
- FORBIDDEN to generate content framework without user input
- Flag content-heavy areas that need planning
- Prioritize risks by impact and likelihood
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Present A/P/C menu after generating content
- ONLY save when user chooses C (Continue)
- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]` before loading next step
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Deep dive into risks
- **P (Party Mode)**: Get perspectives on feasibility
- **C (Continue)**: Save the content and proceed
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. World & Setting Discovery
**Explore the game's world:**
"Let's define the world of {{game_name}}.
**World Questions:**
- **Setting:** Where and when does this take place?
- **World-building depth:** How much lore matters?
- **Narrative importance:** Story-driven or story-light?
- **Atmosphere:** What mood should the world evoke?
Describe the world and setting for {{game_name}}."
### 2. Narrative Approach Discovery
**Define storytelling strategy:**
"How will {{game_name}} handle narrative?
**Narrative Approaches:**
| Approach | Examples |
| ----------------- | ----------------------------------------- |
| **Story-Driven** | Linear narrative with cutscenes, dialogue |
| **Environmental** | Story told through world, items, visuals |
| **Emergent** | Player creates their own stories |
| **Minimal** | Pure gameplay, little to no story |
**Questions:**
- How is story delivered? (cutscenes, dialogue, text, environmental)
- Is there a dedicated narrative workflow needed later?
What's the narrative approach for {{game_name}}?"
### 3. Art & Audio Direction Discovery
**Establish aesthetic vision:**
"Let's define the look and sound of {{game_name}}.
**Visual Style:**
- Art style (pixel, low-poly, stylized 3D, realistic)
- Color palette and mood
- Reference games or images
- Animation complexity
**Audio Style:**
- Music genre and mood
- Sound effect approach
- Voice acting scope (none, grunts, partial, full)
**Production Reality:**
- What can be created in-house?
- What needs outsourcing?
- Are asset store/AI tools acceptable?
Describe the art and audio direction for {{game_name}}."
### 4. Risk Assessment Discovery
**Facilitate honest risk evaluation:**
"Now let's honestly assess the risks for {{game_name}}.
**Risk Categories:**
| Category | Questions |
| ------------- | --------------------------------------- |
| **Technical** | Unproven systems? Performance concerns? |
| **Market** | Saturated genre? Discoverability? |
| **Scope** | Too ambitious? Feature creep? |
| **Team** | Skill gaps? Availability? |
| **Financial** | Runway? Unexpected costs? |
**For each major risk:**
- What could go wrong?
- How likely is it?
- What's the impact if it happens?
- How can we mitigate it?
What are the key risks for {{game_name}}?"
### 5. Generate Content & Production Content
Based on the conversation, prepare the content:
```markdown
## Content Framework
### World and Setting
{{world_setting_description}}
### Narrative Approach
{{narrative_approach}}
**Story Delivery:** {{how_story_delivered}}
### Content Volume
{{content_volume_estimates}}
---
## Art and Audio Direction
### Visual Style
{{visual_style_description}}
**References:** {{reference_games_or_images}}
### Audio Style
{{audio_direction}}
### Production Approach
{{production_strategy}}
---
## Risk Assessment
### Key Risks
{{prioritized_risk_list}}
### Technical Challenges
{{technical_risks}}
### Market Risks
{{market_risks}}
### Mitigation Strategies
{{mitigation_strategies}}
```
### 6. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Content & Production section based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 5]
**Validation Check:**
- Does art/audio align with budget and team?
- Have we identified the biggest risks?
- Are mitigations actionable?
**Select an Option:**
[A] Advanced Elicitation - Deep dive into risks
[P] Party Mode - Get perspectives on feasibility
[C] Continue - Save this and move to Final Review (Step 8 of 8)"
### 7. Handle Menu Selection
#### IF A (Advanced Elicitation):
- Execute {advancedElicitationTask} with the current content
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF P (Party Mode):
- Execute {partyModeWorkflow} with the current content
- Ask user: "Accept these changes? (y/n)"
- If yes: Update content, return to A/P/C menu
- If no: Keep original, return to A/P/C menu
#### IF C (Continue):
- Append the final content to `{outputFile}`
- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- World and setting clearly defined
- Narrative approach documented
- Art/audio direction established
- Risks prioritized with mitigations
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7]
### SYSTEM FAILURE:
- Generating content without user input
- Art/audio vision misaligned with resources
- Missing major risk categories
- Not presenting A/P/C menu after content generation
- Proceeding without user selecting 'C'
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

297
src/modules/bmgd/workflows/1-preproduction/game-brief/steps/step-08-complete.md
View File

@ -1,297 +0,0 @@
---
name: 'step-08-complete'
description: 'Define success criteria and complete the game brief with handoff guidance'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief'
# File References
thisStepFile: './step-08-complete.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/game-brief.md'
# Workflow References
gddWorkflow: '{project-root}/_bmad/bmgd/workflows/2-design/gdd/workflow.yaml'
---
# Step 8: Success & Handoff
**Progress: Step 8 of 8** - Game Brief Complete!
## STEP GOAL:
Define MVP scope, success metrics, immediate next steps, and provide clear handoff guidance for proceeding to GDD creation.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- YOU ARE A FACILITATOR, not a content generator
- NEVER mention time estimates
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a veteran game designer facilitator collaborating with a creative peer
- This is the final step - ensure completeness
- Provide actionable next steps
### Step-Specific Rules:
- Focus on measurable success criteria
- Push for specificity - challenge vague aspirations
- Clearly distinguish MVP from full release
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Generate final sections
- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]`
- Present completion summary and next steps
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. MVP Definition Discovery
**Define minimum viable product:**
"Let's define the MVP (Minimum Playable Version) for {{game_name}}.
**MVP is the absolute minimum where:**
- Core gameplay loop is fun and complete
- Only essential content is included
- It could stand alone as a playable experience
**Questions:**
- What features are absolutely required?
- What content is the minimum to prove the concept?
- What can be cut and added later?
What's the MVP for {{game_name}}?"
### 2. Success Metrics Discovery
**Define measurable success:**
"Let's define how you'll measure success for {{game_name}}.
**Metric Categories:**
| Category | Examples |
| ---------------------- | --------------------------------------- |
| **Player Acquisition** | Wishlists, downloads, sales |
| **Engagement** | Session length, retention, completion |
| **Quality** | Review scores, bug reports |
| **Community** | Discord members, streamers, fan content |
| **Financial** | Revenue, ROI, sustainability |
**For each metric, answer:** How will you measure that?
What success metrics matter for {{game_name}}?"
### 3. Immediate Actions Discovery
**Identify next steps:**
"What should happen immediately after this brief is complete?
**Common Next Actions:**
- Prototype core mechanic
- Create art style test
- Validate technical feasibility
- Build vertical slice
- Playtest with target audience
- Proceed to GDD workflow
**Open Questions:**
- What design questions are still unresolved?
- What assumptions need validation?
- What blockers must be resolved?
What are the immediate next steps for {{game_name}}?"
### 4. Generate Executive Summary
**Create summary section:**
Based on all previous sections, synthesize an executive summary:
```markdown
## Executive Summary
{{game_name}} is {{core_concept}}.
**Target Audience:** {{primary_audience_summary}}
**Core Pillars:** {{pillars_list}}
**Key Differentiators:** {{top_differentiators}}
**Platform:** {{primary_platform}}
**Success Vision:** {{what_success_looks_like}}
```
### 5. Generate Success & Next Steps Content
Based on the conversation, prepare the content:
```markdown
## Success Criteria
### MVP Definition
{{mvp_scope}}
### Success Metrics
{{metrics_with_targets}}
### Launch Goals
{{launch_targets}}
---
## Next Steps
### Immediate Actions
{{prioritized_action_list}}
### Research Needs
{{research_requirements}}
### Open Questions
{{unresolved_questions}}
```
### 6. Present Completion Summary
"**Game Brief Complete!**
{{user_name}}, the Game Brief for **{{game_name}}** is now complete!
**Brief Summary:**
- **Core Concept:** {{core_concept}}
- **Target Audience:** {{primary_audience}}
- **Pillars:** {{pillars}}
- **Platform:** {{platform}}
**Sections Completed:**
1. Game Vision
2. Target Market
3. Game Fundamentals
4. Scope & Constraints
5. Reference Framework
6. Content & Production
7. Success Criteria
8. Next Steps
**Document saved to:** `{outputFile}`
Do you want to review or adjust anything before we finalize?"
### 7. Present Next Steps Menu
**After user confirms completion:**
"**Recommended Next Steps for {{game_name}}:**
1. **Create GDD** - Transform this brief into a detailed Game Design Document
- Command: `create-gdd` (Game Designer agent)
- Input: This game brief
- Output: Comprehensive GDD
2. **Prototype Core Mechanic** - Validate gameplay before full production
3. **Art Style Test** - Validate visual direction
4. **Market Validation** - Test interest with target audience
**Which would you like to do next?**
1. Start GDD workflow
2. Review the completed brief
3. Exit workflow"
### 8. Handle User Selection
Based on user choice:
**If 1 (Start GDD):**
- Update frontmatter with final `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]`
- Provide handoff guidance for GDD workflow
**If 2 (Review):**
- Present full document summary
- Return to next steps menu
**If 3 (Exit):**
- Update frontmatter with final stepsCompleted
- Confirm brief is saved
- Exit workflow gracefully
## CRITICAL STEP COMPLETION NOTE
This is the final step. Ensure:
- Executive summary is generated
- All content is saved to game-brief.md
- Frontmatter shows all 8 steps completed
- User has clear actionable next steps
- Handoff to GDD workflow is smooth
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- MVP clearly scoped
- Success metrics are measurable
- Immediate actions are actionable
- Executive summary synthesizes the brief
- Document is complete and saved
- Clear next steps provided
- Frontmatter updated with all steps completed
### SYSTEM FAILURE:
- Missing MVP definition
- Vague success metrics that can't be measured
- No clear next steps
- Frontmatter not updated to show completion
- User left without actionable guidance
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
---
## Game Brief Workflow Complete
The Game Brief workflow transforms a game idea into a validated vision through 8 collaborative steps:
1. **Initialize** - Set up workflow and discover input documents
2. **Vision** - Capture core concept, pitch, and vision statement
3. **Market** - Define target audience and market context
4. **Fundamentals** - Establish pillars, mechanics, and experience goals
5. **Scope** - Set realistic constraints and resources
6. **References** - Identify inspirations and differentiators
7. **Content** - Define world, art/audio, and assess risks
8. **Complete** - Set success criteria and provide handoff
This step-file architecture ensures consistent, thorough game brief creation with user collaboration at every step.

205
src/modules/bmgd/workflows/1-preproduction/game-brief/templates/game-brief-template.md
View File

@ -1,205 +0,0 @@
# Game Brief: {{game_name}}
**Date:** {{date}}
**Author:** {{user_name}}
**Status:** Draft for GDD Development
---
## Executive Summary
{{executive_summary}}
---
## Game Vision
### Core Concept
{{core_concept}}
### Elevator Pitch
{{elevator_pitch}}
### Vision Statement
{{vision_statement}}
---
## Target Market
### Primary Audience
{{primary_audience}}
### Secondary Audience
{{secondary_audience}}
### Market Context
{{market_context}}
---
## Game Fundamentals
### Core Gameplay Pillars
{{core_gameplay_pillars}}
### Primary Mechanics
{{primary_mechanics}}
### Player Experience Goals
{{player_experience_goals}}
---
## Scope and Constraints
### Target Platforms
{{target_platforms}}
### Development Timeline
{{development_timeline}}
### Budget Considerations
{{budget_considerations}}
### Team Resources
{{team_resources}}
### Technical Constraints
{{technical_constraints}}
---
## Reference Framework
### Inspiration Games
{{inspiration_games}}
### Competitive Analysis
{{competitive_analysis}}
### Key Differentiators
{{key_differentiators}}
---
## Content Framework
### World and Setting
{{world_setting}}
### Narrative Approach
{{narrative_approach}}
### Content Volume
{{content_volume}}
---
## Art and Audio Direction
### Visual Style
{{visual_style}}
### Audio Style
{{audio_style}}
### Production Approach
{{production_approach}}
---
## Risk Assessment
### Key Risks
{{key_risks}}
### Technical Challenges
{{technical_challenges}}
### Market Risks
{{market_risks}}
### Mitigation Strategies
{{mitigation_strategies}}
---
## Success Criteria
### MVP Definition
{{mvp_definition}}
### Success Metrics
{{success_metrics}}
### Launch Goals
{{launch_goals}}
---
## Next Steps
### Immediate Actions
{{immediate_actions}}
### Research Needs
{{research_needs}}
### Open Questions
{{open_questions}}
---
## Appendices
### A. Research Summary
{{research_summary}}
### B. Stakeholder Input
{{stakeholder_input}}
### C. References
{{references}}
---
_This Game Brief serves as the foundational input for Game Design Document (GDD) creation._
_Next Steps: Use the `workflow gdd` command to create detailed game design documentation._

63
src/modules/bmgd/workflows/1-preproduction/game-brief/workflow.md
View File

@ -1,63 +0,0 @@
---
name: create-game-brief
description: Creates a comprehensive Game Brief through collaborative step-by-step discovery to capture game vision before detailed design.
main_config: '{project-root}/_bmad/bmgd/config.yaml'
web_bundle: true
---
# Game Brief Workflow
**Goal:** Create comprehensive Game Briefs through collaborative step-by-step discovery to capture and validate the core game vision before detailed design work.
**Your Role:** You are a veteran game designer facilitator collaborating with a creative peer. This is a partnership, not a client-vendor relationship. You bring structured game design thinking and market awareness, while the user brings their game vision and creative ideas. Work together as equals. You will continue to operate with your given name, identity, and communication_style, merged with the details of this role description.
---
## WORKFLOW ARCHITECTURE
This uses **step-file architecture** for disciplined execution:
### Core Principles
- **Micro-file Design**: Each step is a self contained instruction file that is a part of an overall workflow that must be followed exactly
- **Just-In-Time Loading**: Only the current step file is in memory - never load future step files until told to do so
- **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array when a workflow produces a document
- **Append-Only Building**: Build documents by appending content as directed to the output file
### Step Processing Rules
1. **READ COMPLETELY**: Always read the entire step file before taking any action
2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
6. **LOAD NEXT**: When directed, load, read entire file, then execute the next step file
### Critical Rules (NO EXCEPTIONS)
- NEVER load multiple step files simultaneously
- ALWAYS read entire step file before execution
- NEVER skip steps or optimize the sequence
- ALWAYS update frontmatter of output files when writing the final output for a specific step
- ALWAYS follow the exact instructions in the step file
- ALWAYS halt at menus and wait for user input
- NEVER create mental todo lists from future steps
- NEVER mention time estimates
---
## INITIALIZATION SEQUENCE
### 1. Configuration Loading
Load and read full config from {main_config} and resolve:
- `project_name`, `output_folder`, `user_name`
- `communication_language`, `document_output_language`, `user_skill_level`
- `date` as system-generated current datetime
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### 2. First Step EXECUTION
Load, read the full file and then execute `steps/step-01-init.md` to begin the workflow.

67
src/modules/bmgd/workflows/1-preproduction/game-brief/workflow.yaml
View File

@ -1,67 +0,0 @@
# Game Brief - Interactive Workflow Configuration
name: game-brief
description: "Interactive game brief creation workflow that guides users through defining their game vision with multiple input sources and conversational collaboration"
author: "BMad"
# Critical variables from config
config_source: "{project-root}/_bmad/bmgd/config.yaml"
output_folder: "{config_source}:output_folder"
user_name: "{config_source}:user_name"
communication_language: "{config_source}:communication_language"
document_output_language: "{config_source}:document_output_language"
game_dev_experience: "{config_source}:game_dev_experience"
date: system-generated
# Workflow components - Step-file architecture
installed_path: "{project-root}/_bmad/bmgd/workflows/1-preproduction/game-brief"
instructions: "{installed_path}/workflow.md"
template: "{installed_path}/templates/game-brief-template.md"
validation: "{installed_path}/checklist.md"
# Smart input file references - handles brainstorming/research docs
input_file_patterns:
brainstorm:
description: "Brainstorming or ideation documents (optional)"
whole: "{output_folder}/*brainstorm*.md"
sharded: "{output_folder}/*brainstorm*/index.md"
load_strategy: "FULL_LOAD"
research:
description: "Market or domain research (optional)"
whole: "{output_folder}/*research*.md"
sharded: "{output_folder}/*research*/index.md"
load_strategy: "FULL_LOAD"
inspiration:
description: "Inspiration or reference documents (optional)"
whole: "{output_folder}/*inspiration*.md"
sharded: "{output_folder}/*inspiration*/index.md"
load_strategy: "FULL_LOAD"
# Output configuration
default_output_file: "{output_folder}/game-brief.md"
standalone: true
web_bundle:
name: "game-brief"
description: "Interactive game brief creation workflow that guides users through defining their game vision with multiple input sources and conversational collaboration"
author: "BMad"
instructions: "_bmad/bmgd/workflows/1-preproduction/game-brief/workflow.md"
web_bundle_files:
# Main workflow file
- "_bmad/bmgd/workflows/1-preproduction/game-brief/workflow.md"
# Step files
- "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-01-init.md"
- "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-01b-continue.md"
- "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-02-vision.md"
- "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-03-market.md"
- "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-04-fundamentals.md"
- "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-05-scope.md"
- "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-06-references.md"
- "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-07-content.md"
- "_bmad/bmgd/workflows/1-preproduction/game-brief/steps/step-08-complete.md"
# Template
- "_bmad/bmgd/workflows/1-preproduction/game-brief/templates/game-brief-template.md"
# Validation checklist
- "_bmad/bmgd/workflows/1-preproduction/game-brief/checklist.md"

148
src/modules/bmgd/workflows/2-design/gdd/checklist.md
View File

@ -1,148 +0,0 @@
# GDD Workflow Validation Checklist
**Purpose**: Validate GDD workflow outputs are complete, playable, and ready for solutioning.
**Scope**: All game project levels (0-4)
**Expected Outputs**: GDD.md, epics.md
---
## 1. Output Files Exist
- [ ] GDD.md created in output folder
- [ ] epics.md created in output folder (separate file)
- [ ] bmm-workflow-status.md updated
- [ ] No unfilled {{template_variables}}
---
## 2. Core Gameplay Definition (CRITICAL)
### Game Pillars
- [ ] **2-4 game pillars defined** (fundamental gameplay elements)
- [ ] Each pillar is game-defining (not superficial)
- [ ] Pillars are distinct (don't overlap)
### Core Gameplay Loop
- [ ] **Complete cycle documented** (what player does repeatedly)
- [ ] Loop shows: player action → outcome → reward → motivation to repeat
- [ ] Loop sounds compelling and repeatable
### Win/Loss Conditions
- [ ] Victory conditions clearly defined
- [ ] Failure conditions defined (or N/A for sandbox games)
- [ ] Conditions are testable
---
## 3. Game Mechanics and Systems
### Mechanics
- [ ] Primary mechanics described in detail
- [ ] Mechanics support the game pillars
- [ ] Player interaction with mechanics is clear
### Progression
- [ ] Player progression system defined (skill/power/unlock/narrative)
- [ ] Difficulty curve explained
- [ ] Progression feels rewarding
### Platform and Controls
- [ ] Target platforms specified
- [ ] Control scheme appropriate for platforms
- [ ] Input method clear (keyboard/gamepad/touch/etc.)
---
## 4. Story Quality (If epics.md exists)
### Epic Structure
- [ ] Epics represent deliverable game features
- [ ] Epic sequence makes sense for game development
- [ ] Stories show implementation path
### Story Sequencing (If stories present)
- [ ] **Vertical slices**: Each story delivers playable functionality
- [ ] **Sequential ordering**: Stories build progressively
- [ ] **No forward dependencies**: Each story builds on previous work only
- [ ] Stories result in testable game features
---
## 5. Technical Specifications
### Performance and Platform
- [ ] Performance requirements specified (frame rate, resolution, etc.)
- [ ] Platform-specific considerations noted
- [ ] Asset requirements estimated
### Production Scope
- [ ] Art requirements realistic for project scale
- [ ] Audio requirements documented
- [ ] Scope matches project level and resources
---
## 6. Narrative Integration (If Applicable)
**If narrative-design.md was generated:**
- [ ] Narrative aligns with GDD game design
- [ ] Story supports gameplay (not fighting it)
- [ ] Tone consistent across GDD and narrative docs
---
## 7. Consistency
- [ ] Epic titles match between GDD.md and epics.md
- [ ] Game type identified and appropriate
- [ ] Terminology consistent throughout
- [ ] No contradictions between sections
---
## 8. Readiness for Solutioning
- [ ] Sufficient detail for engine/platform selection
- [ ] Game systems defined enough for technical architecture
- [ ] Clear what needs to be built
- [ ] Playable vision (reader can envision playing the game)
---
## 9. Critical Failures (Auto-Fail)
- [ ] ❌ **No core gameplay loop** (can't be a game without this)
- [ ] ❌ **No game pillars** (game-defining elements missing)
- [ ] ❌ **No mechanics** (what does player actually DO?)
- [ ] ❌ **No epics.md file** (implementation roadmap required)
- [ ] ❌ **Engine/tech in GDD** (should defer to solutioning workflow)
---
## Validation Notes
**Document any findings:**
- Game concept strength: [Compelling / Interesting / Unclear / Weak]
- Strengths:
- Issues to address:
- Recommended actions:
**Ready for solutioning?** [Yes / No - explain]
---
_Adapt based on game type and narrative complexity. Core gameplay must always be solid._

25
src/modules/bmgd/workflows/2-design/gdd/game-types.csv
View File

@ -1,25 +0,0 @@
id,name,description,genre_tags,fragment_file
action-platformer,Action Platformer,"Side-scrolling or 3D platforming with combat mechanics","action,platformer,combat,movement",action-platformer.md
puzzle,Puzzle,"Logic-based challenges and problem-solving","puzzle,logic,cerebral",puzzle.md
rpg,RPG,"Character progression, stats, inventory, quests","rpg,stats,inventory,quests,narrative",rpg.md
strategy,Strategy,"Resource management, tactical decisions, long-term planning","strategy,tactics,resources,planning",strategy.md
shooter,Shooter,"Projectile combat, aiming mechanics, arena/level design","shooter,combat,aiming,fps,tps",shooter.md
adventure,Adventure,"Story-driven exploration and narrative","adventure,narrative,exploration,story",adventure.md
simulation,Simulation,"Realistic systems, management, building","simulation,management,sandbox,systems",simulation.md
roguelike,Roguelike,"Procedural generation, permadeath, run-based progression","roguelike,procedural,permadeath,runs",roguelike.md
moba,MOBA,"Multiplayer team battles, hero/champion selection, lanes","moba,multiplayer,pvp,heroes,lanes",moba.md
fighting,Fighting,"1v1 combat, combos, frame data, competitive","fighting,combat,competitive,combos,pvp",fighting.md
racing,Racing,"Vehicle control, tracks, speed, lap times","racing,vehicles,tracks,speed",racing.md
sports,Sports,"Team-based or individual sports simulation","sports,teams,realistic,physics",sports.md
survival,Survival,"Resource gathering, crafting, persistent threats","survival,crafting,resources,danger",survival.md
horror,Horror,"Atmosphere, tension, limited resources, fear mechanics","horror,atmosphere,tension,fear",horror.md
idle-incremental,Idle/Incremental,"Passive progression, upgrades, automation","idle,incremental,automation,progression",idle-incremental.md
card-game,Card Game,"Deck building, card mechanics, turn-based strategy","card,deck-building,strategy,turns",card-game.md
tower-defense,Tower Defense,"Wave-based defense, tower placement, resource management","tower-defense,waves,placement,strategy",tower-defense.md
metroidvania,Metroidvania,"Interconnected world, ability gating, exploration","metroidvania,exploration,abilities,interconnected",metroidvania.md
visual-novel,Visual Novel,"Narrative choices, branching story, dialogue","visual-novel,narrative,choices,story",visual-novel.md
rhythm,Rhythm,"Music synchronization, timing-based gameplay","rhythm,music,timing,beats",rhythm.md
turn-based-tactics,Turn-Based Tactics,"Grid-based movement, turn order, positioning","tactics,turn-based,grid,positioning",turn-based-tactics.md
sandbox,Sandbox,"Creative freedom, building, minimal objectives","sandbox,creative,building,freedom",sandbox.md
text-based,Text-Based,"Text input/output, parser or choice-based","text,parser,interactive-fiction,mud",text-based.md
party-game,Party Game,"Local multiplayer, minigames, casual fun","party,multiplayer,minigames,casual",party-game.md
1 id name description genre_tags fragment_file
2 action-platformer Action Platformer Side-scrolling or 3D platforming with combat mechanics action,platformer,combat,movement action-platformer.md
3 puzzle Puzzle Logic-based challenges and problem-solving puzzle,logic,cerebral puzzle.md
4 rpg RPG Character progression, stats, inventory, quests rpg,stats,inventory,quests,narrative rpg.md
5 strategy Strategy Resource management, tactical decisions, long-term planning strategy,tactics,resources,planning strategy.md
6 shooter Shooter Projectile combat, aiming mechanics, arena/level design shooter,combat,aiming,fps,tps shooter.md
7 adventure Adventure Story-driven exploration and narrative adventure,narrative,exploration,story adventure.md
8 simulation Simulation Realistic systems, management, building simulation,management,sandbox,systems simulation.md
9 roguelike Roguelike Procedural generation, permadeath, run-based progression roguelike,procedural,permadeath,runs roguelike.md
10 moba MOBA Multiplayer team battles, hero/champion selection, lanes moba,multiplayer,pvp,heroes,lanes moba.md
11 fighting Fighting 1v1 combat, combos, frame data, competitive fighting,combat,competitive,combos,pvp fighting.md
12 racing Racing Vehicle control, tracks, speed, lap times racing,vehicles,tracks,speed racing.md
13 sports Sports Team-based or individual sports simulation sports,teams,realistic,physics sports.md
14 survival Survival Resource gathering, crafting, persistent threats survival,crafting,resources,danger survival.md
15 horror Horror Atmosphere, tension, limited resources, fear mechanics horror,atmosphere,tension,fear horror.md
16 idle-incremental Idle/Incremental Passive progression, upgrades, automation idle,incremental,automation,progression idle-incremental.md
17 card-game Card Game Deck building, card mechanics, turn-based strategy card,deck-building,strategy,turns card-game.md
18 tower-defense Tower Defense Wave-based defense, tower placement, resource management tower-defense,waves,placement,strategy tower-defense.md
19 metroidvania Metroidvania Interconnected world, ability gating, exploration metroidvania,exploration,abilities,interconnected metroidvania.md
20 visual-novel Visual Novel Narrative choices, branching story, dialogue visual-novel,narrative,choices,story visual-novel.md
21 rhythm Rhythm Music synchronization, timing-based gameplay rhythm,music,timing,beats rhythm.md
22 turn-based-tactics Turn-Based Tactics Grid-based movement, turn order, positioning tactics,turn-based,grid,positioning turn-based-tactics.md
23 sandbox Sandbox Creative freedom, building, minimal objectives sandbox,creative,building,freedom sandbox.md
24 text-based Text-Based Text input/output, parser or choice-based text,parser,interactive-fiction,mud text-based.md
25 party-game Party Game Local multiplayer, minigames, casual fun party,multiplayer,minigames,casual party-game.md

45
src/modules/bmgd/workflows/2-design/gdd/game-types/action-platformer.md
View File

@ -1,45 +0,0 @@
## Action Platformer Specific Elements
### Movement System
{{movement_mechanics}}
**Core movement abilities:**
- Jump mechanics (height, air control, coyote time)
- Running/walking speed
- Special movement (dash, wall-jump, double-jump, etc.)
### Combat System
{{combat_system}}
**Combat mechanics:**
- Attack types (melee, ranged, special)
- Combo system
- Enemy AI behavior patterns
- Hit feedback and impact
### Level Design Patterns
{{level_design_patterns}}
**Level structure:**
- Platforming challenges
- Combat arenas
- Secret areas and collectibles
- Checkpoint placement
- Difficulty spikes and pacing
### Player Abilities and Unlocks
{{player_abilities}}
**Ability progression:**
- Starting abilities
- Unlockable abilities
- Ability synergies
- Upgrade paths

84
src/modules/bmgd/workflows/2-design/gdd/game-types/adventure.md
View File

@ -1,84 +0,0 @@
## Adventure Specific Elements
<narrative-workflow-recommended>
This game type is **narrative-heavy**. Consider running the Narrative Design workflow after completing the GDD to create:
- Detailed story structure and beats
- Character profiles and arcs
- World lore and history
- Dialogue framework
- Environmental storytelling
</narrative-workflow-recommended>
### Exploration Mechanics
{{exploration_mechanics}}
**Exploration design:**
- World structure (linear, open, hub-based, interconnected)
- Movement and traversal
- Observation and inspection mechanics
- Discovery rewards (story reveals, items, secrets)
- Pacing of exploration vs. story
### Story Integration
{{story_integration}}
**Narrative gameplay:**
- Story delivery methods (cutscenes, in-game, environmental)
- Player agency in story (linear, branching, player-driven)
- Story pacing (acts, beats, tension/release)
- Character introduction and development
- Climax and resolution structure
**Note:** Detailed story elements (plot, characters, lore) belong in the Narrative Design Document.
### Puzzle Systems
{{puzzle_systems}}
**Puzzle integration:**
- Puzzle types (inventory, logic, environmental, dialogue)
- Puzzle difficulty curve
- Hint systems
- Puzzle-story connection (narrative purpose)
- Optional vs. required puzzles
### Character Interaction
{{character_interaction}}
**NPC systems:**
- Dialogue system (branching, linear, choice-based)
- Character relationships
- NPC schedules/behaviors
- Companion mechanics (if applicable)
- Memorable character moments
### Inventory and Items
{{inventory_items}}
**Item systems:**
- Inventory scope (key items, collectibles, consumables)
- Item examination/description
- Combination/crafting (if applicable)
- Story-critical items vs. optional items
- Item-based progression gates
### Environmental Storytelling
{{environmental_storytelling}}
**World narrative:**
- Visual storytelling techniques
- Audio atmosphere
- Readable documents (journals, notes, signs)
- Environmental clues
- Show vs. tell balance

76
src/modules/bmgd/workflows/2-design/gdd/game-types/card-game.md
View File

@ -1,76 +0,0 @@
## Card Game Specific Elements
### Card Types and Effects
{{card_types}}
**Card design:**
- Card categories (creatures, spells, enchantments, etc.)
- Card rarity tiers (common, rare, epic, legendary)
- Card attributes (cost, power, health, etc.)
- Effect types (damage, healing, draw, control, etc.)
- Keywords and abilities
- Card synergies
### Deck Building
{{deck_building}}
**Deck construction:**
- Deck size limits (minimum, maximum)
- Card quantity limits (e.g., max 2 copies)
- Class/faction restrictions
- Deck archetypes (aggro, control, combo, midrange)
- Sideboard mechanics (if applicable)
- Pre-built vs. custom decks
### Mana/Resource System
{{mana_resources}}
**Resource mechanics:**
- Mana generation (per turn, from cards, etc.)
- Mana curve design
- Resource types (colored mana, energy, etc.)
- Ramp mechanics
- Resource denial strategies
### Turn Structure
{{turn_structure}}
**Game flow:**
- Turn phases (draw, main, combat, end)
- Priority and response windows
- Simultaneous vs. alternating turns
- Time limits per turn
- Match length targets
### Card Collection and Progression
{{collection_progression}}
**Player progression:**
- Card acquisition (packs, rewards, crafting)
- Deck unlocks
- Currency systems (gold, dust, wildcards)
- Free-to-play balance
- Collection completion incentives
### Game Modes
{{game_modes}}
**Mode variety:**
- Ranked ladder
- Draft/Arena modes
- Campaign/story mode
- Casual/unranked
- Special event modes
- Tournament formats

89
src/modules/bmgd/workflows/2-design/gdd/game-types/fighting.md
View File

@ -1,89 +0,0 @@
## Fighting Game Specific Elements
### Character Roster
{{character_roster}}
**Fighter design:**
- Roster size (launch + planned DLC)
- Character archetypes (rushdown, zoner, grappler, all-rounder, etc.)
- Move list diversity
- Complexity tiers (beginner vs. expert characters)
- Balance philosophy (everyone viable vs. tier system)
### Move Lists and Frame Data
{{moves_frame_data}}
**Combat mechanics:**
- Normal moves (light, medium, heavy)
- Special moves (quarter-circle, charge, etc.)
- Super/ultimate moves
- Frame data (startup, active, recovery, advantage)
- Hit/hurt boxes
- Command inputs vs. simplified inputs
### Combo System
{{combo_system}}
**Combo design:**
- Combo structure (links, cancels, chains)
- Juggle system
- Wall/ground bounces
- Combo scaling
- Reset opportunities
- Optimal vs. practical combos
### Defensive Mechanics
{{defensive_mechanics}}
**Defense options:**
- Blocking (high, low, crossup protection)
- Dodging/rolling/backdashing
- Parries/counters
- Pushblock/advancing guard
- Invincibility frames
- Escape options (burst, breaker, etc.)
### Stage Design
{{stage_design}}
**Arena design:**
- Stage size and boundaries
- Wall mechanics (wall combos, wall break)
- Interactive elements
- Ring-out mechanics (if applicable)
- Visual clarity vs. aesthetics
### Single Player Modes
{{single_player}}
**Offline content:**
- Arcade/story mode
- Training mode features
- Mission/challenge mode
- Boss fights
- Unlockables
### Competitive Features
{{competitive_features}}
**Tournament-ready:**
- Ranked matchmaking
- Lobby systems
- Replay features
- Frame delay/rollback netcode
- Spectator mode
- Tournament mode

86
src/modules/bmgd/workflows/2-design/gdd/game-types/horror.md
View File

@ -1,86 +0,0 @@
## Horror Game Specific Elements
<narrative-workflow-recommended>
This game type is **narrative-important**. Consider running the Narrative Design workflow after completing the GDD to create:
- Detailed story structure and scares
- Character backstories and motivations
- World lore and mythology
- Environmental storytelling
- Tension pacing and narrative beats
</narrative-workflow-recommended>
### Atmosphere and Tension Building
{{atmosphere}}
**Horror atmosphere:**
- Visual design (lighting, shadows, color palette)
- Audio design (soundscape, silence, music cues)
- Environmental storytelling
- Pacing of tension and release
- Jump scares vs. psychological horror
- Safe zones vs. danger zones
### Fear Mechanics
{{fear_mechanics}}
**Core horror systems:**
- Visibility/darkness mechanics
- Limited resources (ammo, health, light)
- Vulnerability (combat avoidance, hiding)
- Sanity/fear meter (if applicable)
- Pursuer/stalker mechanics
- Detection systems (line of sight, sound)
### Enemy/Threat Design
{{enemy_threat}}
**Threat systems:**
- Enemy types (stalker, environmental, psychological)
- Enemy behavior (patrol, hunt, ambush)
- Telegraphing and tells
- Invincible vs. killable enemies
- Boss encounters
- Encounter frequency and pacing
### Resource Scarcity
{{resource_scarcity}}
**Limited resources:**
- Ammo/weapon durability
- Health items
- Light sources (batteries, fuel)
- Save points (if limited)
- Inventory constraints
- Risk vs. reward of exploration
### Safe Zones and Respite
{{safe_zones}}
**Tension management:**
- Safe room design
- Save point placement
- Temporary refuge mechanics
- Calm before storm pacing
- Item management areas
### Puzzle Integration
{{puzzles}}
**Environmental puzzles:**
- Puzzle types (locks, codes, environmental)
- Difficulty balance (accessibility vs. challenge)
- Hint systems
- Puzzle-tension balance
- Narrative purpose of puzzles

78
src/modules/bmgd/workflows/2-design/gdd/game-types/idle-incremental.md
View File

@ -1,78 +0,0 @@
## Idle/Incremental Game Specific Elements
### Core Click/Interaction
{{core_interaction}}
**Primary mechanic:**
- Click action (what happens on click)
- Click value progression
- Auto-click mechanics
- Combo/streak systems (if applicable)
- Satisfaction and feedback (visual, audio)
### Upgrade Trees
{{upgrade_trees}}
**Upgrade systems:**
- Upgrade categories (click power, auto-generation, multipliers)
- Upgrade costs and scaling
- Unlock conditions
- Synergies between upgrades
- Upgrade branches and choices
- Meta-upgrades (affect future runs)
### Automation Systems
{{automation}}
**Passive mechanics:**
- Auto-clicker unlocks
- Manager/worker systems
- Multiplier stacking
- Offline progression
- Automation tiers
- Balance between active and idle play
### Prestige and Reset Mechanics
{{prestige_reset}}
**Long-term progression:**
- Prestige conditions (when to reset)
- Persistent bonuses after reset
- Prestige currency
- Multiple prestige layers (if applicable)
- Scaling between runs
- Endgame infinite scaling
### Number Balancing
{{number_balancing}}
**Economy design:**
- Exponential growth curves
- Notation systems (K, M, B, T or scientific)
- Soft caps and plateaus
- Time gates
- Pacing of progression
- Wall breaking mechanics
### Meta-Progression
{{meta_progression}}
**Long-term engagement:**
- Achievement system
- Collectibles
- Alternate game modes
- Seasonal content
- Challenge runs
- Endgame goals

87
src/modules/bmgd/workflows/2-design/gdd/game-types/metroidvania.md
View File

@ -1,87 +0,0 @@
## Metroidvania Specific Elements
<narrative-workflow-recommended>
This game type is **narrative-moderate**. Consider running the Narrative Design workflow after completing the GDD to create:
- World lore and environmental storytelling
- Character encounters and NPC arcs
- Backstory reveals through exploration
- Optional narrative depth
</narrative-workflow-recommended>
### Interconnected World Map
{{world_map}}
**Map design:**
- World structure (regions, zones, biomes)
- Interconnection points (shortcuts, elevators, warps)
- Verticality and layering
- Secret areas
- Map reveal mechanics
- Fast travel system (if applicable)
### Ability-Gating System
{{ability_gating}}
**Progression gates:**
- Core abilities (double jump, dash, wall climb, swim, etc.)
- Ability locations and pacing
- Soft gates vs. hard gates
- Optional abilities
- Sequence breaking considerations
- Ability synergies
### Backtracking Design
{{backtracking}}
**Return mechanics:**
- Obvious backtrack opportunities
- Hidden backtrack rewards
- Fast travel to reduce tedium
- Enemy respawn considerations
- Changed world state (if applicable)
- Completionist incentives
### Exploration Rewards
{{exploration_rewards}}
**Discovery incentives:**
- Health/energy upgrades
- Ability upgrades
- Collectibles (lore, cosmetics)
- Secret bosses
- Optional areas
- Completion percentage tracking
### Combat System
{{combat_system}}
**Combat mechanics:**
- Attack types (melee, ranged, magic)
- Boss fight design
- Enemy variety and placement
- Combat progression
- Defensive options
- Difficulty balance
### Sequence Breaking
{{sequence_breaking}}
**Advanced play:**
- Intended vs. unintended skips
- Speedrun considerations
- Difficulty of sequence breaks
- Reward for sequence breaking
- Developer stance on breaks
- Game completion without all abilities

74
src/modules/bmgd/workflows/2-design/gdd/game-types/moba.md
View File

@ -1,74 +0,0 @@
## MOBA Specific Elements
### Hero/Champion Roster
{{hero_roster}}
**Character design:**
- Hero count (initial roster, planned additions)
- Hero roles (tank, support, carry, assassin, mage, etc.)
- Unique abilities per hero (Q, W, E, R + passive)
- Hero complexity tiers (beginner-friendly vs. advanced)
- Visual and thematic diversity
- Counter-pick dynamics
### Lane Structure and Map
{{lane_map}}
**Map design:**
- Lane configuration (3-lane, 2-lane, custom)
- Jungle/neutral areas
- Objective locations (towers, inhibitors, nexus/ancient)
- Spawn points and fountains
- Vision mechanics (wards, fog of war)
### Item and Build System
{{item_build}}
**Itemization:**
- Item categories (offensive, defensive, utility, consumables)
- Gold economy
- Build paths and item trees
- Situational itemization
- Starting items vs. late-game items
### Team Composition and Roles
{{team_composition}}
**Team strategy:**
- Role requirements (1-3-1, 2-1-2, etc.)
- Team synergies
- Draft/ban phase (if applicable)
- Meta considerations
- Flexible vs. rigid compositions
### Match Phases
{{match_phases}}
**Game flow:**
- Early game (laning phase)
- Mid game (roaming, objectives)
- Late game (team fights, sieging)
- Phase transition mechanics
- Comeback mechanics
### Objectives and Win Conditions
{{objectives_victory}}
**Strategic objectives:**
- Primary objective (destroy base/nexus/ancient)
- Secondary objectives (towers, dragons, baron, roshan, etc.)
- Neutral camps
- Vision control objectives
- Time limits and sudden death (if applicable)

79
src/modules/bmgd/workflows/2-design/gdd/game-types/party-game.md
View File

@ -1,79 +0,0 @@
## Party Game Specific Elements
### Minigame Variety
{{minigame_variety}}
**Minigame design:**
- Minigame count (launch + DLC)
- Genre variety (racing, puzzle, reflex, trivia, etc.)
- Minigame length (15-60 seconds typical)
- Skill vs. luck balance
- Team vs. FFA minigames
- Accessibility across skill levels
### Turn Structure
{{turn_structure}}
**Game flow:**
- Board game structure (if applicable)
- Turn order (fixed, random, earned)
- Turn actions (roll dice, move, minigame, etc.)
- Event spaces
- Special mechanics (warp, steal, bonus)
- Match length (rounds, turns, time)
### Player Elimination vs. Points
{{scoring_elimination}}
**Competition design:**
- Points-based (everyone plays to the end)
- Elimination (last player standing)
- Hybrid systems
- Comeback mechanics
- Handicap systems
- Victory conditions
### Local Multiplayer UX
{{local_multiplayer}}
**Couch co-op design:**
- Controller sharing vs. individual controllers
- Screen layout (split-screen, shared screen)
- Turn clarity (whose turn indicators)
- Spectator experience (watching others play)
- Player join/drop mechanics
- Tutorial integration for new players
### Accessibility and Skill Range
{{accessibility}}
**Inclusive design:**
- Skill floor (easy to understand)
- Skill ceiling (depth for experienced players)
- Luck elements to balance skill gaps
- Assist modes or handicaps
- Child-friendly content
- Colorblind modes and accessibility
### Session Length
{{session_length}}
**Time management:**
- Quick play (5-10 minutes)
- Standard match (15-30 minutes)
- Extended match (30+ minutes)
- Drop-in/drop-out support
- Pause and resume
- Party management (hosting, invites)

58
src/modules/bmgd/workflows/2-design/gdd/game-types/puzzle.md
View File

@ -1,58 +0,0 @@
## Puzzle Game Specific Elements
### Core Puzzle Mechanics
{{puzzle_mechanics}}
**Puzzle elements:**
- Primary puzzle mechanic(s)
- Supporting mechanics
- Mechanic interactions
- Constraint systems
### Puzzle Progression
{{puzzle_progression}}
**Difficulty progression:**
- Tutorial/introduction puzzles
- Core concept puzzles
- Combined mechanic puzzles
- Expert/bonus puzzles
- Pacing and difficulty curve
### Level Structure
{{level_structure}}
**Level organization:**
- Number of levels/puzzles
- World/chapter grouping
- Unlock progression
- Optional/bonus content
### Player Assistance
{{player_assistance}}
**Help systems:**
- Hint system
- Undo/reset mechanics
- Skip puzzle options
- Tutorial integration
### Replayability
{{replayability}}
**Replay elements:**
- Par time/move goals
- Perfect solution challenges
- Procedural generation (if applicable)
- Daily/weekly puzzles
- Challenge modes

88
src/modules/bmgd/workflows/2-design/gdd/game-types/racing.md
View File

@ -1,88 +0,0 @@
## Racing Game Specific Elements
### Vehicle Handling and Physics
{{vehicle_physics}}
**Handling systems:**
- Physics model (arcade vs. simulation vs. hybrid)
- Vehicle stats (speed, acceleration, handling, braking, weight)
- Drift mechanics
- Collision physics
- Vehicle damage system (if applicable)
### Vehicle Roster
{{vehicle_roster}}
**Vehicle design:**
- Vehicle types (cars, bikes, boats, etc.)
- Vehicle classes (lightweight, balanced, heavyweight)
- Unlock progression
- Customization options (visual, performance)
- Balance considerations
### Track Design
{{track_design}}
**Course design:**
- Track variety (circuits, point-to-point, open world)
- Track length and lap counts
- Hazards and obstacles
- Shortcuts and alternate paths
- Track-specific mechanics
- Environmental themes
### Race Mechanics
{{race_mechanics}}
**Core racing:**
- Starting mechanics (countdown, reaction time)
- Checkpoint system
- Lap tracking and position
- Slipstreaming/drafting
- Pit stops (if applicable)
- Weather and time-of-day effects
### Powerups and Boost
{{powerups_boost}}
**Enhancement systems (if arcade-style):**
- Powerup types (offensive, defensive, utility)
- Boost mechanics (drift boost, nitro, slipstream)
- Item balance
- Counterplay mechanics
- Powerup placement on track
### Game Modes
{{game_modes}}
**Mode variety:**
- Standard race
- Time trial
- Elimination/knockout
- Battle/arena modes
- Career/campaign mode
- Online multiplayer modes
### Progression and Unlocks
{{progression}}
**Player advancement:**
- Career structure
- Unlockable vehicles and tracks
- Currency/rewards system
- Achievements and challenges
- Skill-based unlocks vs. time-based

79
src/modules/bmgd/workflows/2-design/gdd/game-types/rhythm.md
View File

@ -1,79 +0,0 @@
## Rhythm Game Specific Elements
### Music Synchronization
{{music_sync}}
**Core mechanics:**
- Beat/rhythm detection
- Note types (tap, hold, slide, etc.)
- Synchronization accuracy
- Audio-visual feedback
- Lane systems (4-key, 6-key, circular, etc.)
- Offset calibration
### Note Charts and Patterns
{{note_charts}}
**Chart design:**
- Charting philosophy (fun, challenge, accuracy to song)
- Pattern vocabulary (streams, jumps, chords, etc.)
- Difficulty representation
- Special patterns (gimmicks, memes)
- Chart preview
- Custom chart support (if applicable)
### Timing Windows
{{timing_windows}}
**Judgment system:**
- Judgment tiers (perfect, great, good, bad, miss)
- Timing windows (frame-perfect vs. lenient)
- Visual feedback for timing
- Audio feedback
- Combo system
- Health/life system (if applicable)
### Scoring System
{{scoring}}
**Score design:**
- Base score calculation
- Combo multipliers
- Accuracy weighting
- Max score calculation
- Grade/rank system (S, A, B, C)
- Leaderboards and competition
### Difficulty Tiers
{{difficulty_tiers}}
**Progression:**
- Difficulty levels (easy, normal, hard, expert, etc.)
- Difficulty representation (stars, numbers)
- Unlock conditions
- Difficulty curve
- Accessibility options
- Expert+ content
### Song Selection
{{song_selection}}
**Music library:**
- Song count (launch + planned DLC)
- Genre diversity
- Licensing vs. original music
- Song length targets
- Song unlock progression
- Favorites and playlists

69
src/modules/bmgd/workflows/2-design/gdd/game-types/roguelike.md
View File

@ -1,69 +0,0 @@
## Roguelike Specific Elements
### Run Structure
{{run_structure}}
**Run design:**
- Run length (time, stages)
- Starting conditions
- Difficulty scaling per run
- Victory conditions
### Procedural Generation
{{procedural_generation}}
**Generation systems:**
- Level generation algorithm
- Enemy placement
- Item/loot distribution
- Biome/theme variation
- Seed system (if deterministic)
### Permadeath and Progression
{{permadeath_progression}}
**Death mechanics:**
- Permadeath rules
- What persists between runs
- Meta-progression systems
- Unlock conditions
### Item and Upgrade System
{{item_upgrade_system}}
**Item mechanics:**
- Item types (passive, active, consumable)
- Rarity system
- Item synergies
- Build variety
- Curse/risk mechanics
### Character Selection
{{character_selection}}
**Playable characters:**
- Starting characters
- Unlockable characters
- Character unique abilities
- Character playstyle differences
### Difficulty Modifiers
{{difficulty_modifiers}}
**Challenge systems:**
- Difficulty tiers
- Modifiers/curses
- Challenge runs
- Achievement conditions

70
src/modules/bmgd/workflows/2-design/gdd/game-types/rpg.md
View File

@ -1,70 +0,0 @@
## RPG Specific Elements
### Character System
{{character_system}}
**Character attributes:**
- Stats (Strength, Dexterity, Intelligence, etc.)
- Classes/roles
- Leveling system
- Skill trees
### Inventory and Equipment
{{inventory_equipment}}
**Equipment system:**
- Item types (weapons, armor, accessories)
- Rarity tiers
- Item stats and modifiers
- Inventory management
### Quest System
{{quest_system}}
**Quest structure:**
- Main story quests
- Side quests
- Quest tracking
- Branching questlines
- Quest rewards
### World and Exploration
{{world_exploration}}
**World design:**
- Map structure (open world, hub-based, linear)
- Towns and safe zones
- Dungeons and combat zones
- Fast travel system
- Points of interest
### NPC and Dialogue
{{npc_dialogue}}
**NPC interaction:**
- Dialogue trees
- Relationship/reputation system
- Companion system
- Merchant NPCs
### Combat System
{{combat_system}}
**Combat mechanics:**
- Combat style (real-time, turn-based, tactical)
- Ability system
- Magic/skill system
- Status effects
- Party composition (if applicable)

79
src/modules/bmgd/workflows/2-design/gdd/game-types/sandbox.md
View File

@ -1,79 +0,0 @@
## Sandbox Game Specific Elements
### Creation Tools
{{creation_tools}}
**Building mechanics:**
- Tool types (place, delete, modify, paint)
- Object library (blocks, props, entities)
- Precision controls (snap, free, grid)
- Copy/paste and templates
- Undo/redo system
- Import/export functionality
### Physics and Building Systems
{{physics_building}}
**System simulation:**
- Physics engine (rigid body, soft body, fluids)
- Structural integrity (if applicable)
- Destruction mechanics
- Material properties
- Constraint systems (joints, hinges, motors)
- Interactive simulations
### Sharing and Community
{{sharing_community}}
**Social features:**
- Creation sharing (workshop, gallery)
- Discoverability (search, trending, featured)
- Rating and feedback systems
- Collaboration tools
- Modding support
- User-generated content moderation
### Constraints and Rules
{{constraints_rules}}
**Game design:**
- Creative mode (unlimited resources, no objectives)
- Challenge mode (limited resources, objectives)
- Budget/point systems (if competitive)
- Build limits (size, complexity)
- Rulesets and game modes
- Victory conditions (if applicable)
### Tools and Editing
{{tools_editing}}
**Advanced features:**
- Logic gates/scripting (if applicable)
- Animation tools
- Terrain editing
- Weather/environment controls
- Lighting and effects
- Testing/preview modes
### Emergent Gameplay
{{emergent_gameplay}}
**Player creativity:**
- Unintended creations (embracing exploits)
- Community-defined challenges
- Speedrunning player creations
- Cross-creation interaction
- Viral moments and showcases
- Evolution of the meta

62
src/modules/bmgd/workflows/2-design/gdd/game-types/shooter.md
View File

@ -1,62 +0,0 @@
## Shooter Specific Elements
### Weapon Systems
{{weapon_systems}}
**Weapon design:**
- Weapon types (pistol, rifle, shotgun, sniper, explosive, etc.)
- Weapon stats (damage, fire rate, accuracy, reload time, ammo capacity)
- Weapon progression (starting weapons, unlocks, upgrades)
- Weapon feel (recoil patterns, sound design, impact feedback)
- Balance considerations (risk/reward, situational use)
### Aiming and Combat Mechanics
{{aiming_combat}}
**Combat systems:**
- Aiming system (first-person, third-person, twin-stick, lock-on)
- Hit detection (hitscan vs. projectile)
- Accuracy mechanics (spread, recoil, movement penalties)
- Critical hits / weak points
- Melee integration (if applicable)
### Enemy Design and AI
{{enemy_ai}}
**Enemy systems:**
- Enemy types (fodder, elite, tank, ranged, melee, boss)
- AI behavior patterns (aggressive, defensive, flanking, cover use)
- Spawn systems (waves, triggers, procedural)
- Difficulty scaling (health, damage, AI sophistication)
- Enemy tells and telegraphing
### Arena and Level Design
{{arena_level_design}}
**Level structure:**
- Arena flow (choke points, open spaces, verticality)
- Cover system design (destructible, dynamic, static)
- Spawn points and safe zones
- Power-up placement
- Environmental hazards
- Sightlines and engagement distances
### Multiplayer Considerations
{{multiplayer}}
**Multiplayer systems (if applicable):**
- Game modes (deathmatch, team deathmatch, objective-based, etc.)
- Map design for PvP
- Loadout systems
- Matchmaking and ranking
- Balance considerations (skill ceiling, counter-play)

73
src/modules/bmgd/workflows/2-design/gdd/game-types/simulation.md
View File

@ -1,73 +0,0 @@
## Simulation Specific Elements
### Core Simulation Systems
{{simulation_systems}}
**What's being simulated:**
- Primary simulation focus (city, farm, business, ecosystem, etc.)
- Simulation depth (abstract vs. realistic)
- System interconnections
- Emergent behaviors
- Simulation tickrate and performance
### Management Mechanics
{{management_mechanics}}
**Management systems:**
- Resource management (budget, materials, time)
- Decision-making mechanics
- Automation vs. manual control
- Delegation systems (if applicable)
- Efficiency optimization
### Building and Construction
{{building_construction}}
**Construction systems:**
- Placeable objects/structures
- Grid system (free placement, snap-to-grid, tiles)
- Building prerequisites and unlocks
- Upgrade/demolition mechanics
- Space constraints and planning
### Economic and Resource Loops
{{economic_loops}}
**Economic design:**
- Income sources
- Expenses and maintenance
- Supply chains (if applicable)
- Market dynamics
- Economic balance and pacing
### Progression and Unlocks
{{progression_unlocks}}
**Progression systems:**
- Unlock conditions (achievements, milestones, levels)
- Tech/research tree
- New mechanics/features over time
- Difficulty scaling
- Endgame content
### Sandbox vs. Scenario
{{sandbox_scenario}}
**Game modes:**
- Sandbox mode (unlimited resources, creative freedom)
- Scenario/campaign mode (specific goals, constraints)
- Challenge modes
- Random/procedural scenarios
- Custom scenario creation

75
src/modules/bmgd/workflows/2-design/gdd/game-types/sports.md
View File

@ -1,75 +0,0 @@
## Sports Game Specific Elements
### Sport-Specific Rules
{{sport_rules}}
**Rule implementation:**
- Core sport rules (scoring, fouls, violations)
- Match/game structure (quarters, periods, innings, etc.)
- Referee/umpire system
- Rule variations (if applicable)
- Simulation vs. arcade rule adherence
### Team and Player Systems
{{team_player}}
**Roster design:**
- Player attributes (speed, strength, skill, etc.)
- Position-specific stats
- Team composition
- Substitution mechanics
- Stamina/fatigue system
- Injury system (if applicable)
### Match Structure
{{match_structure}}
**Game flow:**
- Pre-match setup (lineups, strategies)
- In-match actions (plays, tactics, timeouts)
- Half-time/intermission
- Overtime/extra time rules
- Post-match results and stats
### Physics and Realism
{{physics_realism}}
**Simulation balance:**
- Physics accuracy (ball/puck physics, player movement)
- Realism vs. fun tradeoffs
- Animation systems
- Collision detection
- Weather/field condition effects
### Career and Season Modes
{{career_season}}
**Long-term modes:**
- Career mode structure
- Season/tournament progression
- Transfer/draft systems
- Team management
- Contract negotiations
- Sponsor/financial systems
### Multiplayer Modes
{{multiplayer}}
**Competitive play:**
- Local multiplayer (couch co-op)
- Online multiplayer
- Ranked/casual modes
- Ultimate team/card collection (if applicable)
- Co-op vs. AI

71
src/modules/bmgd/workflows/2-design/gdd/game-types/strategy.md
View File

@ -1,71 +0,0 @@
## Strategy Specific Elements
### Resource Systems
{{resource_systems}}
**Resource management:**
- Resource types (gold, food, energy, population, etc.)
- Gathering mechanics (auto-generate, harvesting, capturing)
- Resource spending (units, buildings, research, upgrades)
- Economic balance (income vs. expenses)
- Scarcity and strategic choices
### Unit Types and Stats
{{unit_types}}
**Unit design:**
- Unit roster (basic, advanced, specialized, hero units)
- Unit stats (health, attack, defense, speed, range)
- Unit abilities (active, passive, unique)
- Counter systems (rock-paper-scissors dynamics)
- Unit production (cost, build time, prerequisites)
### Technology and Progression
{{tech_progression}}
**Progression systems:**
- Tech tree structure (linear, branching, era-based)
- Research mechanics (time, cost, prerequisites)
- Upgrade paths (unit upgrades, building improvements)
- Unlock conditions (progression gates, achievements)
### Map and Terrain
{{map_terrain}}
**Strategic space:**
- Map size and structure (small/medium/large, symmetric/asymmetric)
- Terrain types (passable, impassable, elevated, water)
- Terrain effects (movement, combat bonuses, vision)
- Strategic points (resources, objectives, choke points)
- Fog of war / vision system
### AI Opponent
{{ai_opponent}}
**AI design:**
- AI difficulty levels (easy, medium, hard, expert)
- AI behavior patterns (aggressive, defensive, economic, adaptive)
- AI cheating considerations (fair vs. challenge-focused)
- AI personality types (if multiple opponents)
### Victory Conditions
{{victory_conditions}}
**Win/loss design:**
- Victory types (domination, economic, technological, diplomatic, etc.)
- Time limits (if applicable)
- Score systems (if applicable)
- Defeat conditions
- Early surrender / concession mechanics

79
src/modules/bmgd/workflows/2-design/gdd/game-types/survival.md
View File

@ -1,79 +0,0 @@
## Survival Game Specific Elements
### Resource Gathering and Crafting
{{resource_crafting}}
**Resource systems:**
- Resource types (wood, stone, food, water, etc.)
- Gathering methods (mining, foraging, hunting, looting)
- Crafting recipes and trees
- Tool/weapon crafting
- Durability and repair
- Storage and inventory management
### Survival Needs
{{survival_needs}}
**Player vitals:**
- Hunger/thirst systems
- Health and healing
- Temperature/exposure
- Sleep/rest (if applicable)
- Sanity/morale (if applicable)
- Status effects (poison, disease, etc.)
### Environmental Threats
{{environmental_threats}}
**Danger systems:**
- Wildlife (predators, hostile creatures)
- Environmental hazards (weather, terrain)
- Day/night cycle threats
- Seasonal changes (if applicable)
- Natural disasters
- Dynamic threat scaling
### Base Building
{{base_building}}
**Construction systems:**
- Building materials and recipes
- Structure types (shelter, storage, defenses)
- Base location and planning
- Upgrade paths
- Defensive structures
- Automation (if applicable)
### Progression and Technology
{{progression_tech}}
**Advancement:**
- Tech tree or skill progression
- Tool/weapon tiers
- Unlock conditions
- New biomes/areas access
- Endgame objectives (if applicable)
- Prestige/restart mechanics (if applicable)
### World Structure
{{world_structure}}
**Map design:**
- World size and boundaries
- Biome diversity
- Procedural vs. handcrafted
- Points of interest
- Risk/reward zones
- Fast travel or navigation systems

91
src/modules/bmgd/workflows/2-design/gdd/game-types/text-based.md
View File

@ -1,91 +0,0 @@
## Text-Based Game Specific Elements
<narrative-workflow-critical>
This game type is **narrative-critical**. You MUST run the Narrative Design workflow after completing the GDD to create:
- Complete story and all narrative paths
- Room descriptions and atmosphere
- Puzzle solutions and hints
- Character dialogue
- World lore and backstory
- Parser vocabulary (if parser-based)
</narrative-workflow-critical>
### Input System
{{input_system}}
**Core interface:**
- Parser-based (natural language commands)
- Choice-based (numbered/lettered options)
- Hybrid system
- Command vocabulary depth
- Synonyms and flexibility
- Error messaging and hints
### Room/Location Structure
{{location_structure}}
**World design:**
- Room count and scope
- Room descriptions (length, detail)
- Connection types (doors, paths, obstacles)
- Map structure (linear, branching, maze-like, open)
- Landmarks and navigation aids
- Fast travel or mapping system
### Item and Inventory System
{{item_inventory}}
**Object interaction:**
- Examinable objects
- Takeable vs. scenery objects
- Item use and combinations
- Inventory management
- Object descriptions
- Hidden objects and clues
### Puzzle Design
{{puzzle_design}}
**Challenge structure:**
- Puzzle types (logic, inventory, knowledge, exploration)
- Difficulty curve
- Hint system (gradual reveals)
- Red herrings vs. crucial clues
- Puzzle integration with story
- Non-linear puzzle solving
### Narrative and Writing
{{narrative_writing}}
**Story delivery:**
- Writing tone and style
- Descriptive density
- Character voice
- Dialogue systems
- Branching narrative (if applicable)
- Multiple endings (if applicable)
**Note:** All narrative content must be written in the Narrative Design Document.
### Game Flow and Pacing
{{game_flow}}
**Structure:**
- Game length target
- Acts or chapters
- Save system
- Undo/rewind mechanics
- Walkthrough or hint accessibility
- Replayability considerations

79
src/modules/bmgd/workflows/2-design/gdd/game-types/tower-defense.md
View File

@ -1,79 +0,0 @@
## Tower Defense Specific Elements
### Tower Types and Upgrades
{{tower_types}}
**Tower design:**
- Tower categories (damage, slow, splash, support, special)
- Tower stats (damage, range, fire rate, cost)
- Upgrade paths (linear, branching)
- Tower synergies
- Tier progression
- Special abilities and targeting
### Enemy Wave Design
{{wave_design}}
**Enemy systems:**
- Enemy types (fast, tank, flying, immune, boss)
- Wave composition
- Wave difficulty scaling
- Wave scheduling and pacing
- Boss encounters
- Endless mode scaling (if applicable)
### Path and Placement Strategy
{{path_placement}}
**Strategic space:**
- Path structure (fixed, custom, maze-building)
- Placement restrictions (grid, free placement)
- Terrain types (buildable, non-buildable, special)
- Choke points and strategic locations
- Multiple paths (if applicable)
- Line of sight and range visualization
### Economy and Resources
{{economy}}
**Resource management:**
- Starting resources
- Resource generation (per wave, per kill, passive)
- Resource spending (towers, upgrades, abilities)
- Selling/refund mechanics
- Special currencies (if applicable)
- Economic optimization strategies
### Abilities and Powers
{{abilities_powers}}
**Active mechanics:**
- Player-activated abilities (airstrikes, freezes, etc.)
- Cooldown systems
- Ability unlocks
- Ability upgrade paths
- Strategic timing
- Resource cost vs. cooldown
### Difficulty and Replayability
{{difficulty_replay}}
**Challenge systems:**
- Difficulty levels
- Mission objectives (perfect clear, no lives lost, etc.)
- Star ratings
- Challenge modifiers
- Randomized elements
- New Game+ or prestige modes

88
src/modules/bmgd/workflows/2-design/gdd/game-types/turn-based-tactics.md
View File

@ -1,88 +0,0 @@
## Turn-Based Tactics Specific Elements
<narrative-workflow-recommended>
This game type is **narrative-moderate to heavy**. Consider running the Narrative Design workflow after completing the GDD to create:
- Campaign story and mission briefings
- Character backstories and development
- Faction lore and motivations
- Mission narratives
</narrative-workflow-recommended>
### Grid System and Movement
{{grid_movement}}
**Spatial design:**
- Grid type (square, hex, free-form)
- Movement range calculation
- Movement types (walk, fly, teleport)
- Terrain movement costs
- Zone of control
- Pathfinding visualization
### Unit Types and Classes
{{unit_classes}}
**Unit design:**
- Class roster (warrior, archer, mage, healer, etc.)
- Class abilities and specializations
- Unit progression (leveling, promotions)
- Unit customization
- Unique units (heroes, named characters)
- Class balance and counters
### Action Economy
{{action_economy}}
**Turn structure:**
- Action points system (fixed, variable, pooled)
- Action types (move, attack, ability, item, wait)
- Free actions vs. costing actions
- Opportunity attacks
- Turn order (initiative, simultaneous, alternating)
- Time limits per turn (if applicable)
### Positioning and Tactics
{{positioning_tactics}}
**Strategic depth:**
- Flanking mechanics
- High ground advantage
- Cover system
- Formation bonuses
- Area denial
- Chokepoint tactics
- Line of sight and vision
### Terrain and Environmental Effects
{{terrain_effects}}
**Map design:**
- Terrain types (grass, water, lava, ice, etc.)
- Terrain effects (defense bonus, movement penalty, damage)
- Destructible terrain
- Interactive objects
- Weather effects
- Elevation and verticality
### Campaign Structure
{{campaign}}
**Mission design:**
- Campaign length and pacing
- Mission variety (defeat all, survive, escort, capture, etc.)
- Optional objectives
- Branching campaigns
- Permadeath vs. casualty systems
- Resource management between missions

89
src/modules/bmgd/workflows/2-design/gdd/game-types/visual-novel.md
View File

@ -1,89 +0,0 @@
## Visual Novel Specific Elements
<narrative-workflow-critical>
This game type is **narrative-critical**. You MUST run the Narrative Design workflow after completing the GDD to create:
- Complete story structure and script
- All character profiles and development arcs
- Branching story flowcharts
- Scene-by-scene breakdown
- Dialogue drafts
- Multiple route planning
</narrative-workflow-critical>
### Branching Story Structure
{{branching_structure}}
**Narrative design:**
- Story route types (character routes, plot branches)
- Branch points (choices, stats, flags)
- Convergence points
- Route length and pacing
- True/golden ending requirements
- Branch complexity (simple, moderate, complex)
### Choice Impact System
{{choice_impact}}
**Decision mechanics:**
- Choice types (immediate, delayed, hidden)
- Choice visualization (explicit, subtle, invisible)
- Point systems (affection, alignment, stats)
- Flag tracking
- Choice consequences
- Meaningful vs. cosmetic choices
### Route Design
{{route_design}}
**Route structure:**
- Common route (shared beginning)
- Individual routes (character-specific paths)
- Route unlock conditions
- Route length balance
- Route independence vs. interconnection
- Recommended play order
### Character Relationship Systems
{{relationship_systems}}
**Character mechanics:**
- Affection/friendship points
- Relationship milestones
- Character-specific scenes
- Dialogue variations based on relationship
- Multiple romance options (if applicable)
- Platonic vs. romantic paths
### Save/Load and Flowchart
{{save_flowchart}}
**Player navigation:**
- Save point frequency
- Quick save/load
- Scene skip functionality
- Flowchart/scene select (after completion)
- Branch tracking visualization
- Completion percentage
### Art Asset Requirements
{{art_assets}}
**Visual content:**
- Character sprites (poses, expressions)
- Background art (locations, times of day)
- CG artwork (key moments, endings)
- UI elements
- Special effects
- Asset quantity estimates

249
src/modules/bmgd/workflows/2-design/gdd/steps/step-01-init.md
View File

@ -1,249 +0,0 @@
---
name: 'step-01-init'
description: 'Initialize the GDD workflow by detecting continuation state and setting up the document'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-01-init.md'
nextStepFile: './step-02-context.md'
continueStepFile: './step-01b-continue.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.md'
# Template References
gddTemplate: '{workflow_path}/templates/gdd-template.md'
# Data Files
gameTypesCSV: '{workflow_path}/game-types.csv'
---
# Step 1: Workflow Initialization
**Progress: Step 1 of 14** - Next: Game Context & Type
## STEP GOAL:
Initialize the GDD workflow by detecting continuation state, discovering input documents (game brief, research), and setting up the document structure for collaborative game design discovery.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a veteran game designer facilitator collaborating with a creative peer
- If you already have been given a name, communication_style and persona, continue to use those while playing this new role
- We engage in collaborative dialogue, not command-response
- You bring structured game design thinking and facilitation skills, while the user brings their game vision
### Step-Specific Rules:
- Focus only on initialization and setup - no content generation yet
- FORBIDDEN to look ahead to future steps or assume knowledge from them
- Approach: Systematic setup with clear reporting to user
- Detect existing workflow state and handle continuation properly
## EXECUTION PROTOCOLS:
- Show your analysis of current state before taking any action
- Initialize document structure and update frontmatter appropriately
- Set up frontmatter `stepsCompleted: [1]` before loading next step
- FORBIDDEN to load next step until user selects 'C' (Continue)
## CONTEXT BOUNDARIES:
- Available context: Variables from workflow.md are available in memory
- Focus: Workflow initialization and document setup only
- Limits: Don't assume knowledge from other steps or create content yet
- Dependencies: Configuration loaded from workflow.md initialization
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Check for Existing Workflow State
First, check if the output document already exists:
**Workflow State Detection:**
- Look for file at `{outputFile}`
- If exists, read the complete file including frontmatter
- If not exists, this is a fresh workflow
### 2. Handle Continuation (If Document Exists)
If the document exists and has frontmatter with `stepsCompleted`:
**Continuation Protocol:**
- **STOP immediately** and load `{continueStepFile}`
- Do not proceed with any initialization tasks
- Let step-01b handle all continuation logic
- This is an auto-proceed situation - no user choice needed
### 3. Fresh Workflow Setup (If No Document)
If no document exists or no `stepsCompleted` in frontmatter:
#### A. Input Document Discovery
Discover and load context documents using smart discovery.
**IMPORTANT: Track document counts as you discover files.**
Initialize counters:
```
briefCount = 0
researchCount = 0
brainstormingCount = 0
projectDocsCount = 0
```
**Game Brief (Priority: Analysis -> Main -> Sharded -> Whole):**
1. Check analysis folder: `{output_folder}/analysis/*game-brief*.md`
2. If no analysis files: Try main folder: `{output_folder}/*game-brief*.md`
3. If no main files: Check for sharded brief folder: `{output_folder}/*game-brief*/**/*.md`
4. If sharded folder exists: Load EVERY file in that folder completely
5. Add discovered files to `inputDocuments` frontmatter
6. **Update briefCount with number of files found**
**Research Documents (Priority: Analysis -> Main -> Sharded -> Whole):**
1. Check analysis folder: `{output_folder}/analysis/research/*research*.md`
2. If no analysis files: Try main folder: `{output_folder}/*research*.md`
3. If no main files: Check for sharded research folder: `{output_folder}/*research*/**/*.md`
4. Load useful research files completely
5. Add discovered files to `inputDocuments` frontmatter
6. **Update researchCount with number of files found**
**Brainstorming Documents (Priority: Analysis -> Main):**
1. Check analysis folder: `{output_folder}/analysis/brainstorming/*brainstorm*.md`
2. If no analysis files: Try main folder: `{output_folder}/*brainstorm*.md`
3. Add discovered files to `inputDocuments` frontmatter
4. **Update brainstormingCount with number of files found**
**Project Documentation (Existing Projects - Brownfield):**
1. Look for index file: `{output_folder}/index.md`
2. CRITICAL: Load index.md to understand what project files are available
3. Read available files from index to understand existing project context
4. This provides essential context for extending existing game with new features
5. Add discovered files to `inputDocuments` frontmatter
6. **Update projectDocsCount with number of files found (including index.md)**
**Loading Rules:**
- Load ALL discovered files completely (no offset/limit)
- For sharded folders, load ALL files to get complete picture
- For existing projects, use index.md as guide to what's relevant
- Track all successfully loaded files in frontmatter `inputDocuments` array
#### B. Create Initial Document
**Document Setup:**
- Copy the template from `{gddTemplate}` to `{outputFile}`
- Initialize frontmatter with proper structure including document counts:
```yaml
---
stepsCompleted: []
inputDocuments: []
documentCounts:
briefs: { { briefCount } }
research: { { researchCount } }
brainstorming: { { brainstormingCount } }
projectDocs: { { projectDocsCount } }
workflowType: 'gdd'
lastStep: 0
project_name: '{{project_name}}'
user_name: '{{user_name}}'
date: '{{date}}'
game_type: ''
game_name: ''
---
```
#### C. Present Initialization Results
**Setup Report to User:**
"Welcome {{user_name}}! I've set up your GDD workspace for {{project_name}}.
**Document Setup:**
- Created: `{outputFile}` from template
- Initialized frontmatter with workflow state
**Input Documents Discovered:**
- Game briefs: {{briefCount}} files {if briefCount > 0}loaded{else}(none found){/if}
- Research: {{researchCount}} files {if researchCount > 0}loaded{else}(none found){/if}
- Brainstorming: {{brainstormingCount}} files {if brainstormingCount > 0}loaded{else}(none found){/if}
- Project docs: {{projectDocsCount}} files {if projectDocsCount > 0}loaded (brownfield project){else}(none found - greenfield project){/if}
**Files loaded:** {list of specific file names or "No additional documents found"}
{if projectDocsCount > 0}
**Note:** This is a **brownfield project**. Your existing project documentation has been loaded. In the next step, I'll ask specifically about what new features or changes you want to add to your existing game.
{/if}
Do you have any other documents you'd like me to include, or shall we continue to the next step?"
### 4. Present MENU OPTIONS
Display menu after setup report:
"[C] Continue - Save this and move to Game Context & Type (Step 2 of 14)"
#### Menu Handling Logic:
- IF C: Update frontmatter with `stepsCompleted: [1]`, then load, read entire file, then execute {nextStepFile}
- IF user provides additional files: Load them, update inputDocuments and documentCounts, redisplay report
- IF user asks questions: Answer and redisplay menu
#### EXECUTION RULES:
- ALWAYS halt and wait for user input after presenting menu
- ONLY proceed to next step when user selects 'C'
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [frontmatter properly updated with stepsCompleted: [1] and documentCounts], will you then load and read fully `{nextStepFile}` to execute and begin game context discovery.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Existing workflow detected and properly handed off to step-01b
- Fresh workflow initialized with template and proper frontmatter
- Input documents discovered and loaded using sharded-first logic
- All discovered files tracked in frontmatter `inputDocuments`
- **Document counts stored in frontmatter `documentCounts`**
- User clearly informed of brownfield vs greenfield status
- Menu presented and user input handled correctly
- Frontmatter updated with `stepsCompleted: [1]` before proceeding
### SYSTEM FAILURE:
- Proceeding with fresh initialization when existing workflow exists
- Not updating frontmatter with discovered input documents
- **Not storing document counts in frontmatter**
- Creating document without proper template structure
- Not checking sharded folders first before whole files
- Not reporting discovered documents to user clearly
- Proceeding without user selecting 'C' (Continue)
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

174
src/modules/bmgd/workflows/2-design/gdd/steps/step-01b-continue.md
View File

@ -1,174 +0,0 @@
---
name: 'step-01b-continue'
description: 'Resume an interrupted GDD workflow from the last completed step'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-01b-continue.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.md'
---
# Step 1B: Workflow Continuation
## STEP GOAL:
Resume the GDD workflow from where it was left off, ensuring smooth continuation with full context restoration.
## MANDATORY EXECUTION RULES (READ FIRST):
### Universal Rules:
- NEVER generate content without user input
- CRITICAL: Read the complete step file before taking any action
- CRITICAL: When loading next step with 'C', ensure entire file is read
- YOU ARE A FACILITATOR, not a content generator
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
### Role Reinforcement:
- You are a veteran game designer facilitator collaborating with a creative peer
- We engage in collaborative dialogue, not command-response
- Resume workflow from exact point where it was interrupted
### Step-Specific Rules:
- FOCUS on understanding where we left off and continuing appropriately
- FORBIDDEN to modify content completed in previous steps
- Only reload documents that were already tracked in `inputDocuments`
## EXECUTION PROTOCOLS:
- Show your analysis of current state before taking action
- Keep existing frontmatter `stepsCompleted` values
- Only load documents that were already tracked in `inputDocuments`
- FORBIDDEN to discover new input documents during continuation
## CONTEXT BOUNDARIES:
- Available context: Current document and frontmatter are already loaded
- Focus: Workflow state analysis and continuation logic only
- Limits: Don't assume knowledge beyond what's in the document
- Dependencies: Existing workflow state from previous session
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Analyze Current State
**State Assessment:**
Review the frontmatter to understand:
- `stepsCompleted`: Which steps are already done
- `lastStep`: The most recently completed step number
- `inputDocuments`: What context was already loaded
- `documentCounts`: briefs, research, brainstorming, projectDocs counts
- `game_type`: The identified game type (if set)
- `game_name`: The game name (if set)
- All other frontmatter variables
### 2. Restore Context Documents
**Context Reloading:**
- For each document in `inputDocuments`, load the complete file
- This ensures you have full context for continuation
- Don't discover new documents - only reload what was previously processed
- If `game_type` is set, also reload the corresponding game type guide from `{workflow_path}/game-types/{game_type}.md`
### 3. Present Current Progress
**Progress Report to User:**
"Welcome back {{user_name}}! I'm resuming our GDD collaboration for {{game_name or project_name}}.
**Current Progress:**
- Steps completed: {stepsCompleted}
- Last worked on: Step {lastStep}
- Game type: {game_type or 'Not yet determined'}
- Context documents available: {len(inputDocuments)} files
**Document Status:**
- Current GDD document is ready with all completed sections
- Ready to continue from where we left off
Does this look right, or do you want to make any adjustments before we proceed?"
### 4. Determine Continuation Path
**Next Step Logic:**
Based on `lastStep` value, determine which step to load next:
- If `lastStep = 1` -> Load `./step-02-context.md`
- If `lastStep = 2` -> Load `./step-03-platforms.md`
- If `lastStep = 3` -> Load `./step-04-vision.md`
- If `lastStep = 4` -> Load `./step-05-core-gameplay.md`
- If `lastStep = 5` -> Load `./step-06-mechanics.md`
- If `lastStep = 6` -> Load `./step-07-game-type.md`
- If `lastStep = 7` -> Load `./step-08-progression.md`
- If `lastStep = 8` -> Load `./step-09-levels.md`
- If `lastStep = 9` -> Load `./step-10-art-audio.md`
- If `lastStep = 10` -> Load `./step-11-technical.md`
- If `lastStep = 11` -> Load `./step-12-epics.md`
- If `lastStep = 12` -> Load `./step-13-metrics.md`
- If `lastStep = 13` -> Load `./step-14-complete.md`
- If `lastStep = 14` -> Workflow already complete
### 5. Handle Workflow Completion
**If workflow already complete (`lastStep = 14`):**
"Great news! It looks like we've already completed the GDD workflow for {{game_name}}.
The final document is ready at `{outputFile}` with all sections completed through step 14.
Would you like me to:
- Review the completed GDD with you
- Suggest next workflow steps (like architecture or epic creation)
- Start a new GDD revision
What would be most helpful?"
### 6. Present MENU OPTIONS
**If workflow not complete:**
Display: "Ready to continue with Step {nextStepNumber}?
**Select an Option:** [C] Continue to next step"
#### Menu Handling Logic:
- IF C: Load, read entire file, then execute the appropriate next step file based on `lastStep`
- IF Any other comments or queries: respond and redisplay menu
#### EXECUTION RULES:
- ALWAYS halt and wait for user input after presenting menu
- ONLY proceed to next step when user selects 'C'
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [current state confirmed], will you then load and read fully the appropriate next step file to resume the workflow.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- All previous input documents successfully reloaded
- Game type guide reloaded if game_type was set
- Current workflow state accurately analyzed and presented
- User confirms understanding of progress before continuation
- Correct next step identified and prepared for loading
### SYSTEM FAILURE:
- Discovering new input documents instead of reloading existing ones
- Modifying content from already completed steps
- Loading wrong next step based on `lastStep` value
- Proceeding without user confirmation of current state
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Some files were not shown because too many files have changed in this diff Show More