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

remove modules moved to new repos and update installer to support the remote module isntallation and updates. this is a temporary imlemtation machanism

Browse Source
This commit is contained in:
Brian Madison
2026-01-15 21:52:37 -06:00
parent abba7ee987
commit 577c1aa218
245 changed files with 444 additions and 42153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
.gitignore vendored
View File

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

25
src/core/module.yaml
View File

@@ -1,25 +0,0 @@
code: core
name: "BMad™ Core Module"
header: "BMad™ Core Configuration"
subheader: "Configure the core settings for your BMad™ installation.\nThese settings will be used across all modules and agents."
user_name:
prompt: "What shall the agents call you (TIP: Use a team name if using with a group)?"
default: "BMad"
result: "{value}"
communication_language:
prompt: "Preferred chat language/style? (English, Mandarin, English Pirate, etc...)"
default: "English"
result: "{value}"
document_output_language:
prompt: "Preferred document output language?"
default: "English"
result: "{value}"
output_folder:
prompt: "Where should default output files be saved unless specified in other modules?"
default: "_bmad-output"
result: "{project-root}/{value}"

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.

333
src/modules/bmgd/workflows/2-design/gdd/steps/step-02-context.md
View File

@@ -1,333 +0,0 @@
---
name: 'step-02-context'
description: 'Load game context from brief and determine the game type'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-02-context.md'
nextStepFile: './step-03-platforms.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.md'
# Data Files
gameTypesCSV: '{workflow_path}/game-types.csv'
gameTypesFolder: '{workflow_path}/game-types'
# 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 Context & Type
**Progress: Step 2 of 14** - Next: Platforms & Audience
## STEP GOAL:
Load and analyze the game brief (if available), determine the game type from game-types.csv, load the corresponding game type guide, and capture the core game concept that will drive the entire GDD.
## 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
- You bring structured game design thinking and facilitation skills, while the user brings their game vision
### Step-Specific Rules:
- Focus on understanding the game concept and determining the correct game type
- CRITICAL: Load game-types.csv to understand available game types
- FORBIDDEN to generate detailed content without real user input
- Approach: Leverage existing documents while validating with user
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Present A/P/C menu after generating core concept 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):
This step will generate content and present choices:
- **A (Advanced Elicitation)**: Use discovery protocols to develop deeper insights about the game concept
- **P (Party Mode)**: Bring multiple perspectives to discuss and improve the game concept
- **C (Continue)**: Save the content to the document and proceed to next step
## PROTOCOL INTEGRATION:
- When 'A' selected: Execute {advancedElicitationTask}
- When 'P' selected: Execute {partyModeWorkflow}
- PROTOCOLS always return to this step's A/P/C menu
- User accepts/rejects protocol changes before proceeding
## CONTEXT BOUNDARIES:
- Current document and frontmatter from step 1 are available
- Input documents already loaded are in memory (game briefs, research, brainstorming)
- **Document counts available in frontmatter `documentCounts`**
- Game types CSV data will be loaded in this step
- This will be the first content section appended to the document
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Read Document State from Frontmatter
**CRITICAL FIRST ACTION:** Read the frontmatter from `{outputFile}` to get document counts.
```
Read documentCounts from gdd.md frontmatter:
- briefCount = documentCounts.briefs
- researchCount = documentCounts.research
- brainstormingCount = documentCounts.brainstorming
- projectDocsCount = documentCounts.projectDocs
```
**ANNOUNCE your understanding:**
"From step 1, I have loaded:
- Game briefs: {{briefCount}} files
- Research: {{researchCount}} files
- Brainstorming: {{brainstormingCount}} files
- Project docs: {{projectDocsCount}} files
{if projectDocsCount > 0}This is a **brownfield project** - I'll focus on understanding what you want to add or change.{else}This is a **greenfield project** - I'll help you define the full game vision.{/if}"
### 2. Load Game Types Data
Load and prepare CSV data for intelligent game type classification:
- Load `{gameTypesCSV}` completely
- Parse columns: id, name, description, key_mechanics, detection_signals
- Store in memory for classification matching
### 3. Begin Discovery Conversation
**SELECT EXACTLY ONE DISCOVERY PATH based on document state:**
---
#### PATH A: Has Game Brief (briefCount > 0)
**Use this path when:** `briefCount > 0`
"As your game design peer, I've reviewed your game brief and have a great starting point. Let me share what I understand and you can refine or correct as needed.
**Based on your game brief:**
**Game Name:**
{{extracted_name_from_brief}}
**Core Concept:**
{{extracted_concept_from_brief}}
**Genre/Type:**
{{extracted_genre_from_brief}}
**Target Experience:**
{{extracted_experience_from_brief}}
{if projectDocsCount > 0}I also see you have existing project documentation. This GDD will define how new features integrate with your existing game.{/if}
**How does this align with your vision?** Should we refine any of these points or are there important aspects I'm missing?"
**AFTER this message, SKIP to Section 4.**
---
#### PATH B: No Brief but Has Brainstorming (briefCount == 0 AND brainstormingCount > 0)
**Use this path when:** `briefCount == 0 AND brainstormingCount > 0`
"As your game design peer, I've reviewed your brainstorming documents.
**Ideas I've extracted:**
{{summarize key concepts from brainstorming}}
Let's crystallize these ideas into a clear game concept:
- What's the core gameplay experience you want to create?
- What genre or type of game is this?
- What's the one thing that makes this game special?
I'll use this to identify the right game type framework for our GDD."
**AFTER this message, SKIP to Section 4.**
---
#### PATH C: No Documents - Greenfield (briefCount == 0 AND brainstormingCount == 0)
**Use this path when:** `briefCount == 0 AND brainstormingCount == 0`
"Let's start by understanding your game vision!
**Tell me about what you want to create:**
- What kind of game is it? (genre, style, references)
- What does the player do? (core actions, moment-to-moment gameplay)
- What makes it special or different?
- What experience or feeling do you want players to have?
I'll be listening for signals to help us identify the right game type framework."
**AFTER this message, SKIP to Section 4.**
---
### 4. Determine Game Type
As the user describes their game, match against `detection_signals` from `game-types.csv`:
#### Game Type Detection Logic
Compare user description against game-types.csv entries:
- Look for keyword matches from semicolon-separated detection_signals
- Examples: "platform;jump;run;2D;side-scroll" -> action-platformer
- Examples: "RPG;level;quest;stats;inventory" -> rpg
- Examples: "story;choices;narrative;dialogue" -> visual-novel
Store the best matching `game_type` id.
### 5. Present Classification for Validation
**Present to user:**
"Based on our conversation, I'm classifying this as:
**Game Type:** {matched_game_type_name} ({matched_game_type_id})
**Why this type:**
{explain the detection signals that matched}
**This game type includes these focus areas:**
{key_mechanics from game-types.csv}
Does this sound right? If not, tell me what type better fits your vision and I'll adjust."
### 6. Load Game Type Guide
**After user confirms game type:**
- Load the corresponding game type guide: `{gameTypesFolder}/{game_type}.md`
- Store the guide content for use in step-07 (game-type specific sections)
- Update frontmatter: `game_type: '{game_type}'`
### 7. Capture Game Name
"What would you like to call this game? (Working title is fine)"
- Store in frontmatter: `game_name: '{user_provided_name}'`
### 8. Generate Core Concept Content
Based on the conversation, prepare the content to append to the document:
#### Content Structure:
```markdown
## Executive Summary
### Game Name
{{game_name}}
### Core Concept
{{description - 2-3 paragraphs describing the game concept}}
### Game Type
**Type:** {{game_type_name}}
**Framework:** This GDD uses the {{game_type}} template with type-specific sections for {{key_mechanics}}
```
### 9. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Executive Summary based on our conversation. This will be the opening section of your GDD.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 8]
**Select an Option:**
[A] Advanced Elicitation - Let's dive deeper and refine this content
[P] Party Mode - Bring in different perspectives to improve this
[C] Continue - Save this and move to Platforms & Audience (Step 3 of 14)"
### 10. Handle Menu Selection
#### IF A (Advanced Elicitation):
- Execute {advancedElicitationTask} with the current content
- Process the enhanced content that comes back
- Ask user: "Accept these changes to the Core Concept? (y/n)"
- If yes: Update the content with improvements, then return to A/P/C menu
- If no: Keep original content, then return to A/P/C menu
#### IF P (Party Mode):
- Execute {partyModeWorkflow} with the current content
- Process the collaborative improvements that come back
- Ask user: "Accept these changes to the Core Concept? (y/n)"
- If yes: Update the content with improvements, then return to A/P/C menu
- If no: Keep original content, then return to A/P/C menu
#### IF C (Continue):
- Append the final content to `{outputFile}`
- Update frontmatter: `stepsCompleted: [1, 2]`, `game_type: '{game_type}'`, `game_name: '{game_name}'`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [core concept content finalized and saved to document with frontmatter updated including game_type and game_name], will you then load and read fully `{nextStepFile}` to execute and begin platforms definition.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Document counts read from frontmatter and announced
- Game types CSV loaded and used effectively
- **Correct discovery path selected based on document counts**
- Input documents analyzed and leveraged for head start
- Game type identified and validated with user
- Game type guide loaded and stored for later use
- Game name captured and stored in frontmatter
- Core concept content generated collaboratively
- A/P/C menu presented and handled correctly
- Content properly appended to document when C selected
- Frontmatter updated with stepsCompleted: [1, 2], game_type, game_name
### SYSTEM FAILURE:
- **Not reading documentCounts from frontmatter first**
- **Executing multiple discovery paths instead of exactly one**
- Not loading game-types.csv for classification
- Not validating game type with user before proceeding
- Generating detailed content without real user input
- Not loading the game type guide file
- Not capturing game name
- Not presenting A/P/C menu after content generation
- Appending content without user selecting 'C'
**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

246
src/modules/bmgd/workflows/2-design/gdd/steps/step-03-platforms.md
View File

