ros/BMAD-METHOD
1
0
Fork 0
mirror of https://github.com/bmad-code-org/BMAD-METHOD.git synced 2026-01-30 04:32:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

minor doc updates related to cis removal from repo

Browse Source
This commit is contained in:
Brian Madison
2026-01-17 01:32:49 -06:00
parent 5881790068
commit 7990ad528c
8 changed files with 49 additions and 1151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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 | Description |
|-------|-------------|
| **[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 |
| **[Game Development Agents](/docs/explanation/game-dev/agents.md)** | Complete guide to BMGD's specialized game dev agents |
| Agent | Description |
| ------------------------------------------------------------------------------- | ---------------------------------------------------- |
| **[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 |
## 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
- **Documentation** - Usage guides and reference
## Official Modules
## Official BMad Method and Builder Modules
:::note[Core is Always Installed]
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
- 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)
Innovation and creativity:
- Creative thinking techniques
- Innovation strategy workflows
- Storytelling and ideation
- [Available Here](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
### BMad Game Dev (BMGD)
Game development specialization:
- Game design workflows
- Narrative development
- Performance testing frameworks
- [Available Here](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
## Module Structure

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.
:::

50
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**
- [Why are my Mermaid diagrams not rendering?](#why-are-my-mermaid-diagrams-not-rendering)
- [Can I use BMM with GitHub Copilot / Cursor / other AI tools?](#can-i-use-bmm-with-github-copilot--cursor--other-ai-tools)
- [What IDEs/tools support BMM?](#what-idestools-support-bmm)
- [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)
- [Questions](#questions)
- [Tools and Technical](#tools-and-technical)
- [Why are my Mermaid diagrams not rendering?](#why-are-my-mermaid-diagrams-not-rendering)
- [Can I use BMM with GitHub Copilot / Cursor / other AI tools?](#can-i-use-bmm-with-github-copilot--cursor--other-ai-tools)
- [What IDEs/tools support BMM?](#what-idestools-support-bmm)
- [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**
- [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)
- [Questions](#questions)
- [Tools and Technical](#tools-and-technical)
- [Why are my Mermaid diagrams not rendering?](#why-are-my-mermaid-diagrams-not-rendering)
- [Can I use BMM with GitHub Copilot / Cursor / other AI tools?](#can-i-use-bmm-with-github-copilot--cursor--other-ai-tools)
- [What IDEs/tools support BMM?](#what-idestools-support-bmm)
- [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**
@@ -203,7 +227,7 @@ Party mode is a unique multi-agent collaboration feature where ALL your installe
**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
3. BMad Master selects 2-3 most relevant agents per message
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