bmad-method 4.9.0 → 4.9.1

package/expansion-packs/bmad-2d-phaser-game-dev/data/development-guidelines.md

@@ -10,7 +10,7 @@ This document establishes coding standards, architectural patterns, and developm
 
 **Required tsconfig.json settings:**
 
-````json
+```json
 {
   "compilerOptions": {
     "strict": true,
@@ -23,11 +23,12 @@ This document establishes coding standards, architectural patterns, and developm
     "exactOptionalPropertyTypes": true
   }
 }
-```text
+```
 
 ### Type Definitions
 
 **Game Object Interfaces:**
+
 ```typescript
 // Core game entity interface
 interface GameEntity {
@@ -51,9 +52,10 @@ interface GameSystem {
   update(delta: number): void;
   shutdown(): void;
 }
-```text
+```
 
 **Scene Data Interfaces:**
+
 ```typescript
 // Scene transition data
 interface SceneData {
@@ -71,28 +73,32 @@ interface GameState {
 interface GameSettings {
   musicVolume: number;
   sfxVolume: number;
-  difficulty: 'easy' | 'normal' | 'hard';
+  difficulty: "easy" | "normal" | "hard";
   controls: ControlScheme;
 }
-```text
+```
 
 ### 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`
 
@@ -101,18 +107,19 @@ interface GameSettings {
 ### Scene Organization
 
 **Scene Lifecycle Management:**
+
 ```typescript
 class GameScene extends Phaser.Scene {
   private gameManager!: GameManager;
   private inputManager!: InputManager;
 
   constructor() {
-    super({ key: 'GameScene' });
+    super({ key: "GameScene" });
   }
 
   preload(): void {
     // Load only scene-specific assets
-    this.load.image('player', 'assets/player.png');
+    this.load.image("player", "assets/player.png");
   }
 
   create(data: SceneData): void {
@@ -137,28 +144,29 @@ class GameScene extends Phaser.Scene {
     this.inputManager.destroy();
 
     // Remove event listeners
-    this.events.off('*');
+    this.events.off("*");
   }
 }
-````
+```
 
 **Scene Transitions:**
 
-````typescript
+```typescript
 // Proper scene transitions with data
-this.scene.start('NextScene', {
+this.scene.start("NextScene", {
   playerScore: this.playerScore,
-  currentLevel: this.currentLevel + 1
+  currentLevel: this.currentLevel + 1,
 });
 
 // Scene overlays for UI
-this.scene.launch('PauseMenuScene');
+this.scene.launch("PauseMenuScene");
 this.scene.pause();
-```text
+```
 
 ### Game Object Patterns
 
 **Component-Based Architecture:**
+
 ```typescript
 // Base game entity
 abstract class GameEntity extends Phaser.GameObjects.Sprite {
@@ -179,11 +187,11 @@ abstract class GameEntity extends Phaser.GameObjects.Sprite {
   }
 
   update(delta: number): void {
-    this.components.forEach(component => component.update(delta));
+    this.components.forEach((component) => component.update(delta));
   }
 
   destroy(): void {
-    this.components.forEach(component => component.destroy());
+    this.components.forEach((component) => component.destroy());
     this.components.clear();
     super.destroy();
   }
@@ -195,17 +203,18 @@ class Player extends GameEntity {
   private health!: HealthComponent;
 
   constructor(scene: Phaser.Scene, x: number, y: number) {
-    super(scene, x, y, 'player');
+    super(scene, x, y, "player");
 
     this.movement = this.addComponent(new MovementComponent(this));
     this.health = this.addComponent(new HealthComponent(this, 100));
   }
 }
-```text
+```
 
 ### System Management
 
 **Singleton Managers:**
+
 ```typescript
 class GameManager {
   private static instance: GameManager;
@@ -214,7 +223,7 @@ class GameManager {
 
   constructor(scene: Phaser.Scene) {
     if (GameManager.instance) {
-      throw new Error('GameManager already exists!');
+      throw new Error("GameManager already exists!");
     }
 
     this.scene = scene;
@@ -224,7 +233,7 @@ class GameManager {
 
   static getInstance(): GameManager {
     if (!GameManager.instance) {
-      throw new Error('GameManager not initialized!');
+      throw new Error("GameManager not initialized!");
     }
     return GameManager.instance;
   }
@@ -237,13 +246,14 @@ class GameManager {
     GameManager.instance = null!;
   }
 }
-```text
+```
 
 ## Performance Optimization
 
 ### Object Pooling
 
 **Required for High-Frequency Objects:**
+
 ```typescript
 class BulletPool {
   private pool: Bullet[] = [];
@@ -262,7 +272,7 @@ class BulletPool {
   }
 
   getBullet(): Bullet | null {
-    const bullet = this.pool.find(b => !b.active);
+    const bullet = this.pool.find((b) => !b.active);
     if (bullet) {
       bullet.setActive(true);
       bullet.setVisible(true);
@@ -270,7 +280,7 @@ class BulletPool {
     }
 
     // Pool exhausted - create new bullet
-    console.warn('Bullet pool exhausted, creating new bullet');
+    console.warn("Bullet pool exhausted, creating new bullet");
     return new Bullet(this.scene, 0, 0);
   }
 
@@ -280,13 +290,13 @@ class BulletPool {
     bullet.setPosition(0, 0);
   }
 }
-````
+```
 
 ### Frame Rate Optimization
 
 **Performance Monitoring:**
 
-````typescript
+```typescript
 class PerformanceMonitor {
   private frameCount: number = 0;
   private lastTime: number = 0;
@@ -311,9 +321,10 @@ class PerformanceMonitor {
     // Reduce particle counts, disable effects, etc.
   }
 }
-```text
+```
 
 **Update Loop Optimization:**
+
 ```typescript
 // Avoid expensive operations in update loops
 class GameScene extends Phaser.Scene {
@@ -334,13 +345,14 @@ class GameScene extends Phaser.Scene {
     }
   }
 }
-```text
+```
 
 ## Input Handling
 
 ### Cross-Platform Input
 
 **Input Abstraction:**
+
 ```typescript
 interface InputState {
   moveLeft: boolean;
@@ -356,7 +368,7 @@ class InputManager {
     moveRight: false,
     jump: false,
     action: false,
-    pause: false
+    pause: false,
   };
 
   private keys!: { [key: string]: Phaser.Input.Keyboard.Key };
@@ -368,12 +380,12 @@ class InputManager {
   }
 
   private setupKeyboard(): void {
-    this.keys = this.scene.input.keyboard.addKeys('W,A,S,D,SPACE,ESC,UP,DOWN,LEFT,RIGHT');
+    this.keys = this.scene.input.keyboard.addKeys("W,A,S,D,SPACE,ESC,UP,DOWN,LEFT,RIGHT");
   }
 
   private setupTouch(): void {
-    this.scene.input.on('pointerdown', this.handlePointerDown, this);
-    this.scene.input.on('pointerup', this.handlePointerUp, this);
+    this.scene.input.on("pointerdown", this.handlePointerDown, this);
+    this.scene.input.on("pointerup", this.handlePointerUp, this);
   }
 
   update(): void {
@@ -388,20 +400,21 @@ class InputManager {
     return { ...this.inputState };
   }
 }
-```text
+```
 
 ## Error Handling
 
 ### Graceful Degradation
 
 **Asset Loading Error Handling:**
+
 ```typescript
 class AssetManager {
   loadAssets(): Promise<void> {
     return new Promise((resolve, reject) => {
-      this.scene.load.on('filecomplete', this.handleFileComplete, this);
-      this.scene.load.on('loaderror', this.handleLoadError, this);
-      this.scene.load.on('complete', () => resolve());
+      this.scene.load.on("filecomplete", this.handleFileComplete, this);
+      this.scene.load.on("loaderror", this.handleLoadError, this);
+      this.scene.load.on("complete", () => resolve());
 
       this.scene.load.start();
     });
@@ -417,21 +430,21 @@ class AssetManager {
   private loadFallbackAsset(key: string): void {
     // Load placeholder or default assets
     switch (key) {
-      case 'player':
-        this.scene.load.image('player', 'assets/defaults/default-player.png');
+      case "player":
+        this.scene.load.image("player", "assets/defaults/default-player.png");
         break;
       default:
         console.warn(`No fallback for asset: ${key}`);
     }
   }
 }
-````
+```
 
 ### Runtime Error Recovery
 
 **System Error Handling:**
 
-````typescript
+```typescript
 class GameSystem {
   protected handleError(error: Error, context: string): void {
     console.error(`Error in ${context}:`, error);
@@ -445,11 +458,11 @@ class GameSystem {
 
   private attemptRecovery(context: string): void {
     switch (context) {
-      case 'update':
+      case "update":
         // Reset system state
         this.reset();
         break;
-      case 'render':
+      case "render":
         // Disable visual effects
         this.disableEffects();
         break;
@@ -459,16 +472,17 @@ class GameSystem {
     }
   }
 }
-```text
+```
 
 ## Testing Standards
 
 ### Unit Testing
 
 **Game Logic Testing:**
+
 ```typescript
 // Example test for game mechanics
-describe('HealthComponent', () => {
+describe("HealthComponent", () => {
   let healthComponent: HealthComponent;
 
   beforeEach(() => {
@@ -476,30 +490,31 @@ describe('HealthComponent', () => {
     healthComponent = new HealthComponent(mockEntity, 100);
   });
 
-  test('should initialize with correct health', () => {
+  test("should initialize with correct health", () => {
     expect(healthComponent.currentHealth).toBe(100);
     expect(healthComponent.maxHealth).toBe(100);
   });
 
-  test('should handle damage correctly', () => {
+  test("should handle damage correctly", () => {
     healthComponent.takeDamage(25);
     expect(healthComponent.currentHealth).toBe(75);
     expect(healthComponent.isAlive()).toBe(true);
   });
 
-  test('should handle death correctly', () => {
+  test("should handle death correctly", () => {
     healthComponent.takeDamage(150);
     expect(healthComponent.currentHealth).toBe(0);
     expect(healthComponent.isAlive()).toBe(false);
   });
 });
-```text
+```
 
 ### Integration Testing
 
 **Scene Testing:**
+
 ```typescript
-describe('GameScene Integration', () => {
+describe("GameScene Integration", () => {
   let scene: GameScene;
   let mockGame: Phaser.Game;
 
@@ -509,62 +524,60 @@ describe('GameScene Integration', () => {
     scene = new GameScene();
   });
 
-  test('should initialize all systems', () => {
+  test("should initialize all systems", () => {
     scene.create({});
 
     expect(scene.gameManager).toBeDefined();
     expect(scene.inputManager).toBeDefined();
   });
 });
-```text
+```
 
 ## File Organization
 
 ### Project Structure
 
-````
-
+```
 src/
 ├── scenes/
-│ ├── BootScene.ts # Initial loading and setup
-│ ├── PreloadScene.ts # Asset loading with progress
-│ ├── MenuScene.ts # Main menu and navigation
-│ ├── GameScene.ts # Core gameplay
-│ └── UIScene.ts # Overlay UI elements
+│   ├── BootScene.ts          # Initial loading and setup
+│   ├── PreloadScene.ts       # Asset loading with progress
+│   ├── MenuScene.ts          # Main menu and navigation
+│   ├── GameScene.ts          # Core gameplay
+│   └── UIScene.ts            # Overlay UI elements
 ├── gameObjects/
-│ ├── entities/
-│ │ ├── Player.ts # Player game object
-│ │ ├── Enemy.ts # Enemy base class
-│ │ └── Collectible.ts # Collectible items
-│ ├── components/
-│ │ ├── MovementComponent.ts
-│ │ ├── HealthComponent.ts
-│ │ └── CollisionComponent.ts
-│ └── ui/
-│ ├── Button.ts # Interactive buttons
-│ ├── HealthBar.ts # Health display
-│ └── ScoreDisplay.ts # Score UI
+│   ├── entities/
+│   │   ├── Player.ts         # Player game object
+│   │   ├── Enemy.ts          # Enemy base class
+│   │   └── Collectible.ts    # Collectible items
+│   ├── components/
+│   │   ├── MovementComponent.ts
+│   │   ├── HealthComponent.ts
+│   │   └── CollisionComponent.ts
+│   └── ui/
+│       ├── Button.ts         # Interactive buttons
+│       ├── HealthBar.ts      # Health display
+│       └── ScoreDisplay.ts   # Score UI
 ├── systems/
-│ ├── GameManager.ts # Core game state management
-│ ├── InputManager.ts # Cross-platform input handling
-│ ├── AudioManager.ts # Sound and music system
-│ ├── SaveManager.ts # Save/load functionality
-│ └── PerformanceMonitor.ts # Performance tracking
+│   ├── GameManager.ts        # Core game state management
+│   ├── InputManager.ts       # Cross-platform input handling
+│   ├── AudioManager.ts       # Sound and music system
+│   ├── SaveManager.ts        # Save/load functionality
+│   └── PerformanceMonitor.ts # Performance tracking
 ├── utils/
-│ ├── ObjectPool.ts # Generic object pooling
-│ ├── MathUtils.ts # Game math helpers
-│ ├── AssetLoader.ts # Asset management utilities
-│ └── EventBus.ts # Global event system
+│   ├── ObjectPool.ts         # Generic object pooling
+│   ├── MathUtils.ts          # Game math helpers
+│   ├── AssetLoader.ts        # Asset management utilities
+│   └── EventBus.ts           # Global event system
 ├── types/
-│ ├── GameTypes.ts # Core game type definitions
-│ ├── UITypes.ts # UI-related types
-│ └── SystemTypes.ts # System interface definitions
+│   ├── GameTypes.ts          # Core game type definitions
+│   ├── UITypes.ts            # UI-related types
+│   └── SystemTypes.ts        # System interface definitions
 ├── config/
-│ ├── GameConfig.ts # Phaser game configuration
-│ ├── GameBalance.ts # Game balance parameters
-│ └── AssetConfig.ts # Asset loading configuration
-└── main.ts # Application entry point
-
+│   ├── GameConfig.ts         # Phaser game configuration
+│   ├── GameBalance.ts        # Game balance parameters
+│   └── AssetConfig.ts        # Asset loading configuration
+└── main.ts                   # Application entry point
 ```
 
 ## Development Workflow
@@ -572,21 +585,25 @@ src/
 ### Story Implementation Process
 
 1. **Read Story Requirements:**
+
    - Understand acceptance criteria
    - Identify technical requirements
    - Review performance constraints
 
 2. **Plan Implementation:**
+
    - Identify files to create/modify
    - Consider component architecture
    - Plan testing approach
 
 3. **Implement Feature:**
+
    - Follow TypeScript strict mode
    - Use established patterns
    - Maintain 60 FPS performance
 
 4. **Test Implementation:**
+
    - Write unit tests for game logic
    - Test cross-platform functionality
    - Validate performance targets
@@ -599,6 +616,7 @@ src/
 ### Code Review Checklist
 
 **Before Committing:**
+
 - [ ] TypeScript compiles without errors
 - [ ] All tests pass
 - [ ] Performance targets met (60 FPS)
@@ -612,20 +630,22 @@ src/
 ## Performance Targets
 
 ### Frame Rate Requirements
+
 - **Desktop**: Maintain 60 FPS at 1080p
 - **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.
-```

package/expansion-packs/bmad-2d-phaser-game-dev/templates/game-architecture-tmpl.md

@@ -59,7 +59,7 @@ This architecture is designed to support the gameplay mechanics defined in the G
 
 [[LLM: Design a clear folder structure for game development]]
 
-````text
+```text
 {{game_name}}/
 ├── src/
 │   ├── scenes/          # Game scenes
@@ -80,7 +80,7 @@ This architecture is designed to support the gameplay mechanics defined in the G
 │   ├── stories/         # Development stories
 │   └── architecture/    # Technical docs
 └── dist/                # Built game files
-```text
+```
 
 ### Module Organization
 
@@ -365,7 +365,7 @@ const gameConfig: Phaser.Types.Core.GameConfig = {
     },
     // Additional configuration...
 };
-```text
+```
 
 ### Game Balance Configuration
 
@@ -386,7 +386,7 @@ export const GameBalance = {
     },
     // Additional balance parameters...
 };
-````
+```
 
 ## Development Guidelines