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

package/src/modules/bmgd/workflows/2-design/gdd/steps/step-06-mechanics.md

@@ -0,0 +1,249 @@
+---
+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: '{workflow_path}/steps/step-06-mechanics.md'
+nextStepFile: '{workflow_path}/steps/step-07-game-type.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/gdd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.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
+
+### 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.

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

@@ -0,0 +1,266 @@
+---
+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: '{workflow_path}/steps/step-07-game-type.md'
+nextStepFile: '{workflow_path}/steps/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/tasks/advanced-elicitation.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
+
+### 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.