---
name: 'step-03-starter'
description: 'Discover and evaluate game engine and starter template options'

# Path Definitions
workflow_path: '{installed_path}'

# File References
thisStepFile: './step-03-starter.md'
nextStepFile: './step-04-decisions.md'
workflowFile: '{workflow_path}/workflow.md'
outputFile: '{output_folder}/game-architecture.md'

# Knowledge Base References
engineMcps: '{workflow_path}/engine-mcps.yaml'

# Task References
advancedElicitationTask: 'skill:bmad-advanced-elicitation'
partyModeWorkflow: 'skill:bmad-party-mode'
---

# Step 3: Engine & Starter Selection

**Progress: Step 3 of 9** - Next: Architectural Decisions

## STEP GOAL:

Discover and evaluate game engine options and starter templates based on project requirements. Modern engines/starters make many architectural decisions automatically.

## 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 architect facilitator
- Modern starters/engines provide many architectural decisions out of the box
- Verify current versions via web search - NEVER trust hardcoded versions

### Step-Specific Rules:

- ALWAYS search web for current versions
- Document which decisions the engine provides
- Help user understand engine trade-offs

## EXECUTION PROTOCOLS:

- Show your analysis before taking any action
- Present A/P/C menu after engine selection
- ONLY proceed when user chooses C (Continue)
- Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step

## COLLABORATION MENUS (A/P/C):

- **A (Advanced Elicitation)**: Explore alternative engines
- **P (Party Mode)**: Get perspectives on engine choice
- **C (Continue)**: Confirm selection and proceed

## Sequence of Instructions (Do not deviate, skip, or optimize)

### 1. Identify Engine Requirements

**Based on project context, determine engine needs:**

"Let's determine the right engine/framework for **{{game_name}}**.

**Your Requirements:**

- Platform: {{platform}}
- Genre: {{genre}}
- Key systems: {{key_systems}}

**Engine Considerations:**

| Requirement         | Implications          |
| ------------------- | --------------------- |
| **2D vs 3D**        | {{2d_or_3d}}          |
| **Performance**     | {{performance_needs}} |
| **Networking**      | {{networking_needs}}  |
| **Platform Export** | {{platform_targets}}  |

What engine or framework are you considering, or would you like recommendations?"

### 2. Research Engine Options

**If user has an engine in mind:**

Search the web to verify:

- Current stable version
- Platform support status
- Recent updates and roadmap

**If user wants recommendations:**

Based on requirements, search for appropriate options:

| Game Type    | Recommended Options         |
| ------------ | --------------------------- |
| **2D Indie** | Godot, Unity 2D, Phaser          |
| **3D Indie** | Godot, Unity, Unreal             |
| **Web Game** | Phaser, PixiJS, Three.js         |
| **Mobile**   | Unity, Godot, Flutter Flame      |
| **VR/AR**    | Unity, Unreal                    |
| **Social/Platform** | Roblox Studio               |

Search web: "{{recommended_engine}} game engine {{current_year}} version features"

### 3. Present Engine Options

**Present findings to user:**

"Based on your requirements, here are the engine options:

**Option 1: {{engine_1}}**

- Version: {{verified_version}}
- Strengths: {{strengths}}
- Considerations: {{considerations}}
- Best for: {{best_use_case}}

**Option 2: {{engine_2}}**

- Version: {{verified_version}}
- Strengths: {{strengths}}
- Considerations: {{considerations}}
- Best for: {{best_use_case}}

**Option 3: {{engine_3}}**

- Version: {{verified_version}}
- Strengths: {{strengths}}
- Considerations: {{considerations}}
- Best for: {{best_use_case}}

Which engine would you like to use for {{game_name}}?"

### 4. Document Engine Selection

**After user selects engine:**

"**Engine Selected:** {{selected_engine}} v{{version}}

**Decisions Provided by Engine:**

| Category             | Decision               | Provided By |
| -------------------- | ---------------------- | ----------- |
| **Rendering**        | {{rendering_approach}} | Engine      |
| **Physics**          | {{physics_system}}     | Engine      |
| **Audio**            | {{audio_system}}       | Engine      |
| **Input**            | {{input_system}}       | Engine      |
| **Scene Management** | {{scene_approach}}     | Engine      |
| **Build System**     | {{build_approach}}     | Engine      |

**Remaining Decisions:**
These architectural decisions still need to be made:
{{list_of_remaining_decisions}}