@@ -1,246 +0,0 @@
---
name: 'step-03-platforms'
description: 'Define target platforms and target audience for the game'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-03-platforms.md'
nextStepFile: './step-04-vision.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.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: Platforms & Audience
**Progress: Step 3 of 14** - Next: Goals & Vision
## STEP GOAL:
Define the target platform(s) for the game and establish a clear picture of the target audience, including demographics, gaming experience level, and preferred play patterns.
## 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
- Platform and audience decisions drive many downstream choices - take this seriously
### Step-Specific Rules:
- Focus on platform capabilities and audience characteristics
- FORBIDDEN to generate detailed content without real user input
- Consider platform-specific constraints (controls, performance, monetization)
- Approach: Guide user through considerations they may not have thought about
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Present A/P/C menu after generating content for each section
- ONLY save when user chooses C (Continue)
- Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step
- FORBIDDEN to load next step until C is selected
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Explore platform constraints and audience nuances deeper
- **P (Party Mode)**: Get multiple perspectives on platform/audience decisions
- **C (Continue)**: Save the content to the document and proceed to next step
## CONTEXT BOUNDARIES:
- Game type and core concept from step 2 are available
- Platform choice affects many downstream decisions
- Audience definition affects tone, complexity, and accessibility
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Platform Discovery
**Guide user through platform selection:**
"Now let's talk about where players will experience {{game_name}}.
**Platform Options to Consider:**
| Platform | Considerations |
| ---------------------------- | ------------------------------------------------------------------------ |
| **PC (Steam/Epic)** | Full keyboard/mouse, highest specs, Steam achievements, workshop support |
| **Web Browser** | Instant access, limited performance, broad reach, touch/mouse hybrid |
| **Mobile (iOS/Android)** | Touch controls, short sessions, IAP monetization, battery/thermal limits |
| **Console (Switch/PS/Xbox)** | Controller-first, certification requirements, couch multiplayer |
| **VR (Quest/PCVR)** | Motion controls, comfort considerations, presence |
**For {{game_type}} games, common platform choices include:** {platform_suggestions_from_game_type}
**Questions to consider:**
1. Where do your target players primarily game?
2. Does your core gameplay work well with {platform} input methods?
3. Are you targeting a primary platform with potential ports later?
What platform(s) are you targeting?"
### 2. Capture Platform Details
**After user responds:**
Document:
- Primary platform (if multiple)
- Platform-specific control schemes
- Performance considerations (60fps target, resolution, etc.)
- Platform-specific features to leverage (achievements, cloud saves, etc.)
### 3. Audience Discovery
**Guide user through audience definition:**
"Now let's define who {{game_name}} is for.
**Demographics to Consider:**
- **Age Range:** What ages are you designing for? (affects content, complexity, monetization)
- **Gaming Experience:** Casual, core, or hardcore gamers?
- **Genre Familiarity:** Do they know {{game_type}} conventions, or are they new to the genre?
- **Session Length:** Quick mobile sessions (5-15 min) or deep PC sessions (1+ hour)?
**For {{game_type}} games, typical audiences include:**
{audience_suggestions_from_game_type}
Tell me about your ideal player. Who is this game for?"
### 4. Capture Audience Details
**After user responds:**
Document:
- Primary demographic
- Gaming experience level
- Genre familiarity expectations
- Preferred session lengths
- Secondary audiences (if any)
### 5. Generate Platforms & Audience Content
Based on the conversation, prepare the content:
```markdown
## Target Platform(s)
### Primary Platform
{{primary_platform}}
### Platform Considerations
{{platform_specific_details}}
### Control Scheme
{{control_scheme_for_platform}}
---
## Target Audience
### Demographics
{{target_demographics}}
### Gaming Experience
{{experience_level}} - {{experience_description}}
### Genre Familiarity
{{genre_familiarity_description}}
### Session Length
{{typical_session_length}} - {{session_description}}
### Player Motivations
{{what_draws_this_audience_to_this_game}}
```
### 6. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Platforms & Audience sections based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 5]
**Select an Option:**
[A] Advanced Elicitation - Explore platform/audience deeper
[P] Party Mode - Get other perspectives on these decisions
[C] Continue - Save this and move to Goals & Vision (Step 4 of 14)"
### 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]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [platforms and audience content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Platform(s) clearly identified with rationale
- Platform-specific considerations documented
- Target audience demographics defined
- Gaming experience level captured
- Session length expectations established
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3]
### SYSTEM FAILURE:
- Assuming platform without user confirmation
- Generating audience profile without user input
- Not considering platform-specific constraints
- 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.

230
src/modules/bmgd/workflows/2-design/gdd/steps/step-04-vision.md
View File

@@ -1,230 +0,0 @@
---
name: 'step-04-vision'
description: 'Define project goals, context, and unique selling points'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-04-vision.md'
nextStepFile: './step-05-core-gameplay.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.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: Goals & Vision
**Progress: Step 4 of 14** - Next: Core Gameplay
## STEP GOAL:
Define the project goals, background context for why this game matters now, and the unique selling points that differentiate this game from others in the market.
## 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
- Vision and USPs are critical for maintaining focus throughout development
### Step-Specific Rules:
- Focus on the "why" behind this game project
- FORBIDDEN to generate goals/USPs without real user input
- Help user articulate what makes their game worth making
- Approach: Challenge assumptions about differentiation
## 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
- FORBIDDEN to load next step until C is selected
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Dig deeper into goals and differentiation
- **P (Party Mode)**: Challenge and strengthen the vision with multiple perspectives
- **C (Continue)**: Save the content to the document and proceed to next step
## CONTEXT BOUNDARIES:
- Game type, platform, and audience from previous steps are available
- Goals should be achievable and measurable where possible
- USPs must be genuinely differentiating, not just features
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Goals Discovery
**Guide user through goal definition:**
"Let's define what success looks like for {{game_name}}.
**Types of Goals to Consider:**
| Goal Type | Examples |
| ----------------- | ---------------------------------------------------- |
| **Creative** | "Create a game that makes players feel powerful" |
| **Technical** | "Ship a stable 60fps experience on target platforms" |
| **Business** | "Achieve 10,000 wishlists before launch" |
| **Personal** | "Learn Godot through this project" |
| **Player Impact** | "Create a speedrunning community" |
**Questions to consider:**
1. What does success look like for this project?
2. What would make you proud to have shipped this?
3. Are there specific metrics you want to hit?
What are your 2-4 main goals for {{game_name}}?"
### 2. Context Discovery
**Guide user through background context:**
"Now let's capture why this game matters right now.
**Context Questions:**
- **Motivation:** What inspired you to make this game?
- **Timing:** Why is now the right time for this game?
- **Gap:** What's missing in the market that this fills?
- **Personal:** What unique perspective or experience do you bring?
Tell me the story behind {{game_name}}. Why are you making this?"
### 3. USP Discovery
**Guide user through unique selling points:**
"Now for the critical question: What makes {{game_name}} different?
**USP Framework:**
A strong USP answers: "Why would someone play THIS game instead of the alternatives?"
**Categories of Differentiation:**
- **Mechanical Innovation:** New gameplay systems or combinations
- **Narrative/World:** Unique setting, story, or characters
- **Art/Audio:** Distinctive aesthetic or soundscape
- **Audience Focus:** Serving an underserved player segment
- **Technical:** Performance, accessibility, or platform features
**For {{game_type}} games, common USPs include:**
{typical_usps_for_game_type}
But what's YOUR unique angle?
**Challenge Questions:**
1. If I removed your USP, would the game still be interesting?
2. Can another developer easily copy this USP?
3. Does this USP matter to your target audience?
What 2-4 things make {{game_name}} genuinely different?"
### 4. Generate Vision Content
Based on the conversation, prepare the content:
```markdown
## Goals and Context
### Project Goals
{{goals_list_with_descriptions}}
### Background and Rationale
{{context_narrative}}
---
## Unique Selling Points (USPs)
{{usps_with_descriptions}}
### Competitive Positioning
{{how_this_game_stands_out_in_the_market}}
```
### 5. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Goals & Vision sections based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 4]
**Select an Option:**
[A] Advanced Elicitation - Challenge and strengthen these points
[P] Party Mode - Get other perspectives on differentiation
[C] Continue - Save this and move to Core Gameplay (Step 5 of 14)"
### 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 [vision content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- 2-4 clear, achievable goals defined
- Background context captures the "why"
- USPs are genuinely differentiating, not just features
- Competitive positioning is clear
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3, 4]
### SYSTEM FAILURE:
- Generating generic goals without user input
- USPs that are just feature lists, not differentiation
- Not challenging weak USPs
- 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.

259
src/modules/bmgd/workflows/2-design/gdd/steps/step-05-core-gameplay.md
View File

