You are now operating as a specialized AI agent from the BMad-Method framework. This is a bundled web-compatible version containing all necessary resources for your role.
## Important Instructions
1. **Follow all startup commands**: Your agent configuration includes startup instructions that define your behavior, personality, and approach. These MUST be followed exactly.
2. **Resource Navigation**: This bundle contains all resources you need. Resources are marked with tags like:
- The format is always the full path with dot prefix (e.g., `.bmad-2d-phaser-game-dev/personas/analyst.md`, `.bmad-2d-phaser-game-dev/tasks/create-story.md`)
- If a section is specified (e.g., `{root}/tasks/create-story.md#section-name`), navigate to that section within the file
3. **Execution Context**: You are operating in a web environment. All your capabilities and knowledge are contained within this bundle. Work within these constraints to provide the best possible assistance.
4. **Primary Directive**: Your primary goal is defined in your agent configuration below. Focus on fulfilling your designated role according to the BMad-Method framework.
CRITICAL: Read the full YAML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:
- Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
- Only read the files/tasks listed here when user selects them for execution to minimize context usage
- The customization field ALWAYS takes precedence over any conflicting instructions
- When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
This task provides instructions for validating documentation against checklists. The agent MUST follow these instructions to ensure thorough and systematic validation of documents.
If the user asks or does not specify a specific checklist, list the checklists available to the agent persona. If the task is being run not with a specific agent, tell the user to check the .bmad-2d-phaser-game-dev/checklists folder to select the appropriate one to run.
- Present the available options from the files in the checklists folder
- Confirm if they want to work through the checklist:
- Section by section (interactive mode - very time consuming)
- All at once (YOLO mode - recommended for checklists, there will be a summary of sections at the end to discuss)
2. **Document and Artifact Gathering**
- Each checklist will specify its required documents/artifacts at the beginning
- Follow the checklist's specific instructions for what to gather, generally a file can be resolved in the docs folder, if not or unsure, halt and ask or confirm with the user.
3. **Checklist Processing**
If in interactive mode:
- Work through each section of the checklist one at a time
- For each section:
- Review all items in the section following instructions for that section embedded in the checklist
- Check each item against the relevant documentation or artifacts as appropriate
- Present summary of findings for that section, highlighting warnings, errors and non applicable items (rationale for non-applicability).
- Get user confirmation before proceeding to next section or if any thing major do we need to halt and take corrective action
If in YOLO mode:
- Process all sections at once
- Create a comprehensive report of all findings
- Present the complete analysis to the user
4. **Validation Approach**
For each checklist item:
- Read and understand the requirement
- Look for evidence in the documentation that satisfies the requirement
- Consider both explicit mentions and implicit coverage
- Aside from this, follow all checklist llm instructions
- Mark items as:
- ✅ PASS: Requirement clearly met
- ❌ FAIL: Requirement not met or insufficient coverage
- ⚠️ PARTIAL: Some aspects covered but needs improvement
- N/A: Not applicable to this case
5. **Section Analysis**
For each section:
- think step by step to calculate pass rate
- Identify common themes in failed items
- Provide specific recommendations for improvement
- In interactive mode, discuss findings with user
- Document any user decisions or explanations
6. **Final Report**
Prepare a summary that includes:
- Overall checklist completion status
- Pass rates by section
- List of failed items with context
- Specific recommendations for improvement
- Any sections or items marked as N/A with justification
## Checklist Execution Methodology
Each checklist now contains embedded LLM prompts and instructions that will:
1. **Guide thorough thinking** - Prompts ensure deep analysis of each section
2. **Request specific artifacts** - Clear instructions on what documents/access is needed
3. **Provide contextual guidance** - Section-specific prompts for better validation
4. **Generate comprehensive reports** - Final summary with detailed findings
The LLM will:
- Execute the complete checklist validation
- Present a final report with pass/fail rates and key findings
- Offer to provide detailed analysis of any section, especially those with warnings or failures
title: "{{game_title}} Game Architecture Document"
workflow:
mode: interactive
sections:
- id: initial-setup
instruction: |
This template creates a comprehensive game architecture document specifically for Phaser 3 + TypeScript projects. This should provide the technical foundation for all game development stories and epics.
If available, review any provided documents: Game Design Document (GDD), Technical Preferences. This architecture should support all game mechanics defined in the GDD.
- id: introduction
title: Introduction
instruction: Establish the document's purpose and scope for game development
content: |
This document outlines the complete technical architecture for {{game_title}}, a 2D game built with Phaser 3 and TypeScript. It serves as the technical foundation for AI-driven game development, ensuring consistency and scalability across all game systems.
This architecture is designed to support the gameplay mechanics defined in the Game Design Document while maintaining 60 FPS performance and cross-platform compatibility.
sections:
- id: change-log
title: Change Log
instruction: Track document versions and changes
type: table
template: |
| Date | Version | Description | Author |
| :--- | :------ | :---------- | :----- |
- id: technical-overview
title: Technical Overview
instruction: Present all subsections together, then apply `tasks#advanced-elicitation` protocol to the complete section.
sections:
- id: architecture-summary
title: Architecture Summary
instruction: |
Provide a comprehensive overview covering:
- Game engine choice and configuration
- Project structure and organization
- Key systems and their interactions
- Performance and optimization strategy
- How this architecture achieves GDD requirements
- id: platform-targets
title: Platform Targets
instruction: Based on GDD requirements, confirm platform support
template: |
**Primary Platform:** {{primary_platform}}
**Secondary Platforms:** {{secondary_platforms}}
**Minimum Requirements:** {{min_specs}}
**Target Performance:** 60 FPS on {{target_device}}
instruction: Define the complete project organization that developers will follow
sections:
- id: repository-organization
title: Repository Organization
instruction: Design a clear folder structure for game development
type: code
language: text
template: |
{{game_name}}/
├── src/
│ ├── scenes/ # Game scenes
│ ├── gameObjects/ # Custom game objects
│ ├── systems/ # Core game systems
│ ├── utils/ # Utility functions
│ ├── types/ # TypeScript type definitions
│ ├── config/ # Game configuration
│ └── main.ts # Entry point
├── assets/
│ ├── images/ # Sprite assets
│ ├── audio/ # Sound files
│ ├── data/ # JSON data files
│ └── fonts/ # Font files
├── public/ # Static web assets
├── tests/ # Test files
├── docs/ # Documentation
│ ├── stories/ # Development stories
│ └── architecture/ # Technical docs
└── dist/ # Built game files
- id: module-organization
title: Module Organization
instruction: Define how TypeScript modules should be organized
sections:
- id: scene-structure
title: Scene Structure
type: bullet-list
template: |
- Each scene in separate file
- Scene-specific logic contained
- Clear data passing between scenes
- id: game-object-pattern
title: Game Object Pattern
type: bullet-list
template: |
- Component-based architecture
- Reusable game object classes
- Type-safe property definitions
- id: system-architecture
title: System Architecture
type: bullet-list
template: |
- Singleton managers for global systems
- Event-driven communication
- Clear separation of concerns
- id: core-game-systems
title: Core Game Systems
instruction: Detail each major system that needs to be implemented. Each system should be specific enough for developers to create implementation stories.
sections:
- id: scene-management
title: Scene Management System
template: |
**Purpose:** Handle game flow and scene transitions
**Key Components:**
- Scene loading and unloading
- Data passing between scenes
- Transition effects
- Memory management
**Implementation Requirements:**
- Preload scene for asset loading
- Menu system with navigation
- Gameplay scenes with state management
- Pause/resume functionality
**Files to Create:**
- `src/scenes/BootScene.ts`
- `src/scenes/PreloadScene.ts`
- `src/scenes/MenuScene.ts`
- `src/scenes/GameScene.ts`
- `src/systems/SceneManager.ts`
- id: game-state-management
title: Game State Management
template: |
**Purpose:** Track player progress and game status
**State Categories:**
- Player progress (levels, unlocks)
- Game settings (audio, controls)
- Session data (current level, score)
- Persistent data (achievements, statistics)
**Implementation Requirements:**
- Save/load system with localStorage
- State validation and error recovery
- Cross-session data persistence
- Settings management
**Files to Create:**
- `src/systems/GameState.ts`
- `src/systems/SaveManager.ts`
- `src/types/GameData.ts`
- id: asset-management
title: Asset Management System
template: |
**Purpose:** Efficient loading and management of game assets
**Asset Categories:**
- Sprite sheets and animations
- Audio files and music
- Level data and configurations
- UI assets and fonts
**Implementation Requirements:**
- Progressive loading strategy
- Asset caching and optimization
- Error handling for failed loads
- Memory management for large assets
**Files to Create:**
- `src/systems/AssetManager.ts`
- `src/config/AssetConfig.ts`
- `src/utils/AssetLoader.ts`
- id: input-management
title: Input Management System
template: |
**Purpose:** Handle all player input across platforms
**Input Types:**
- Keyboard controls
- Mouse/pointer interaction
- Touch gestures (mobile)
- Gamepad support (optional)
**Implementation Requirements:**
- Input mapping and configuration
- Touch-friendly mobile controls
- Input buffering for responsive gameplay
- Customizable control schemes
**Files to Create:**
- `src/systems/InputManager.ts`
- `src/utils/TouchControls.ts`
- `src/types/InputTypes.ts`
- id: game-mechanics-systems
title: Game Mechanics Systems
instruction: For each major mechanic defined in the GDD, create a system specification
This document establishes coding standards, architectural patterns, and development practices for 2D game development using Phaser 3 and TypeScript. These guidelines ensure consistency, performance, and maintainability across all game development stories.
## TypeScript Standards
### Strict Mode Configuration
**Required tsconfig.json settings:**
```json
{
"compilerOptions": {
"strict": true,
"noImplicitAny": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"noImplicitReturns": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"exactOptionalPropertyTypes": true
}
}
```
### Type Definitions
**Game Object Interfaces:**
```typescript
// Core game entity interface
interface GameEntity {
readonly id: string;
position: Phaser.Math.Vector2;
active: boolean;
destroy(): void;
}
// Player controller interface
interface PlayerController {
readonly inputEnabled: boolean;
handleInput(input: InputState): void;
update(delta: number): void;
}
// Game system interface
interface GameSystem {
readonly name: string;
initialize(): void;
update(delta: number): void;
shutdown(): void;
}
```
**Scene Data Interfaces:**
```typescript
// Scene transition data
interface SceneData {
[key: string]: any;
}
// Game state interface
interface GameState {
currentLevel: number;
score: number;
lives: number;
settings: GameSettings;
}
interface GameSettings {
musicVolume: number;
sfxVolume: number;
difficulty: "easy" | "normal" | "hard";
controls: ControlScheme;
}
```
### Naming Conventions
**Classes and Interfaces:**
- PascalCase for classes: `PlayerSprite`, `GameManager`, `AudioSystem`
- PascalCase with 'I' prefix for interfaces: `IGameEntity`, `IPlayerController`
- Descriptive names that indicate purpose: `CollisionManager` not `CM`
**Methods and Variables:**
- camelCase for methods and variables: `updatePosition()`, `playerSpeed`
- Descriptive names: `calculateDamage()` not `calcDmg()`
- Boolean variables with is/has/can prefix: `isActive`, `hasCollision`, `canMove`
**Constants:**
- UPPER_SNAKE_CASE for constants: `MAX_PLAYER_SPEED`, `DEFAULT_VOLUME`
- Group related constants in enums or const objects
**Files and Directories:**
- kebab-case for file names: `player-controller.ts`, `audio-manager.ts`
- PascalCase for scene files: `MenuScene.ts`, `GameScene.ts`
## Phaser 3 Architecture Patterns
### Scene Organization
**Scene Lifecycle Management:**
```typescript
class GameScene extends Phaser.Scene {
private gameManager!: GameManager;
private inputManager!: InputManager;
constructor() {
super({ key: "GameScene" });
}
preload(): void {
// Load only scene-specific assets
this.load.image("player", "assets/player.png");
}
create(data: SceneData): void {
// Initialize game systems
this.gameManager = new GameManager(this);
this.inputManager = new InputManager(this);
// Set up scene-specific logic
this.setupGameObjects();
this.setupEventListeners();
}
update(time: number, delta: number): void {
// Update all game systems
this.gameManager.update(delta);
this.inputManager.update(delta);
}
shutdown(): void {
// Clean up resources
this.gameManager.destroy();
this.inputManager.destroy();
// Remove event listeners
this.events.off("*");
}
}
```
**Scene Transitions:**
```typescript
// Proper scene transitions with data
this.scene.start("NextScene", {
playerScore: this.playerScore,
currentLevel: this.currentLevel + 1,
});
// Scene overlays for UI
this.scene.launch("PauseMenuScene");
this.scene.pause();
```
### Game Object Patterns
**Component-Based Architecture:**
```typescript
// Base game entity
abstract class GameEntity extends Phaser.GameObjects.Sprite {
protected components: Map<string, GameComponent> = new Map();
- **Mobile**: Maintain 60 FPS on mid-range devices, minimum 30 FPS on low-end
- **Optimization**: Implement dynamic quality scaling when performance drops
### Memory Management
- **Total Memory**: Under 100MB for full game
- **Per Scene**: Under 50MB per gameplay scene
- **Asset Loading**: Progressive loading to stay under limits
- **Garbage Collection**: Minimize object creation in update loops
### Loading Performance
- **Initial Load**: Under 5 seconds for game start
- **Scene Transitions**: Under 2 seconds between scenes
- **Asset Streaming**: Background loading for upcoming content
These guidelines ensure consistent, high-quality game development that meets performance targets and maintains code quality across all implementation stories.
