bmad-method 6.0.0-alpha.2 → 6.0.0-alpha.20

package/src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-05-crosscutting.md

@@ -0,0 +1,319 @@
+---
+name: 'step-05-crosscutting'
+description: 'Address cross-cutting concerns that affect all game systems'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-05-crosscutting.md'
+nextStepFile: '{workflow_path}/steps/step-06-structure.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 5: Cross-cutting Concerns
+
+**Progress: Step 5 of 9** - Next: Project Structure
+
+## STEP GOAL:
+
+Define patterns for concerns that affect EVERY system in the game: error handling, logging, configuration, events, and debugging. These decisions ensure consistency across all AI agent implementations.
+
+## 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
+
+### Role Reinforcement:
+
+- You are a veteran game architect facilitator
+- Cross-cutting concerns affect EVERY system
+- Consistency here prevents major integration issues
+
+### Step-Specific Rules:
+
+- Focus on patterns that prevent AI agent conflicts
+- Every decision must have a concrete example
+- These become mandatory rules for all implementations
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after all concerns documented
+- ONLY proceed 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)**: Deep dive into specific concerns
+- **P (Party Mode)**: Get perspectives on patterns
+- **C (Continue)**: Confirm patterns and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Explain Cross-cutting Importance
+
+"Now let's define cross-cutting concerns - patterns that apply to EVERY system.
+
+**Why this matters:**
+If one AI agent handles errors differently than another, your game breaks.
+If logging formats vary, debugging becomes impossible.
+These patterns are the 'constitution' that all code must follow.
+
+Let's define each one."
+
+### 2. Error Handling Strategy
+
+"**Error Handling**
+
+How should ALL systems handle errors?
+
+**Options:**
+
+| Approach                 | Description                     | Best For            |
+| ------------------------ | ------------------------------- | ------------------- |
+| **Try-Catch Everywhere** | Explicit handling at each point | Critical systems    |
+| **Global Handler**       | Centralized error management    | Consistent recovery |
+| **Signal/Event Based**   | Emit errors as events           | Decoupled systems   |
+| **Result Objects**       | Return success/failure objects  | Functional style    |
+
+**Game-specific considerations:**
+
+- Should errors pause the game?
+- How should critical vs recoverable errors differ?
+- Should errors be visible to players?
+
+What's your error handling strategy?"
+
+### 3. Logging Approach
+
+"**Logging Strategy**
+
+How should ALL systems log information?
+
+**Log Levels:**
+
+- **ERROR**: Something broke
+- **WARN**: Something unexpected but handled
+- **INFO**: Normal operation milestones
+- **DEBUG**: Detailed diagnostic info
+- **TRACE**: Extremely verbose (development only)
+
+**Questions:**
+
+- What format? (structured JSON, plain text, engine-native)
+- Where do logs go? (console, file, external service)
+- What should always be logged vs conditional?
+- How should performance-critical paths handle logging?
+
+What's your logging approach?"
+
+### 4. Configuration Management
+
+"**Configuration Management**
+
+How will game settings be organized and accessed?
+
+**Configuration Types:**
+
+- **Game constants** - Values that never change
+- **Balancing values** - Tweakable gameplay numbers
+- **Player settings** - User preferences
+- **Platform settings** - Per-platform adjustments
+
+**Storage options:**
+
+- Hardcoded constants
+- Configuration files (JSON, YAML)
+- Engine-native systems
+- Remote configuration
+
+How should configuration be managed?"
+
+### 5. Event/Signal System
+
+"**Event System**
+
+How should systems communicate without tight coupling?
+
+**Options:**
+
+| Pattern           | Description           | Complexity |
+| ----------------- | --------------------- | ---------- |
+| **Observer**      | Direct subscription   | Simple     |
+| **Event Bus**     | Central dispatcher    | Medium     |
+| **Signal/Slot**   | Type-safe connections | Medium     |
+| **Message Queue** | Async processing      | Complex    |
+
+**Questions:**
+
+- Typed events or stringly-typed?
+- Sync or async event processing?
+- Event history/replay for debugging?
+
+What's your event system approach?"
+
+### 6. Debug/Development Tools
+
+"**Debug & Development Tools**
+
+What development tools should be built in?
+
+**Common debug features:**
+
+- Debug console/command system
+- Visual debugging overlays
+- State inspection tools
+- Performance profiling hooks
+- Cheat/testing commands
+
+**Questions:**
+
+- How are debug features enabled/disabled?
+- Should they be in release builds?
+- What's the debug key/activation method?
+
+What debug tools do you want?"
+
+### 7. Generate Cross-cutting Section
+
+Based on the conversation, prepare the content:
+
+````markdown
+## Cross-cutting Concerns
+
+These patterns apply to ALL systems and must be followed by every implementation.
+
+### Error Handling
+
+**Strategy:** {{error_strategy}}
+
+**Error Levels:**
+{{error_level_definitions}}
+
+**Example:**
+
+```{{language}}
+{{error_handling_example}}
+```
+````
+
+### Logging
+
+**Format:** {{logging_format}}
+**Destination:** {{log_destination}}
+
+**Log Levels:**
+{{log_level_usage}}
+
+**Example:**
+
+```{{language}}
+{{logging_example}}
+```
+
+### Configuration
+
+**Approach:** {{config_approach}}
+
+**Configuration Structure:**
+{{config_structure}}
+
+### Event System
+
+**Pattern:** {{event_pattern}}
+
+**Event Naming:** {{naming_convention}}
+
+**Example:**
+
+```{{language}}
+{{event_example}}
+```
+
+### Debug Tools
+
+**Available Tools:**
+{{debug_tool_list}}
+
+**Activation:** {{how_to_enable}}
+
+```
+
+### 8. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've documented all cross-cutting concerns.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 7]
+
+**Validation Check:**
+- Do these patterns cover all systems?
+- Are the examples clear enough for AI agents?
+- Any edge cases we missed?
+
+**Select an Option:**
+[A] Advanced Elicitation - Deep dive into specific concerns
+[P] Party Mode - Get perspectives on patterns
+[C] Continue - Save this and move to Project Structure (Step 6 of 9)"
+
+### 9. 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 [cross-cutting content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Error handling strategy defined with example
+- Logging approach documented
+- Configuration management established
+- Event system pattern selected
+- Debug tools identified
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5]
+
+### SYSTEM FAILURE:
+
+- Missing any cross-cutting concern
+- No concrete examples provided
+- Patterns too vague for AI agents to follow
+- Not presenting A/P/C menu after documentation
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+```