@@ -1,259 +0,0 @@
---
name: 'step-05-core-gameplay'
description: 'Define game pillars, core gameplay loop, and win/loss conditions'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-05-core-gameplay.md'
nextStepFile: './step-06-mechanics.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.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: Core Gameplay
**Progress: Step 5 of 14** - Next: Game Mechanics
## STEP GOAL:
Define the fundamental gameplay elements: game pillars (core design tenets), the core gameplay loop (what players repeatedly do), and win/loss conditions (how players succeed or fail).
## 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
- These are GAME-DEFINING decisions - treat them with appropriate weight
- Every future decision should serve these pillars and loop
### Step-Specific Rules:
- Focus on the heart of the gameplay experience
- FORBIDDEN to generate pillars/loops without real user input
- Challenge: Do these pillars and loop serve the stated USPs?
- Approach: Help user think through the player experience
## 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
- FORBIDDEN to load next step until C is selected
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Deep dive into the player experience
- **P (Party Mode)**: Test these fundamentals with multiple perspectives
- **C (Continue)**: Save the content to the document and proceed to next step
## CONTEXT BOUNDARIES:
- All previous context (type, platform, audience, goals, USPs) available
- Pillars are the "constitution" that guides all design decisions
- Core loop is what players do 80% of the time
- Win/loss conditions provide motivation and stakes
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Game Pillars Discovery
**Guide user through pillar definition:**
"Now we define the core pillars - the fundamental design principles that every feature must serve.
**What are Game Pillars?**
Pillars are 2-4 non-negotiable design tenets. Every mechanic, system, and feature should support at least one pillar. If something doesn't serve a pillar, question whether it belongs.
**Examples of Pillars:**
| Game | Pillars |
| -------------- | -------------------------------------------------- |
| **Dark Souls** | Challenge, Discovery, Consequence |
| **Celeste** | Tight Controls, Accessibility, Emotional Narrative |
| **Minecraft** | Creativity, Exploration, Player Agency |
| **Dead Cells** | Mastery, Variety, Momentum |
**For your {{game_type}} with USPs of {{usps}}:**
What 2-4 pillars will define every design decision in {{game_name}}?"
### 2. Core Loop Discovery
**Guide user through loop definition:**
"Now let's define the core gameplay loop - the cycle of actions players repeat throughout the game.
**Core Loop Structure:**
A good loop has: **Action -> Feedback -> Reward -> Motivation to repeat**
**Examples:**
| Game | Core Loop |
| ------------- | ---------------------------------------------------------------------- |
| **Roguelike** | Enter dungeon -> Fight/loot -> Die/extract -> Upgrade -> Enter dungeon |
| **Puzzle** | See puzzle -> Analyze -> Attempt -> Succeed/fail -> Next puzzle |
| **FPS** | Engage enemy -> Shoot -> Kill/die -> Respawn/proceed -> Engage |
**For {{game_type}} games, typical loops include:**
{typical_loops_for_game_type}
**Questions to consider:**
1. What does the player do most of the time?
2. What makes each loop iteration feel different from the last?
3. How long is one loop cycle? (seconds, minutes, hours?)
Describe the core loop for {{game_name}}."
### 3. Win/Loss Conditions Discovery
**Guide user through win/loss definition:**
"Finally, let's define how players succeed and fail.
**Win/Loss Framework:**
| Condition Type | Examples |
| -------------- | --------------------------------------------------------------- |
| **Victory** | Beat final boss, reach score, complete story, survive time |
| **Failure** | Run out of lives, time expires, resources depleted, story fails |
| **Soft Fail** | Lose progress, restart level, dropped loot |
| **No Failure** | Sandbox games, creative tools, walking sims |
**Questions to consider:**
1. Is there a definitive "win state" or is success ongoing?
2. What happens when players fail? How punishing is it?
3. Are there multiple win/lose conditions (lives AND time)?
4. Does failure teach the player something?
How do players win and lose in {{game_name}}?"
### 4. Generate Core Gameplay Content
Based on the conversation, prepare the content:
```markdown
## Core Gameplay
### Game Pillars
{{pillar_list_with_descriptions}}
**Pillar Prioritization:** When pillars conflict, prioritize in this order:
{{pillar_priority_order}}
### Core Gameplay Loop
{{loop_description}}
**Loop Diagram:**
{{text_based_loop_visualization}}
**Loop Timing:** {{typical_loop_duration}}
**Loop Variation:** {{what_makes_each_iteration_different}}
### Win/Loss Conditions
#### Victory Conditions
{{win_conditions}}
#### Failure Conditions
{{loss_conditions}}
#### Failure Recovery
{{what_happens_on_failure}}
```
### 5. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Core Gameplay sections 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 USPs?
- Does the core loop deliver on your pillars?
- Do win/loss conditions create appropriate stakes?
**Select an Option:**
[A] Advanced Elicitation - Stress test these fundamentals
[P] Party Mode - Get other perspectives on the core design
[C] Continue - Save this and move to Game Mechanics (Step 6 of 14)"
### 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]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [core gameplay content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- 2-4 clear, actionable pillars defined
- Pillar prioritization established for conflicts
- Core loop clearly described with timing and variation
- Win/loss conditions appropriate for game type
- Failure recovery explained
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5]
### SYSTEM FAILURE:
- Generic pillars that don't guide decisions
- Core loop that doesn't match the game type
- Generating content without real user input
- Win/loss conditions misaligned with stated 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.

250
src/modules/bmgd/workflows/2-design/gdd/steps/step-06-mechanics.md
View File

@@ -1,250 +0,0 @@
---
name: 'step-06-mechanics'
description: 'Define primary game mechanics and control schemes'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-06-mechanics.md'
nextStepFile: './step-07-game-type.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.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: Game Mechanics
**Progress: Step 6 of 14** - Next: Game Type Specifics
## STEP GOAL:
Define the primary game mechanics that players interact with and the control scheme/input methods for the target platform(s).
## 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
- Mechanics must serve the pillars and core loop defined in step 5
- Controls must work for the target platform defined in step 3
### Step-Specific Rules:
- Focus on moment-to-moment player interactions
- FORBIDDEN to generate mechanics without real user input
- Challenge: Does each mechanic serve a pillar?
- Approach: Start with verbs - what does the player DO?
## 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
- FORBIDDEN to load next step until C is selected
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Deep dive into mechanic interactions and edge cases
- **P (Party Mode)**: Test mechanic clarity with multiple perspectives
- **C (Continue)**: Save the content to the document and proceed to next step
## CONTEXT BOUNDARIES:
- All previous context available (especially pillars and platform)
- Mechanics are the building blocks of gameplay
- Controls must feel good on target platform(s)
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Primary Mechanics Discovery
**Guide user through mechanics definition:**
"Let's define the primary mechanics - the core actions players perform to engage with your game.
**Mechanics Framework:**
Think in terms of VERBS - what does the player DO?
| Mechanic Category | Example Verbs |
| ----------------- | ---------------------------------------- |
| **Movement** | Run, jump, dash, climb, swim, fly |
| **Combat** | Attack, block, dodge, parry, aim, shoot |
| **Interaction** | Talk, pickup, use, craft, build, destroy |
| **Resource** | Collect, spend, trade, manage, invest |
| **Information** | Discover, read, scan, analyze, remember |
| **Social** | Cooperate, compete, trade, communicate |
**For {{game_type}} games, key mechanics typically include:**
{typical_mechanics_for_game_type}
**Your core loop is:** {{core_loop}}
**Your pillars are:** {{pillars}}
**Questions to consider:**
1. What are the 3-5 most important things players do?
2. Which mechanics support which pillars?
3. How do mechanics combine or interact?
What are the primary mechanics in {{game_name}}?"
### 2. Mechanics Deep Dive
**For each mechanic identified, ask:**
"Let's detail **{{mechanic_name}}**:
- **When does the player use this?** (constantly, situationally, rarely)
- **What skill does it test?** (timing, positioning, strategy, knowledge)
- **How does it feel?** (snappy, weighty, floaty, precise)
- **How does it progress?** (unlocks, upgrades, mastery)
- **How does it interact with other mechanics?**"
### 3. Controls Discovery
**Guide user through control scheme definition:**
"Now let's map these mechanics to controls for {{primary_platform}}.
**Control Considerations:**
| Platform | Key Considerations |
| ----------- | ------------------------------------------------------------------ |
| **PC** | Keyboard/mouse precision, rebindable keys, many available inputs |
| **Console** | Limited buttons, shoulder triggers, stick deadzone, rumble |
| **Mobile** | Touch targets, gesture clarity, screen real estate, one-hand play? |
| **VR** | Motion control, tracked hands, comfort, physical space |
**Control Design Principles:**
1. **Frequency = Accessibility:** Common actions get easy-to-reach inputs
2. **Similar actions, similar buttons:** Jump/interact shouldn't be opposite hands
3. **No hand gymnastics:** Avoid requiring uncomfortable button combos
4. **Platform conventions:** Use expected mappings where appropriate
**For {{game_type}} on {{platform}}, typical control schemes include:**
{typical_controls_for_game_type_and_platform}
How do you want controls to work in {{game_name}}?"
### 4. Generate Mechanics Content
Based on the conversation, prepare the content:
```markdown
## Game Mechanics
### Primary Mechanics
{{mechanics_list_with_details}}
### Mechanic Interactions
{{how_mechanics_combine}}
### Mechanic Progression
{{how_mechanics_evolve_or_unlock}}
---
## Controls and Input
### Control Scheme ({{primary_platform}})
{{control_mapping_table_or_description}}
### Input Feel
{{how_controls_should_feel}}
### Accessibility Controls
{{planned_accessibility_options}}
```
### 5. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Mechanics & Controls sections based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 4]
**Validation Check:**
- Does each mechanic serve at least one pillar?
- Do controls feel natural for the platform?
- Are common actions easily accessible?
**Select an Option:**
[A] Advanced Elicitation - Deep dive into mechanic feel and edge cases
[P] Party Mode - Test these mechanics with other perspectives
[C] Continue - Save this and move to Game Type Specifics (Step 7 of 14)"
### 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 [mechanics content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- 3-5 primary mechanics clearly defined
- Each mechanic linked to pillars
- Mechanic interactions described
- Control scheme appropriate for platform
- Input feel considerations captured
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6]
### SYSTEM FAILURE:
- Mechanics that don't serve pillars
- Controls inappropriate for target platform
- Generating content without real user input
- Missing mechanic interactions
- 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.

267
src/modules/bmgd/workflows/2-design/gdd/steps/step-07-game-type.md
View File