Does this look correct?"

### 5. Discover Starter Templates

**Search for project templates:**

Search web: "{{engine}} starter template {{game_type}} {{current_year}}"

**If templates found:**

"I found some starter templates for {{engine}}:

**{{template_1}}:**

- What it provides: {{features}}
- Setup command: `{{command}}`

**{{template_2}}:**

- What it provides: {{features}}
- Setup command: `{{command}}`

Would you like to use a starter template, or start from scratch?"

### 6. Recommend Game Engine MCPs

**Load MCP knowledge base:** `{engineMcps}`

**Look up MCPs for the selected engine ({{selected_engine}}):**

Search web: "{{selected_engine}} MCP server Model Context Protocol {{current_year}}"

**Verify the repos listed in the knowledge base are still active and maintained.** The MCP ecosystem moves fast - confirm star counts, recent commits, and compatibility with the user's engine version before recommending.

**If multiple MCPs exist for the engine, present the default recommendation first** (per `recommendation_rules.multiple_options` in the knowledge base), then mention alternatives. Include:
- Repo name and link
- Key capabilities (3-5 bullet points)
- Requirements (engine version, Node.js, Python, etc.)
- Install type

**Present based on skill level:**

For **expert** users:

"**Available MCPs for {{selected_engine}}:**

| MCP | Repo | Install | Requirements |
| --- | ---- | ------- | ------------ |
| {{mcp_name}} | {{repo}} | {{install_type}} | {{requirements}} |

Key capabilities: {{capability_summary}}

Include MCP setup in your architecture? [y/n]"

For **beginner** users:

"**AI Development Tools**

There's a way to give your AI assistant direct access to {{selected_engine}} - called MCP (Model Context Protocol) servers. Think of it like giving your AI a window into the game editor.

For {{selected_engine}}, I'd recommend **{{mcp_name}}** which lets the AI:
{{friendly_capability_list}}

This means the AI can inspect your scenes and assets directly instead of relying on descriptions. It's optional but highly recommended for AI-assisted development.

Include MCP setup in your architecture? [y/n]"

**Also recommend Context7** (upstash/context7): Lets the AI look up current {{selected_engine}} documentation instead of relying on training data. Works with any engine.

**If user accepts MCPs:**

Record selected MCPs for inclusion in Development Environment section:
- MCP name, repo, install steps, requirements
- These will be included in the final architecture document

**If user declines:**

"No problem - you can always add MCPs later. Let's continue with the architecture."

### 7. Generate Engine Section

Based on the conversation, prepare the content:

````markdown
## Engine & Framework

### Selected Engine

**{{engine_name}}** v{{version}}

**Rationale:** {{why_selected}}

### Project Initialization

{{if_starter_template}}

```bash
{{initialization_command}}
```
````

{{/if_starter_template}}

### Engine-Provided Architecture

| Component | Solution | Notes |
| --------- | -------- | ----- |

{{engine_provided_table}}

### Remaining Architectural Decisions

The following decisions must be made explicitly:

{{remaining_decisions_list}}

```

### 8. Present Content and Menu

Show the generated content to the user and present:

"I've drafted the Engine & Framework section.

**Here's what I'll add to the document:**

[Show the complete markdown content from step 7]

**Validation Check:**
- Is the engine version current?
- Are the engine-provided decisions accurate?
- Have we identified all remaining decisions?

**Select an Option:**
[A] Advanced Elicitation - Explore alternative engines
[P] Party Mode - Get perspectives on engine choice
[C] Continue - Save this and move to Architectural Decisions (Step 4 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]`
- Load `{nextStepFile}`

## CRITICAL STEP COMPLETION NOTE

ONLY WHEN [C continue option] is selected and [engine content saved with frontmatter updated], will you then load and read fully `{nextStepFile}`.

---

## SYSTEM SUCCESS/FAILURE METRICS

### SUCCESS:

- Engine requirements clearly identified
- Current versions verified via web search
- Engine-provided decisions documented
- Remaining decisions identified
- Starter template evaluated if applicable
- Game engine MCPs presented and user preference recorded
- A/P/C menu presented and handled correctly
- Frontmatter updated with stepsCompleted: [1, 2, 3]

### SYSTEM FAILURE:

- Using hardcoded versions without verification
- Not documenting engine-provided decisions
- Proceeding without user engine selection
- Not presenting A/P/C menu after selection
- Proceeding without user selecting 'C'

**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
```