package/src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-06-structure.md

@@ -0,0 +1,304 @@
+---
+name: 'step-06-structure'
+description: 'Define project structure, directory organization, and architectural boundaries'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-06-structure.md'
+nextStepFile: '{workflow_path}/steps/step-07-patterns.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/game-architecture.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 6: Project Structure
+
+**Progress: Step 6 of 9** - Next: Implementation Patterns
+
+## STEP GOAL:
+
+Define the complete project structure including directory organization, file naming conventions, and architectural boundaries. This ensures all AI agents place code consistently.
+
+## 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
+
+### Role Reinforcement:
+
+- You are a veteran game architect facilitator
+- Project structure prevents "where does this go?" confusion
+- Clear boundaries enable parallel development
+
+### Step-Specific Rules:
+
+- Structure must be complete, not generic placeholders
+- Map every major system to a location
+- Define naming conventions explicitly
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Present A/P/C menu after structure defined
+- ONLY proceed 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)**: Refine structure organization
+- **P (Party Mode)**: Get perspectives on layout
+- **C (Continue)**: Confirm structure and proceed
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Determine Organization Pattern
+
+"Let's define how your project will be organized.
+
+**Organization Patterns:**
+
+| Pattern           | Description                      | Best For      |
+| ----------------- | -------------------------------- | ------------- |
+| **By Feature**    | All related files together       | Feature teams |
+| **By Type**       | Scripts, assets, scenes separate | Traditional   |
+| **Hybrid**        | Types at top, features within    | Balanced      |
+| **Domain-Driven** | By game domain/system            | Complex games |
+
+**Engine Conventions:**
+
+- {{engine}} typically uses: {{engine_convention}}
+
+What organization pattern do you prefer?"
+
+### 2. Define Root Structure
+
+"Based on {{selected_pattern}}, let's define your root structure.
+
+**For {{engine}}, typical root looks like:**
+
+```
+{{project_name}}/
+├── {{source_folder}}/          # Game source code
+├── {{assets_folder}}/          # Art, audio, data
+├── {{scenes_folder}}/          # Scene/level files
+├── {{tests_folder}}/           # Test files
+├── {{docs_folder}}/            # Documentation
+└── {{config_files}}            # Project config
+```
+
+Does this work, or would you like to adjust?"
+
+### 3. Detail Source Structure
+
+"Now let's detail the source code organization.
+
+**Based on your systems:**
+{{list_of_systems_from_context}}
+
+**Proposed structure:**
+
+```
+{{source_folder}}/
+├── core/                   # Core systems (singletons, managers)
+│   ├── {{core_systems}}
+├── gameplay/               # Gameplay mechanics
+│   ├── {{gameplay_systems}}
+├── ui/                     # User interface
+│   ├── {{ui_organization}}
+├── utils/                  # Utilities and helpers
+│   ├── {{util_types}}
+└── data/                   # Data structures and models
+    └── {{data_types}}
+```
+
+What adjustments would you make?"
+
+### 4. Define Asset Structure
+
+"Let's organize your assets.
+
+**Asset Categories:**
+
+- Art (sprites, textures, models)
+- Audio (music, sfx, voice)
+- Data (configurations, levels)
+- UI (interface assets)
+
+**Proposed asset structure:**
+
+```
+{{assets_folder}}/
+├── art/
+│   ├── {{art_categories}}
+├── audio/
+│   ├── music/
+│   ├── sfx/
+│   └── {{audio_categories}}
+├── data/
+│   └── {{data_file_types}}
+└── ui/
+    └── {{ui_asset_types}}
+```
+
+How should assets be organized?"
+
+### 5. Map Systems to Locations
+
+"Let's map each major system to its location.
+
+| System | Location | Notes |
+| ------ | -------- | ----- |
+
+{{system_location_mapping}}
+
+Does this mapping make sense for your project?"
+
+### 6. Define Naming Conventions
+
+"Finally, let's establish naming conventions.
+
+**Files:**
+
+- Scripts: {{script_naming}} (e.g., PlayerController, enemy_spawner)
+- Scenes: {{scene_naming}} (e.g., Level01, main_menu)
+- Assets: {{asset_naming}} (e.g., player_idle, btn_play)
+
+**Code Elements:**
+
+- Classes: {{class_naming}} (e.g., PascalCase)
+- Functions: {{function_naming}} (e.g., snake_case, camelCase)
+- Variables: {{variable_naming}}
+- Constants: {{constant_naming}} (e.g., UPPER_SNAKE)
+
+**Game-Specific:**
+
+- Prefabs/Scenes: {{prefab_naming}}
+- Animation clips: {{animation_naming}}
+- Event names: {{event_naming}}
+
+What are your naming preferences?"
+
+### 7. Generate Structure Section
+
+Based on the conversation, prepare the content:
+
+```markdown
+## Project Structure
+
+### Organization Pattern
+
+**Pattern:** {{organization_pattern}}
+
+**Rationale:** {{why_this_pattern}}
+
+### Directory Structure
+```
+
+{{project_name}}/
+{{complete_directory_tree}}
+
+```
+
+### System Location Mapping
+
+| System | Location | Responsibility |
+|--------|----------|----------------|
+{{system_mapping_table}}
+
+### Naming Conventions
+
+#### Files
+{{file_naming_rules}}
+
+#### Code Elements
+| Element | Convention | Example |
+|---------|------------|---------|
+{{code_naming_table}}
+
+#### Game Assets
+{{asset_naming_rules}}
+
+### Architectural Boundaries
+
+{{boundary_rules}}
+```
+
+### 8. Present Content and Menu
+
+Show the generated content to the user and present:
+
+"I've defined the complete project structure.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 7]
+
+**Validation Check:**
+
+- Can every system find its home?
+- Are naming conventions clear and consistent?
+- Will AI agents know exactly where to place new code?
+
+**Select an Option:**
+[A] Advanced Elicitation - Refine structure organization
+[P] Party Mode - Get perspectives on layout
+[C] Continue - Save this and move to Implementation Patterns (Step 7 of 9)"
+
+### 9. 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 [structure content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Complete directory structure defined
+- Every system mapped to location
+- Naming conventions explicit and consistent
+- No placeholder or generic structures
+- A/P/C menu presented and handled correctly
+- Frontmatter updated with stepsCompleted: [1, 2, 3, 4, 5, 6]
+
+### SYSTEM FAILURE:
+
+- Generic structure with placeholders
+- Systems without clear locations
+- Vague naming conventions
+- Not presenting A/P/C menu after structure
+- Proceeding without user selecting 'C'
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.