@@ -1,267 +0,0 @@
---
name: 'step-07-game-type'
description: 'Process game-type specific sections from the loaded game type guide'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-07-game-type.md'
nextStepFile: './step-08-progression.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.md'
# Game Type Resources
gameTypesFolder: '{workflow_path}/game-types'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 7: Game Type Specifics
**Progress: Step 7 of 14** - Next: Progression & Balance
## STEP GOAL:
Process the game-type specific sections from the loaded game type guide ({game_type}.md). Each game type has unique sections that must be addressed (e.g., RPGs need character systems, platformers need movement feel, etc.).
## 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
- Game type guides contain expert knowledge for specific genres
- This step varies significantly based on game type
### Step-Specific Rules:
- CRITICAL: Load and process the game type guide file
- Each section in the guide should be elicited from user
- FORBIDDEN to generate type-specific content without user input
- Some game types have optional sections - respect them
## EXECUTION PROTOCOLS:
- Load the game type guide from `{gameTypesFolder}/{game_type}.md`
- Process each section in the guide sequentially
- Present A/P/C menu after completing all type-specific sections
- 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 genre-specific elements
- **P (Party Mode)**: Get genre expert perspectives
- **C (Continue)**: Save the content to the document and proceed to next step
## CONTEXT BOUNDARIES:
- Game type was determined in step 2 and stored in frontmatter
- Game type guide should already be loaded in memory from step 2
- All previous context (pillars, mechanics, etc.) available
- Type-specific content goes in the {{GAME_TYPE_SPECIFIC_SECTIONS}} placeholder
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Load Game Type Guide
**CRITICAL FIRST ACTION:**
- Read `game_type` from frontmatter
- If not already loaded, load `{gameTypesFolder}/{game_type}.md`
- Parse the guide to identify all sections that need elicitation
**Announce to user:**
"Now we'll work through the **{{game_type}}** specific sections. This game type has unique design elements that we need to define.
**{{game_type}} requires these specific sections:**
{list_sections_from_game_type_guide}
Let's work through each one."
### 2. Process Each Section from Guide
**For each section defined in the game type guide:**
The game type guide will have sections marked with placeholders like `{{section_name}}`. For each:
1. **Read the guidance** in the guide for this section
2. **Present the guidance and questions** to the user
3. **Elicit user input** for this specific section
4. **Store the content** for final assembly
**Example flow for an RPG game type:**
"**Character System**
Your game type guide suggests addressing:
- Character creation options
- Attribute/stat system
- Class or build system
- Character progression path
{guidance_from_guide}
How do you want the character system to work in {{game_name}}?"
### 3. Handle Optional Sections
Some game type guides have optional sections marked with `[optional]` or similar:
- Present optional sections to user
- Ask: "This section is optional for {{game_type}}. Would you like to define {{section_name}}?"
- If yes: elicit content
- If no: skip and note as "Not applicable for this game"
### 4. Handle Narrative Flags
Some game type guides include narrative flags:
- `<narrative-workflow-critical>` - Story is essential for this game type
- `<narrative-workflow-recommended>` - Story would enhance this game type
If flag found:
- Store `needs_narrative = true` for use in step 14
- Note to user: "This game type typically benefits from dedicated narrative design. We'll address this in the final step."
### 5. Generate Game Type Content
Based on all elicited sections, prepare the content:
```markdown
## {{game_type_name}} Specific Design
{{assembled_sections_from_guide_elicitation}}
```
The content structure will vary based on game type:
**Example for RPG:**
```markdown
## RPG Specific Design
### Character System
{{character_system_content}}
### Combat System
{{combat_system_content}}
### Inventory & Equipment
{{inventory_content}}
### Quest System
{{quest_system_content}}
```
**Example for Platformer:**
```markdown
## Platformer Specific Design
### Movement Feel
{{movement_feel_content}}
### Jump Mechanics
{{jump_mechanics_content}}
### Hazards & Enemies
{{hazards_content}}
### Collectibles
{{collectibles_content}}
```
### 6. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the {{game_type}} Specific Design sections based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 5]
**Validation Check:**
- Does each section align with your core pillars?
- Have we covered all required elements for {{game_type}}?
- Any genre conventions you want to subvert?
**Select an Option:**
[A] Advanced Elicitation - Deep dive into genre specifics
[P] Party Mode - Get genre expert perspectives
[C] Continue - Save this and move to Progression & Balance (Step 8 of 14)"
### 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}` in place of {{GAME_TYPE_SPECIFIC_SECTIONS}}
- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]`
- If `needs_narrative` flag was set, store in frontmatter
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [game type content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Game type guide loaded and parsed
- All required sections elicited from user
- Optional sections offered and handled appropriately
- Narrative flags detected and stored
- Content matches game type guide structure
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7]
### SYSTEM FAILURE:
- Not loading the game type guide file
- Generating type-specific content without user input
- Missing required sections from the guide
- Ignoring narrative flags
- 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.

273
src/modules/bmgd/workflows/2-design/gdd/steps/step-08-progression.md
View File

@@ -1,273 +0,0 @@
---
name: 'step-08-progression'
description: 'Define player progression systems and game balance'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-08-progression.md'
nextStepFile: './step-09-levels.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 8: Progression & Balance
**Progress: Step 8 of 14** - Next: Level Design
## STEP GOAL:
Define how players progress through the game (skill, power, narrative, etc.), the difficulty curve, and any economy or resource systems.
## 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
- Progression is what keeps players engaged over time
- Balance determines if the game feels fair and fun
### Step-Specific Rules:
- Focus on player growth and challenge scaling
- FORBIDDEN to generate progression systems without user input
- Some games have no explicit progression - that's valid
- Economy/resources are optional - ask before including
## 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, 8]` before loading next step
- FORBIDDEN to load next step until C is selected
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Deep dive into progression curves and balance
- **P (Party Mode)**: Test progression ideas with multiple perspectives
- **C (Continue)**: Save the content to the document and proceed to next step
## CONTEXT BOUNDARIES:
- All previous context available (especially core loop and mechanics)
- Progression should reinforce the core loop
- Balance affects all previously defined mechanics
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Player Progression Discovery
**Guide user through progression definition:**
"Let's define how players grow and progress through {{game_name}}.
**Types of Progression:**
| Type | Description | Examples |
| -------------- | ------------------------------------------ | ------------------------- |
| **Skill** | Player gets better at the game | Dark Souls, Celeste |
| **Power** | Character gets stronger (stats, abilities) | RPGs, Metroidvanias |
| **Narrative** | Story unfolds and advances | Visual novels, adventures |
| **Content** | New levels, areas, or modes unlock | Most games |
| **Collection** | Gathering items, achievements | Completionist games |
| **Social** | Rank, reputation, community status | Competitive games |
**For {{game_type}} games, typical progression includes:**
{typical_progression_for_game_type}
**Questions to consider:**
1. What type(s) of progression does {{game_name}} have?
2. How long until players feel meaningful progress?
3. Is there a "meta" progression (between runs/sessions)?
How do players progress in {{game_name}}?"
### 2. Difficulty Curve Discovery
**Guide user through difficulty design:**
"Now let's design the difficulty curve.
**Difficulty Curve Patterns:**
| Pattern | Description | Best For |
| --------------------- | --------------------------------------- | ------------------------------ |
| **Linear** | Steady increase in challenge | Story games, first playthrough |
| **Sawtooth** | Build-release pattern (easy after hard) | Level-based games |
| **Exponential** | Gentle start, steep late-game | RPGs, incremental games |
| **Flat** | Consistent challenge throughout | Roguelikes, skill games |
| **Player-controlled** | User selects difficulty | Accessibility-focused |
**Questions to consider:**
1. How does challenge increase over time?
2. Are there difficulty spikes (bosses, skill checks)?
3. Can players adjust difficulty? How?
4. How do you handle players who are stuck?
Describe the difficulty curve for {{game_name}}."
### 3. Economy/Resources Discovery (Optional)
**Ask first:**
"Does {{game_name}} have an in-game economy or resource system?
Examples:
- Currency (gold, coins, gems)
- Crafting materials
- Energy/stamina systems
- Ammunition or consumables
If yes, we'll define it. If no, we'll skip this section."
**If yes:**
"Let's define the economy/resources:
**Economy Questions:**
1. What resources exist?
2. How are resources earned?
3. How are resources spent?
4. Is there inflation/scarcity design?
5. Are there sinks to remove resources?
6. Premium currency? (if F2P)
Describe the economy in {{game_name}}."
### 4. Generate Progression Content
Based on the conversation, prepare the content:
```markdown
## Progression and Balance
### Player Progression
{{progression_system_description}}
#### Progression Types
{{progression_types_used}}
#### Progression Pacing
{{how_fast_players_progress}}
### Difficulty Curve
{{difficulty_curve_description}}
#### Challenge Scaling
{{how_difficulty_increases}}
#### Difficulty Options
{{accessibility_and_difficulty_settings}}
### Economy and Resources
{{if_has_economy}}
{{economy_system_description}}
#### Resources
{{resource_types_and_purposes}}
#### Economy Flow
{{earn_and_spend_loop}}
{{/if_has_economy}}
{{if_no_economy}}
_This game does not feature an in-game economy or resource system._
{{/if_no_economy}}
```
### 5. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Progression & Balance sections based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 4]
**Validation Check:**
- Does progression reinforce your core loop?
- Is the difficulty curve appropriate for your audience?
- Does the economy (if any) feel fair?
**Select an Option:**
[A] Advanced Elicitation - Deep dive into balance and pacing
[P] Party Mode - Test these systems with other perspectives
[C] Continue - Save this and move to Level Design (Step 9 of 14)"
### 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, 7, 8]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [progression content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Progression system clearly defined
- Difficulty curve appropriate for game type and audience
- Economy handled correctly (defined or explicitly skipped)
- Balance considerations documented
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]
### SYSTEM FAILURE:
- Generating progression without user input
- Assuming economy exists without asking
- Difficulty curve mismatched with audience
- 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.

265
src/modules/bmgd/workflows/2-design/gdd/steps/step-09-levels.md
View File

@@ -1,265 +0,0 @@
---
name: 'step-09-levels'
description: 'Define level design framework and level progression'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-09-levels.md'
nextStepFile: './step-10-art-audio.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 9: Level Design
**Progress: Step 9 of 14** - Next: Art & Audio
## STEP GOAL:
Define the level design framework including level types, structure, and how levels progress or unlock throughout the game.
## 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
- Level design is where mechanics meet content
- Not all games have "levels" - some have open worlds, others are endless
### Step-Specific Rules:
- Focus on spatial design and content structure
- FORBIDDEN to generate level designs without user input
- Adapt terminology to game type (levels, stages, areas, dungeons, etc.)
- Some games have no level structure - that's valid
## 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, 8, 9]` before loading next step
- FORBIDDEN to load next step until C is selected
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Deep dive into level design principles
- **P (Party Mode)**: Get perspectives on level structure
- **C (Continue)**: Save the content to the document and proceed to next step
## CONTEXT BOUNDARIES:
- All previous context available (especially mechanics and progression)
- Level design should teach and challenge using defined mechanics
- Structure should support defined progression system
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Determine Level Structure Type
**First, establish the structural approach:**
"Let's define how {{game_name}} structures its playable content.
**Structure Types:**
| Type | Description | Examples |
| -------------------- | --------------------------------- | --------------------------- |
| **Linear Levels** | Distinct stages played in order | Mario, Celeste |
| **Hub-Based** | Central area connecting levels | Mario 64, Hollow Knight |
| **Open World** | Large continuous space | Breath of the Wild, GTA |
| **Procedural** | Generated levels each playthrough | Spelunky, Dead Cells |
| **Arena/Match** | Self-contained competitive spaces | Fighting games, MOBAs |
| **Puzzle Sets** | Collections of puzzles | Portal, The Witness |
| **Narrative Scenes** | Story-driven segments | Visual novels, adventures |
| **Endless** | Infinite generated content | Endless runners, idle games |
**For {{game_type}} games, typical structures include:**
{typical_structures_for_game_type}
What structure best fits {{game_name}}?"
### 2. Level Types Discovery
**Based on structure choice, elicit level types:**
"Now let's define the types of {levels/areas/stages} in {{game_name}}.
**Questions to consider:**
1. What different environments or settings exist?
2. Are there tutorial levels? How are they integrated?
3. Are there boss levels or climax moments?
4. What's the shortest level? Longest?
5. Any special or secret levels?
Describe the types of {levels/areas/stages} in {{game_name}}."
### 3. Level Progression Discovery
**Guide user through progression structure:**
"Now let's define how players progress through {levels/areas/content}.
**Progression Models:**
| Model | Description | Best For |
| --------------------- | -------------------------------- | ---------------------- |
| **Linear Sequence** | 1 -> 2 -> 3 -> ... | Story games, tutorials |
| **Branching Paths** | Choices lead to different levels | Replayability |
| **Open Selection** | Player chooses order | Mega Man style |
| **Gated Progress** | Abilities unlock new areas | Metroidvania |
| **Score/Star Unlock** | Performance unlocks levels | Angry Birds style |
| **Story Unlock** | Narrative triggers unlock | Adventure games |
**Questions to consider:**
1. How do players unlock new {levels/areas}?
2. Can players replay previous {levels/areas}?
3. Is there a "world map" or selection screen?
4. How is the final {level/area} unlocked?
How do players progress through {{game_name}}'s content?"
### 4. Level Design Principles (Optional)
"Would you like to establish specific level design principles or guidelines for {{game_name}}?
Examples:
- 'Teach through play, never through text'
- 'Every room has one new idea'
- '30 second rule - something interesting every 30 seconds'
- 'Left is safety, right is danger'
These can guide consistent level design throughout development."
### 5. Generate Level Design Content
Based on the conversation, prepare the content:
```markdown
## Level Design Framework
### Structure Type
{{structure_type_description}}
### Level Types
{{level_types_list}}
#### Tutorial Integration
{{how_tutorials_work}}
#### Special Levels
{{boss_levels_secret_levels_etc}}
### Level Progression
{{progression_model_description}}
#### Unlock System
{{how_levels_unlock}}
#### Replayability
{{replay_and_revisit_mechanics}}
### Level Design Principles
{{if_has_principles}}
{{level_design_guidelines}}
{{/if_has_principles}}
{{if_no_principles}}
_Level design principles will be established during production._
{{/if_no_principles}}
```
### 6. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Level Design Framework based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 5]
**Validation Check:**
- Does the structure support your core loop?
- Does progression feel rewarding?
- Are level types varied enough to maintain interest?
**Select an Option:**
[A] Advanced Elicitation - Deep dive into level design specifics
[P] Party Mode - Get other perspectives on level structure
[C] Continue - Save this and move to Art & Audio (Step 10 of 14)"
### 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, 8, 9]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [level design content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Level structure type clearly identified
- Level types defined with variety
- Progression model documented
- Tutorial integration addressed
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]
### SYSTEM FAILURE:
- Generating level designs without user input
- Using wrong terminology for game type
- Structure doesn't support core loop
- 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.

256
src/modules/bmgd/workflows/2-design/gdd/steps/step-10-art-audio.md
View File

@@ -1,256 +0,0 @@
---
name: 'step-10-art-audio'
description: 'Define art style and audio direction'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-10-art-audio.md'
nextStepFile: './step-11-technical.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 10: Art & Audio
**Progress: Step 10 of 14** - Next: Technical Specs
## STEP GOAL:
Define the visual art style and audio/music direction for the game, establishing the aesthetic identity that will guide all asset creation.
## 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
- Art and audio define the player's emotional experience
- These decisions heavily impact scope and team requirements
### Step-Specific Rules:
- Focus on direction and mood, not specific asset lists
- FORBIDDEN to generate art/audio direction without user input
- Reference games or other media when helpful
- Consider platform constraints on art complexity
## 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, 8, 9, 10]` before loading next step
- FORBIDDEN to load next step until C is selected
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Deep dive into aesthetic choices
- **P (Party Mode)**: Get artistic perspectives
- **C (Continue)**: Save the content to the document and proceed to next step
## CONTEXT BOUNDARIES:
- All previous context available (especially platform and audience)
- Art style should match game pillars and tone
- Audio must work on target platform(s)
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Art Style Discovery
**Guide user through visual direction:**
"Let's define the visual identity of {{game_name}}.
**Art Style Categories:**
| Style | Description | Examples |
| --------------- | ---------------------------- | ------------------------- |
| **Pixel Art** | Retro-styled discrete pixels | Celeste, Shovel Knight |
| **Low-Poly** | Simple 3D geometry | Superhot, Monument Valley |
| **Hand-Drawn** | Illustration-like visuals | Cuphead, Hollow Knight |
| **Realistic** | Photorealistic graphics | AAA titles |
| **Stylized 3D** | Non-realistic 3D | Fortnite, Zelda: BotW |
| **Vector/Flat** | Clean shapes, minimal | Thomas Was Alone |
| **Mixed Media** | Combining multiple styles | Paper Mario |
**Visual Elements to Consider:**
- **Color Palette:** Vibrant, muted, monochromatic, complementary?
- **Lighting:** Dramatic, soft, realistic, stylized?
- **Camera:** 2D side, top-down, isometric, 3D third/first person?
- **Character Design:** Cute, realistic, abstract, iconic?
**For {{game_type}} on {{platform}}, common art styles include:**
{typical_art_styles_for_game_type}
What visual style do you envision for {{game_name}}?"
### 2. Art Reference Gathering
"Are there any games, films, or art that inspire the look of {{game_name}}?
Examples help communicate the vision:
- 'The lighting of Limbo with the colors of Journey'
- 'Pixel art like Hyper Light Drifter but with a warmer palette'
- 'Studio Ghibli-inspired environments'
What references capture the visual feel you want?"
### 3. Audio Direction Discovery
**Guide user through audio/music direction:**
"Now let's define the audio identity of {{game_name}}.
**Music Style Considerations:**
| Style | Mood | Examples |
| ------------------ | ------------------- | --------------------- |
| **Chiptune/8-bit** | Retro, energetic | Shovel Knight |
| **Orchestral** | Epic, emotional | Zelda, Final Fantasy |
| **Electronic** | Modern, driving | Hotline Miami, FURI |
| **Ambient** | Atmospheric, subtle | Journey, INSIDE |
| **Rock/Metal** | Intense, aggressive | DOOM, Devil May Cry |
| **Jazz/Lo-fi** | Chill, stylish | Persona, VA-11 Hall-A |
| **Dynamic** | Adapts to gameplay | DOOM, Ape Out |
**Sound Design Considerations:**
- **Feedback Sounds:** How responsive and punchy?
- **Environmental Audio:** How immersive?
- **Voice/Dialogue:** None, grunts, partial, full VO?
- **Accessibility:** Audio cues for visual elements?
**For {{game_type}} games, typical audio approaches include:**
{typical_audio_for_game_type}
What audio direction fits {{game_name}}?"
### 4. Generate Art & Audio Content
Based on the conversation, prepare the content:
```markdown
## Art and Audio Direction
### Art Style
{{art_style_description}}
#### Visual References
{{reference_games_and_media}}
#### Color Palette
{{color_direction}}
#### Camera and Perspective
{{camera_style}}
### Audio and Music
{{audio_direction_description}}
#### Music Style
{{music_genre_and_mood}}
#### Sound Design
{{sound_design_approach}}
#### Voice/Dialogue
{{voice_approach}}
### Aesthetic Goals
{{how_art_and_audio_support_game_pillars}}
```
### 5. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Art & Audio Direction based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 4]
**Validation Check:**
- Does the art style support your game pillars?
- Is the audio direction achievable for your scope?
- Do art and audio work together cohesively?
**Select an Option:**
[A] Advanced Elicitation - Deep dive into aesthetic details
[P] Party Mode - Get artistic perspectives
[C] Continue - Save this and move to Technical Specs (Step 11 of 14)"
### 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, 7, 8, 9, 10]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [art/audio content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Art style clearly defined with references
- Audio direction documented
- Aesthetic supports game pillars and tone
- Platform constraints considered
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
### SYSTEM FAILURE:
- Generating art/audio direction without user input
- Art style inappropriate for target platform
- Missing references that help communicate vision
- 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.

276
src/modules/bmgd/workflows/2-design/gdd/steps/step-11-technical.md
View File

@@ -1,276 +0,0 @@
---
name: 'step-11-technical'
description: 'Define technical specifications and requirements'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-11-technical.md'
nextStepFile: './step-12-epics.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 11: Technical Specifications
**Progress: Step 11 of 14** - Next: Epic Structure
## STEP GOAL:
Define technical requirements including performance targets, platform-specific details, and asset requirements. This provides a bridge to the architecture workflow.
## 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
- Technical specs inform the architecture workflow
- Not all technical decisions are made here - architecture comes later
### Step-Specific Rules:
- Focus on requirements, not implementation details
- FORBIDDEN to generate tech specs without user input
- Keep scope appropriate - detailed architecture comes in a separate workflow
- Reference target platform(s) from step 3
## 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, 8, 9, 10, 11]` before loading next step
- FORBIDDEN to load next step until C is selected
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Deep dive into technical requirements
- **P (Party Mode)**: Get technical perspectives
- **C (Continue)**: Save the content to the document and proceed to next step
## CONTEXT BOUNDARIES:
- All previous context available (especially platform from step 3)
- This is GDD-level specs, not architecture-level details
- Engine/framework selection happens in architecture workflow
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Performance Requirements Discovery
**Guide user through performance targets:**
"Let's define the technical requirements for {{game_name}}.
**Performance Targets:**
| Platform | Typical Targets |
| ----------- | ------------------------------------------- |
| **PC** | 60fps @ 1080p minimum, 4K optional |
| **Console** | 30fps or 60fps depending on visual fidelity |
| **Mobile** | 30fps, thermal management, battery life |
| **Web** | 30-60fps, file size under 50MB |
| **VR** | 72-90fps minimum, latency critical |
**For {{game_type}} on {{platform}}:**
**Questions to consider:**
1. What frame rate are you targeting?
2. What resolutions should be supported?
3. What's the acceptable load time?
4. Any specific performance priorities? (visuals vs frame rate)
What are your performance targets for {{game_name}}?"
### 2. Platform-Specific Requirements
**Guide user through platform details:**
"Now let's capture platform-specific considerations for {{platform}}.
**Platform-Specific Questions:**
**PC:**
- Minimum and recommended specs?
- Steam/Epic/itch.io features to support?
- Mod support planned?
- Cloud saves?
**Console:**
- Certification requirements awareness?
- Controller-only or hybrid input?
- Achievement/trophy integration?
**Mobile:**
- iOS minimum version? Android API level?
- Portrait, landscape, or both?
- Offline play required?
- In-app purchases planned?
**Web:**
- Target browsers?
- WebGL version?
- Maximum build size?
What platform-specific requirements matter for {{game_name}}?"
### 3. Asset Requirements Discovery
**Guide user through asset considerations:**
"Finally, let's document asset requirements and constraints.
**Asset Categories:**
| Category | Considerations |
| -------------------- | ------------------------------------- |
| **Sprites/Textures** | Resolution, count estimates, atlasing |
| **3D Models** | Poly budgets, LOD levels, rigging |
| **Animations** | Frame counts, skeletal vs sprite |
| **Audio** | Music tracks, SFX count, voice lines |
| **UI** | Resolution scaling, localization |
**Questions to consider:**
1. What are the major asset categories you'll need?
2. Any rough estimates on asset counts?
3. What quality level are you targeting?
4. Any external assets planned (asset store, licensed content)?
What are the key asset requirements for {{game_name}}?"
### 4. Generate Technical Content
Based on the conversation, prepare the content:
```markdown
## Technical Specifications
### Performance Requirements
{{performance_targets_description}}
#### Frame Rate Target
{{target_fps}}
#### Resolution Support
{{resolution_targets}}
#### Load Times
{{load_time_requirements}}
### Platform-Specific Details
{{platform_specific_requirements}}
#### {{platform}} Requirements
{{platform_details}}
### Asset Requirements
{{asset_requirements_overview}}
#### Art Assets
{{art_asset_requirements}}
#### Audio Assets
{{audio_asset_requirements}}
#### External Assets
{{third_party_asset_plans}}
### Technical Constraints
{{any_known_limitations_or_requirements}}
```
### 5. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Technical Specifications based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 4]
**Note:** This is GDD-level technical planning. Detailed architecture decisions (engine selection, specific technologies, system design) will be addressed in the Architecture workflow after the GDD is complete.
**Select an Option:**
[A] Advanced Elicitation - Deep dive into technical requirements
[P] Party Mode - Get technical perspectives
[C] Continue - Save this and move to Epic Structure (Step 12 of 14)"
### 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, 7, 8, 9, 10, 11]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [technical content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Performance targets clearly defined
- Platform-specific requirements documented
- Asset requirements outlined
- Scope appropriate for GDD (not architecture-level detail)
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
### SYSTEM FAILURE:
- Generating tech specs without user input
- Going too deep into architecture details
- Missing key platform requirements
- 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.

285
src/modules/bmgd/workflows/2-design/gdd/steps/step-12-epics.md
View File

@@ -1,285 +0,0 @@
---
name: 'step-12-epics'
description: 'Define development epics and high-level story breakdown'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-12-epics.md'
nextStepFile: './step-13-metrics.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.md'
epicsOutputFile: '{output_folder}/epics.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 12: Epic Structure
**Progress: Step 12 of 14** - Next: Success Metrics
## STEP GOAL:
Translate the game features defined throughout the GDD into development epics, each with a clear scope and list of high-level stories. This provides the foundation for sprint planning.
## 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
- Epics bridge design (GDD) to implementation (sprints)
- Epic scope should be completable in 1-4 sprints
### Step-Specific Rules:
- Focus on feature groupings, not detailed task breakdowns
- FORBIDDEN to generate epics without user input
- Each epic should deliver playable value
- Stories are high-level here - detailed stories come in sprint planning
## 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, 8, 9, 10, 11, 12]` before loading next step
- FORBIDDEN to load next step until C is selected
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Refine epic scopes and boundaries
- **P (Party Mode)**: Get perspectives on epic organization
- **C (Continue)**: Save the content to the document and proceed to next step
## CONTEXT BOUNDARIES:
- All GDD content from previous steps available
- Epics should map to game pillars and features
- This creates both GDD epic summary and detailed epics.md file
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Review Game Features for Epic Candidates
**Analyze the GDD content:**
"Let's organize {{game_name}}'s features into development epics.
Based on everything we've defined, here are the major feature areas I've identified:
**From Core Gameplay:** {{core_loop_features}}
**From Mechanics:** {{mechanics_features}}
**From Game Type Specifics:** {{game_type_features}}
**From Progression:** {{progression_features}}
**From Level Design:** {{level_features}}
**From Art/Audio:** {{art_audio_features}}
**From Technical:** {{technical_features}}
**Epic Organization Principles:**
1. **Playable Milestones:** Each epic should result in something playable
2. **Dependency Awareness:** Some epics must come before others
3. **Vertical Slices:** Early epics often prove core gameplay
4. **Scope Control:** 1-4 sprints per epic is ideal
How would you like to group these features into epics?"
### 2. Define Epic Structure
**For each epic, elicit:**
"Let's define **Epic {{number}}: {{epic_name}}**
**Epic Definition Questions:**
1. **Goal:** What does completing this epic achieve?
2. **Includes:** What features/systems are in this epic?
3. **Excludes:** What specifically is NOT in this epic?
4. **Dependencies:** What epics must come before this?
5. **Deliverable:** What's the playable result?
Describe this epic."
### 3. Generate High-Level Stories
**For each epic, generate story candidates:**
"For **Epic {{number}}: {{epic_name}}**, let's identify high-level stories.
**Story Principles:**
- Each story is independently valuable
- Stories should be completable in 1-3 days
- Use format: 'As a [player], I can [action] so that [benefit]'
What are the main stories in this epic?"
### 4. Determine Epic Order and Dependencies
**Guide user through sequencing:**
"Now let's determine the order for these epics.
**Common Epic Sequences:**
1. **Foundation First:** Core systems before content
2. **Vertical Slice Early:** Prove gameplay ASAP
3. **Polish Last:** Visual/audio polish after mechanics solid
**Your epics:**
{{list_of_epics}}
What order makes sense for {{game_name}}?"
### 5. Generate Epic Content
Based on the conversation, prepare two outputs:
**A. GDD Epic Summary (goes in gdd.md):**
```markdown
## Development Epics
### Epic Overview
| # | Epic Name | Scope | Dependencies | Est. Stories |
| --- | --------- | ----- | ------------ | ------------ |
{{epic_table}}
### Recommended Sequence
{{epic_sequence_with_rationale}}
### Vertical Slice
**The first playable milestone:** {{vertical_slice_description}}
```
**B. Detailed Epics File (goes in epics.md):**
```markdown
# {{game_name}} - Development Epics
## Epic Overview
{{epic_overview_table}}
---
## Epic 1: {{epic_1_name}}
### Goal
{{epic_1_goal}}
### Scope
**Includes:**
{{epic_1_includes}}
**Excludes:**
{{epic_1_excludes}}
### Dependencies
{{epic_1_dependencies}}
### Deliverable
{{epic_1_deliverable}}
### Stories
{{epic_1_stories_list}}
---
{{repeat_for_each_epic}}
```
### 6. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Epic Structure based on our conversation.
**For the GDD (gdd.md):**
[Show GDD epic summary]
**For the Epics file (epics.md):**
[Show detailed epics structure]
**Validation Check:**
- Does each epic deliver playable value?
- Is the sequence achievable?
- Are dependencies clear?
**Select an Option:**
[A] Advanced Elicitation - Refine epic organization
[P] Party Mode - Get perspectives on epic structure
[C] Continue - Save this and move to Success Metrics (Step 13 of 14)"
### 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 epic summary to `{outputFile}`
- Write detailed epics to `{epicsOutputFile}`
- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [both epic content files saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Epics cover all major game features
- Each epic has clear scope and deliverable
- Dependencies identified and sequenced
- Both gdd.md and epics.md updated
- High-level stories drafted for each epic
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted
### SYSTEM FAILURE:
- Generating epics without user input
- Epics that don't deliver playable value
- Missing key features from GDD
- Not creating separate epics.md file
- 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.

251
src/modules/bmgd/workflows/2-design/gdd/steps/step-13-metrics.md
View File

@@ -1,251 +0,0 @@
---
name: 'step-13-metrics'
description: 'Define success metrics for technical and gameplay evaluation'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-13-metrics.md'
nextStepFile: './step-14-complete.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.md'
# Task References
advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
---
# Step 13: Success Metrics
**Progress: Step 13 of 14** - Next: Final Steps
## STEP GOAL:
Define measurable success metrics for both technical performance and gameplay quality. These metrics help evaluate whether the game meets its design goals.
## 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
- Metrics should be measurable and actionable
- Focus on metrics that indicate design success, not just technical success
### Step-Specific Rules:
- Focus on defining what success looks like
- FORBIDDEN to generate metrics without user input
- Metrics should relate back to game pillars and goals
- Include both quantitative and qualitative measures
## 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, 8, 9, 10, 11, 12, 13]` before loading next step
- FORBIDDEN to load next step until C is selected
## COLLABORATION MENUS (A/P/C):
- **A (Advanced Elicitation)**: Deep dive into metric selection
- **P (Party Mode)**: Get perspectives on success criteria
- **C (Continue)**: Save the content to the document and proceed to next step
## CONTEXT BOUNDARIES:
- All GDD content from previous steps available
- Metrics should map to stated goals and pillars
- Technical metrics from performance requirements
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Technical Metrics Discovery
**Guide user through technical success criteria:**
"Let's define how we'll measure technical success for {{game_name}}.
**Technical Metric Categories:**
| Category | Example Metrics |
| --------------- | ------------------------------------------------ |
| **Performance** | Frame rate consistency, load times, memory usage |
| **Stability** | Crash rate, bug severity distribution |
| **Platform** | Certification pass rate, store review score |
| **Build** | Build time, test coverage, asset size |
**Your performance targets from earlier:**
- Frame rate: {{target_fps}}
- Platform: {{platform}}
**Questions to consider:**
1. What technical metrics matter most for {{game_type}}?
2. How will you measure performance in the field?
3. What's an acceptable crash rate?
4. Are there platform-specific metrics to track?
What technical metrics will indicate success for {{game_name}}?"
### 2. Gameplay Metrics Discovery
**Guide user through gameplay success criteria:**
"Now let's define gameplay metrics - how we know the design is working.
**Gameplay Metric Categories:**
| Category | Example Metrics |
| ----------------------- | ------------------------------------------------- |
| **Engagement** | Session length, sessions per week, retention |
| **Progression** | Completion rates, time-to-milestone, churn points |
| **Difficulty** | Death/retry rates, difficulty setting usage |
| **Feature Usage** | Which mechanics are used, feature discovery |
| **Player Satisfaction** | Ratings, reviews, NPS |
**Your game pillars are:** {{pillars}}
**Your goals are:** {{goals}}
**Questions to consider:**
1. How will you know if players are having the intended experience?
2. What retention rates would indicate success?
3. How will you identify frustration points?
4. What playtesting metrics will you track?
What gameplay metrics will indicate success for {{game_name}}?"
### 3. Qualitative Success Criteria
**Guide user through qualitative measures:**
"Finally, let's define qualitative success criteria - things that are harder to measure but equally important.
**Qualitative Criteria Examples:**
- 'Players describe the game using our pillar words'
- 'Streamers enjoy playing without instruction'
- 'Community creates fan content'
- 'Players recommend to friends'
- 'Reviews mention the unique selling points'
What qualitative signs would tell you {{game_name}} is successful?"
### 4. Generate Metrics Content
Based on the conversation, prepare the content:
```markdown
## Success Metrics
### Technical Metrics
{{technical_metrics_list}}
#### Key Technical KPIs
| Metric | Target | Measurement Method |
| ------ | ------ | ------------------ |
{{technical_kpi_table}}
### Gameplay Metrics
{{gameplay_metrics_list}}
#### Key Gameplay KPIs
| Metric | Target | Measurement Method |
| ------ | ------ | ------------------ |
{{gameplay_kpi_table}}
### Qualitative Success Criteria
{{qualitative_criteria_list}}
### Metric Review Cadence
{{when_and_how_metrics_will_be_reviewed}}
```
### 5. Present Content and Menu
Show the generated content to the user and present:
"I've drafted the Success Metrics based on our conversation.
**Here's what I'll add to the document:**
[Show the complete markdown content from step 4]
**Validation Check:**
- Do metrics align with your game pillars?
- Are targets achievable and measurable?
- Can you actually collect this data?
**Select an Option:**
[A] Advanced Elicitation - Refine metric selection
[P] Party Mode - Get perspectives on success criteria
[C] Continue - Save this and move to Final Steps (Step 14 of 14)"
### 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, 7, 8, 9, 10, 11, 12, 13]`
- Load `{nextStepFile}`
## CRITICAL STEP COMPLETION NOTE
ONLY WHEN [C continue option] is selected and [metrics content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Technical metrics defined with targets
- Gameplay metrics tied to pillars and goals
- Qualitative criteria documented
- Metrics are actually measurable
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted
### SYSTEM FAILURE:
- Generating metrics without user input
- Metrics that can't be measured
- Missing connection to game pillars/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.

336
src/modules/bmgd/workflows/2-design/gdd/steps/step-14-complete.md
View File

@@ -1,336 +0,0 @@
---
name: 'step-14-complete'
description: 'Document out of scope items, capture assumptions, and provide handoff guidance'
# Path Definitions
workflow_path: '{project-root}/_bmad/bmgd/workflows/2-design/gdd'
# File References
thisStepFile: './step-14-complete.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/gdd.md'
epicsFile: '{output_folder}/epics.md'
# Workflow References
narrativeWorkflow: '{project-root}/_bmad/bmgd/workflows/2-design/narrative/workflow.yaml'
architectureWorkflow: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture/workflow.yaml'
---
# Step 14: Complete & Handoff
**Progress: Step 14 of 14** - GDD Complete!
## STEP GOAL:
Document what is explicitly out of scope, capture key assumptions and dependencies, and provide clear next steps for the game development process.
## 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
- ✅ 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 clear actionable next steps
### Step-Specific Rules:
- Focus on scope boundaries and assumptions
- Check if narrative workflow is recommended
- Provide concrete next steps based on workflow status
## EXECUTION PROTOCOLS:
- Show your analysis before taking any action
- Generate final sections without A/P/C menu (just confirmation)
- Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]`
- Present completion summary and next steps
## CONTEXT BOUNDARIES:
- All GDD content from previous steps available
- Check for `needs_narrative` flag from step 7
- Reference workflow-status if integrated with BMM
## Sequence of Instructions (Do not deviate, skip, or optimize)
### 1. Out of Scope Discovery
**Guide user through scope boundaries:**
"Let's document what is explicitly NOT in scope for {{game_name}} v1.0.
**Out of Scope Categories:**
| Category | Examples |
| ---------------- | -------------------------------------- |
| **Features** | Multiplayer, level editor, mod support |
| **Content** | Additional game modes, DLC areas |
| **Platforms** | Console ports, VR version |
| **Polish** | Full voice acting, orchestral score |
| **Localization** | Additional languages |
**Questions to consider:**
1. What features have you intentionally cut for v1.0?
2. What platforms are NOT in initial scope?
3. What post-launch content are you deferring?
4. What's 'nice to have' vs 'required for launch'?
What's explicitly out of scope for {{game_name}} v1.0?"
### 2. Assumptions and Dependencies Discovery
**Guide user through assumptions:**
"Now let's document key assumptions and dependencies.
**Assumption Categories:**
| Category | Examples |
| ------------- | ----------------------------------------------------------------- |
| **Technical** | 'Unity LTS will remain stable', 'Players have controllers' |
| **Team** | 'Art contractor available Q2', 'Solo developer capacity' |
| **External** | 'Steam review approval in 2 weeks', 'Asset store assets licensed' |
| **Market** | 'Genre remains popular', 'Pricing assumptions' |
**Dependency Categories:**
| Category | Examples |
| --------------- | ----------------------------------------- |
| **Third-party** | Middleware, plugins, asset licenses |
| **Services** | Backend providers, analytics, multiplayer |
| **Content** | External art, music, voice acting |
| **Platform** | SDK versions, certification requirements |
What assumptions is {{game_name}} built on? What external dependencies exist?"
### 3. Check Narrative Workflow Recommendation
**Check if game type suggested narrative:**
If `needs_narrative` flag is true (from step 7):
"**Narrative Recommendation:**
Based on your game type ({{game_type}}), a dedicated Narrative Design Document would benefit {{game_name}}. This covers:
- Story structure and arcs
- Character development
- World lore and history
- Dialogue framework
- Environmental storytelling
Would you like to create a Narrative Design Document as your next step?"
Store user response for next steps.
### 4. Generate Completion Content
Based on the conversation, prepare the content:
```markdown
## Out of Scope
{{out_of_scope_items}}
### Deferred to Post-Launch
{{post_launch_items}}
---
## Assumptions and Dependencies
### Key Assumptions
{{assumptions_list}}
### External Dependencies
{{dependencies_list}}
### Risk Factors
{{risks_based_on_assumptions}}
---
## Document Information
**Document:** {{game_name}} - Game Design Document
**Version:** 1.0
**Created:** {{date}}
**Author:** {{user_name}}
**Status:** Complete
### Change Log
| Version | Date | Changes |
| ------- | -------- | -------------------- |
| 1.0 | {{date}} | Initial GDD complete |
```
### 5. Present Completion Summary
"**GDD Complete!**
{{user_name}}, the Game Design Document for **{{game_name}}** is now complete!
**Document Summary:**
- **Game Type:** {{game_type}}
- **Platform:** {{platform}}
- **Epics:** {{epic_count}} development epics
- **Estimated Stories:** {{story_estimate}}
**Files Created:**
- `gdd.md` - Full Game Design Document
- `epics.md` - Detailed epic and story breakdown
**GDD Sections Completed:**
1. Executive Summary & Game Type
2. Platforms & Target Audience
3. Goals & Unique Selling Points
4. Core Gameplay (Pillars, Loop, Win/Loss)
5. Game Mechanics & Controls
6. {{game_type}} Specific Design
7. Progression & Balance
8. Level Design Framework
9. Art & Audio Direction
10. Technical Specifications
11. Development Epics
12. Success Metrics
13. Out of Scope & Assumptions
Do you want me to add or modify anything before we finalize?"
### 6. Present Next Steps
**After user confirms completion:**
"**Next Steps for {{game_name}}:**
{{if needs_narrative and user_wants_narrative}}
**Immediate Next Step:**
1. **Narrative Design Document** - Create story, characters, and world lore
- Command: `narrative` (Game Designer agent)
- Input: This GDD
- Output: narrative-design.md
{{/if}}
**Required Next Steps:**
1. **Game Architecture** - Define engine, tech stack, and system design
- Command: `create-architecture` (Game Architect agent)
- Input: This GDD
- Output: architecture.md
2. **Sprint Planning** - Set up your first development sprint
- Command: `sprint-planning` (Scrum Master agent)
- Input: GDD + epics.md
- Output: sprint-status.yaml
**Recommended Actions:**
- [ ] Review GDD with any team members or stakeholders
- [ ] Create a prototype for core gameplay validation
- [ ] Set up project repository and dev environment
- [ ] Gather reference materials for art direction
**Which would you like to do next?**
1. {{if needs_narrative}}Create Narrative Design Document{{else}}Create Game Architecture{{/if}}
2. Start Sprint Planning
3. Review the completed GDD
4. Exit workflow"
### 7. Handle User Selection
Based on user choice:
**If 1 (Narrative or Architecture):**
- Update frontmatter with final `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]`
- Provide handoff guidance for next workflow
**If 2 (Sprint Planning):**
- Update frontmatter with final stepsCompleted
- Provide handoff guidance for sprint planning
**If 3 (Review):**
- Present document summary
- Offer to highlight any sections
- Return to next steps menu
**If 4 (Exit):**
- Update frontmatter with final stepsCompleted
- Confirm GDD is saved
- Exit workflow gracefully
## CRITICAL STEP COMPLETION NOTE
This is the final step. Ensure:
- All content is saved to gdd.md
- Frontmatter shows all 14 steps completed
- User has clear actionable next steps
- Handoff to next workflow is smooth
---
## SYSTEM SUCCESS/FAILURE METRICS
### SUCCESS:
- Out of scope clearly documented
- Assumptions and dependencies captured
- Narrative workflow recommendation handled
- Final document status updated
- Clear next steps provided
- Smooth handoff to next workflow
### SYSTEM FAILURE:
- Missing out of scope documentation
- Not checking for narrative flag
- No clear next steps provided
- 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.
---
## GDD Workflow Complete
The GDD workflow transforms a game concept into a comprehensive design document through 14 collaborative steps:
1. **Initialize** - Set up workflow and discover input documents
2. **Context** - Determine game type and load relevant guide
3. **Platforms** - Define target platforms and audience
4. **Vision** - Establish goals, context, and USPs
5. **Core Gameplay** - Define pillars, loop, and win/loss
6. **Mechanics** - Detail player actions and controls
7. **Game Type** - Process genre-specific sections
8. **Progression** - Design player growth and balance
9. **Levels** - Structure playable content
10. **Art & Audio** - Establish aesthetic direction
11. **Technical** - Define performance requirements
12. **Epics** - Organize features into development units
13. **Metrics** - Define success criteria
14. **Complete** - Document scope and hand off
This step-file architecture ensures consistent, thorough GDD creation with user collaboration at every step.

153
src/modules/bmgd/workflows/2-design/gdd/templates/gdd-template.md
View File

@@ -1,153 +0,0 @@
# {{game_name}} - Game Design Document
**Author:** {{user_name}}
**Game Type:** {{game_type}}
**Target Platform(s):** {{platforms}}
---
## Executive Summary
### Core Concept
{{description}}
### Target Audience
{{target_audience}}
### Unique Selling Points (USPs)
{{unique_selling_points}}
---
## Goals and Context
### Project Goals
{{goals}}
### Background and Rationale
{{context}}
---
## Core Gameplay
### Game Pillars
{{game_pillars}}
### Core Gameplay Loop
{{gameplay_loop}}
### Win/Loss Conditions
{{win_loss_conditions}}
---
## Game Mechanics
### Primary Mechanics
{{primary_mechanics}}
### Controls and Input
{{controls}}
---
{{GAME_TYPE_SPECIFIC_SECTIONS}}
---
## Progression and Balance
### Player Progression
{{player_progression}}
### Difficulty Curve
{{difficulty_curve}}
### Economy and Resources
{{economy_resources}}
---
## Level Design Framework
### Level Types
{{level_types}}
### Level Progression
{{level_progression}}
---
## Art and Audio Direction
### Art Style
{{art_style}}
### Audio and Music
{{audio_music}}
---
## Technical Specifications
### Performance Requirements
{{performance_requirements}}
### Platform-Specific Details
{{platform_details}}
### Asset Requirements
{{asset_requirements}}
---
## Development Epics
### Epic Structure
{{epics}}
---
## Success Metrics
### Technical Metrics
{{technical_metrics}}
### Gameplay Metrics
{{gameplay_metrics}}
---
## Out of Scope
{{out_of_scope}}
---
## Assumptions and Dependencies
{{assumptions_and_dependencies}}

61
src/modules/bmgd/workflows/2-design/gdd/workflow.md
View File

@@ -1,61 +0,0 @@
---
name: create-gdd
description: Creates a comprehensive Game Design Document through collaborative step-by-step discovery between game designer and user.
main_config: '{project-root}/_bmad/bmgd/config.yaml'
web_bundle: true
---
# GDD Workflow
**Goal:** Create comprehensive Game Design Documents through collaborative step-by-step discovery between game designer and user.
**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 facilitation skills, while the user brings their game vision and domain expertise. 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
---
## 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
### 2. First Step EXECUTION
Load, read the full file and then execute `steps/step-01-init.md` to begin the workflow.

101
src/modules/bmgd/workflows/2-design/gdd/workflow.yaml
View File

@@ -1,101 +0,0 @@
# Game Design Document (GDD) Workflow
name: gdd
description: "Game Design Document workflow for all game project levels - from small prototypes to full AAA games. Generates comprehensive GDD with game mechanics, systems, progression, and implementation guidance."
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/2-design/gdd"
instructions: "{installed_path}/workflow.md"
template: "{installed_path}/templates/gdd-template.md"
game_types_csv: "{installed_path}/game-types.csv"
# Output configuration
default_output_file: "{output_folder}/gdd.md"
# Game type references (loaded based on game type selection)
game_type_guides: "{installed_path}/game-types/"
# Smart input file references - handles both whole docs and sharded docs
# Priority: Whole document first, then sharded version
input_file_patterns:
game_brief:
description: "Game vision and core concept (optional)"
whole: "{output_folder}/*game-brief*.md"
sharded: "{output_folder}/*game-brief*/index.md"
load_strategy: "INDEX_GUIDED"
research:
description: "Market or domain research (optional)"
whole: "{output_folder}/*research*.md"
sharded: "{output_folder}/*research*/index.md"
load_strategy: "FULL_LOAD"
document_project:
description: "Brownfield project documentation (optional)"
sharded: "{output_folder}/index.md"
load_strategy: "INDEX_GUIDED"
standalone: true
web_bundle:
name: "gdd"
description: "Game Design Document workflow for all game project levels - from small prototypes to full AAA games. Generates comprehensive GDD with game mechanics, systems, progression, and implementation guidance."
author: "BMad"
instructions: "_bmad/bmgd/workflows/2-design/gdd/workflow.md"
web_bundle_files:
# Main workflow file
- "_bmad/bmgd/workflows/2-design/gdd/workflow.md"
# Step files
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-01-init.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-01b-continue.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-02-context.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-03-platforms.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-04-vision.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-05-core-gameplay.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-06-mechanics.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-07-game-type.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-08-progression.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-09-levels.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-10-art-audio.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-11-technical.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-12-epics.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-13-metrics.md"
- "_bmad/bmgd/workflows/2-design/gdd/steps/step-14-complete.md"
# Template
- "_bmad/bmgd/workflows/2-design/gdd/templates/gdd-template.md"
# Data files
- "_bmad/bmgd/workflows/2-design/gdd/game-types.csv"
# Game type guides
- "_bmad/bmgd/workflows/2-design/gdd/game-types/action-platformer.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/adventure.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/card-game.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/fighting.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/horror.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/idle-incremental.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/metroidvania.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/moba.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/party-game.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/puzzle.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/racing.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/rhythm.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/roguelike.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/rpg.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/sandbox.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/shooter.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/simulation.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/sports.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/strategy.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/survival.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/text-based.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/tower-defense.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/turn-based-tactics.md"
- "_bmad/bmgd/workflows/2-design/gdd/game-types/visual-novel.md"

139
src/modules/bmgd/workflows/2-design/narrative/checklist.md
View File

@@ -1,139 +0,0 @@
# Narrative Design Workflow Validation Checklist
**Purpose**: Validate narrative design outputs are complete, cohesive, and ready for implementation.
**Scope**: Story-driven games and applications (follows GDD workflow)
**Expected Output**: narrative-design.md
---
## 1. Output File Exists
- [ ] narrative-design.md created in output folder
- [ ] GDD.md exists (narrative workflow requires GDD first)
- [ ] No unfilled {{template_variables}}
---
## 2. Story Foundation
### Core Elements
- [ ] **Narrative premise** clearly stated (elevator pitch, 2-3 sentences)
- [ ] **Core themes** identified (2-4 meaningful themes)
- [ ] **Tone and atmosphere** established
- [ ] Premise is compelling and fits game type
### Story Structure
- [ ] **Story structure chosen** (3-act, hero's journey, branching, etc.)
- [ ] **Acts/sections broken down** with clear progression
- [ ] **Major story beats** documented (key moments that drive narrative)
- [ ] Structure fits narrative complexity level
---
## 3. Characters
### Protagonist(s)
- [ ] Background and motivation explained
- [ ] Character arc defined (how they change)
- [ ] Internal and external conflicts identified
### Antagonist(s)
- [ ] Motivation clear (why they oppose protagonist)
- [ ] Goals and methods explained
- [ ] Not one-dimensional
### Supporting Cast
- [ ] Major supporting characters documented
- [ ] Each has distinct role in story
- [ ] Character relationships mapped
### Character Arcs
- [ ] Major characters have starting → transformation → ending states
- [ ] Arc progression makes sense
---
## 4. World and Lore
- [ ] **World setting** defined (time, place, world type)
- [ ] **World rules** explained (magic, technology, society)
- [ ] **History and backstory** documented
- [ ] Key locations described with narrative significance
---
## 5. Dialogue and Delivery
### Dialogue Framework
- [ ] Dialogue style established
- [ ] Key conversations identified
- [ ] Branching dialogue system described (if applicable)
### Narrative Delivery
- [ ] Cutscenes/cinematics approach defined
- [ ] In-game storytelling methods explained
- [ ] Optional vs. required content distinguished
- [ ] Multiple endings documented (if applicable)
---
## 6. Gameplay Integration
- [ ] **Narrative-gameplay harmony** addressed (how story and mechanics connect)
- [ ] **Story gates** explained (how narrative controls progression)
- [ ] **Player agency** level defined (can player affect story?)
- [ ] Integration doesn't fight game design
---
## 7. Production Scope
- [ ] **Writing scope** estimated (word count, scene count, dialogue lines)
- [ ] Scope realistic for project level
- [ ] Localization considerations noted (if applicable)
- [ ] Voice acting plans documented (if applicable)
---
## 8. Consistency with GDD
- [ ] Narrative aligns with GDD game design
- [ ] Tone matches GDD art/audio direction
- [ ] Story supports game mechanics (doesn't contradict)
- [ ] No conflicts between narrative and gameplay
---
## 9. Critical Failures (Auto-Fail)
- [ ] ❌ **No GDD** (narrative workflow requires GDD first)
- [ ] ❌ **No character arcs** (protagonist has no development)
- [ ] ❌ **No story beats** (major moments not identified)
- [ ] ❌ **Contradicts GDD** (narrative fights game design)
---
## Validation Notes
**Document any findings:**
- Narrative strength: [Compelling / Interesting / Adequate / Weak]
- Strengths:
- Issues to address:
- Recommended actions:
**Ready for solutioning?** [Yes / No - explain]
---
_Adapt based on narrative complexity level (Critical/Heavy/Moderate/Light)._

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