comment

Author: ryanbarlow97

src/client/ClientGameRunner.ts

@@ -13,6 +13,7 @@ import {
 import { createPartialGameRecord, replacer } from "../core/Util";
 import { ServerConfig } from "../core/configuration/Config";
 import { getConfig } from "../core/configuration/ConfigLoader";
+import { TestSkinExecution } from "../core/execution/TestSkinExecution";
 import { PlayerActions, UnitType } from "../core/game/Game";
 import { TileRef } from "../core/game/GameMap";
 import { GameMapLoader } from "../core/game/GameMapLoader";
@@ -40,7 +41,6 @@ import {
 } from "./InputHandler";
 import { endGame, startGame, startTime } from "./LocalPersistantStats";
 import { terrainMapFileLoader } from "./TerrainMapFileLoader";
-import { TestSkinExecution } from "./TestSkinExecution";
 import {
   SendAttackIntentEvent,
   SendBoatAttackIntentEvent,
@@ -52,6 +52,7 @@ import {
 import { createCanvas } from "./Utils";
 import { createRenderer, GameRenderer } from "./graphics/GameRenderer";
 import { GoToPlayerEvent } from "./graphics/layers/Leaderboard";
+import { ShowSkinTestModalEvent } from "./graphics/layers/SkinTestWinModal";
 import SoundManager from "./sound/SoundManager";
 import { ReplaySpeedMultiplier } from "./utilities/ReplaySpeedMultiplier";
 
@@ -364,14 +365,19 @@ export class ClientGameRunner {
       // Start a fresh TestSkinExecution which manages its own modal timeout
       this.testSkinExecution = new TestSkinExecution(
         this.gameView,
-        this.eventBus,
         this.lobby.clientID,
         () => this.isActive,
         () => {
           // Called when execution requests the modal be shown — stop the game and
           // clean up resources first.
           this.stop();
         },
+        (targetID, troops) =>
+          this.eventBus.emit(new SendAttackIntentEvent(targetID, troops)),
+        (patternName, colorPalette) =>
+          this.eventBus.emit(
+            new ShowSkinTestModalEvent(patternName, colorPalette),
+          ),
       );
       this.testSkinExecution.start();
     }

src/client/TestSkinExecution.ts src/core/execution/TestSkinExecution.tssrc/client/TestSkinExecution.ts renamed to src/core/execution/TestSkinExecution.ts

@@ -1,24 +1,38 @@
-import { EventBus } from "../core/EventBus";
-import { GameView, PlayerView } from "../core/game/GameView";
-import { ClientID } from "../core/Schemas";
-import { ShowSkinTestModalEvent } from "./graphics/layers/SkinTestWinModal";
-import { SendAttackIntentEvent } from "./Transport";
+import { ColorPalette } from "../CosmeticSchemas";
+import { Execution, Game, PlayerID } from "../game/Game";
+import { GameView, PlayerView } from "../game/GameView";
+import { ClientID } from "../Schemas";
 
-export class TestSkinExecution {
+export class TestSkinExecution implements Execution {
   private myPlayer: PlayerView | null = null;
   private initialAttackTimeoutId: ReturnType<typeof setTimeout> | null = null;
   private modalTimeoutId: ReturnType<typeof setTimeout> | null = null;
+  private active = true;
 
   constructor(
     private gameView: GameView,
-    private eventBus: EventBus,
     private clientID: ClientID,
-
-    private isActive: () => boolean,
-    // callback to request the runner stop the game before showing the modal
+    private isRunnerActive: () => boolean,
     private onShowModalRequested: () => void,
+    private onAttackIntent: (targetID: PlayerID | null, troops: number) => void,
+    private onShowModal: (
+      patternName: string,
+      colorPalette: ColorPalette | null,
+    ) => void,
   ) {}
 
+  isActive(): boolean {
+    return this.active;
+  }
+
+  activeDuringSpawnPhase(): boolean {
+    return false;
+  }
+
+  init(_mg: Game, _ticks: number): void {}
+
+  tick(_ticks: number): void {}
+
   public start() {
     // schedule the initial attack
     this.scheduleInitialAttack(100);
@@ -30,12 +44,13 @@ export class TestSkinExecution {
     }
     this.modalTimeoutId = setTimeout(() => {
       this.modalTimeoutId = null;
-      if (!this.isActive()) return;
+      if (!this.isRunnerActive()) return;
       this.showModal();
     }, 120000);
   }
 
   public stop() {
+    this.active = false;
     if (this.initialAttackTimeoutId !== null) {
       clearTimeout(this.initialAttackTimeoutId);
       this.initialAttackTimeoutId = null;
@@ -74,7 +89,7 @@ export class TestSkinExecution {
     const patternName = myPlayer.cosmetics.pattern.name;
     const colorPalette = myPlayer.cosmetics.pattern.colorPalette ?? null;
 
-    this.eventBus.emit(new ShowSkinTestModalEvent(patternName, colorPalette));
+    this.onShowModal(patternName, colorPalette);
   }
 
   private scheduleInitialAttack(delayMs: number) {
@@ -84,13 +99,13 @@ export class TestSkinExecution {
     }
     this.initialAttackTimeoutId = setTimeout(() => {
       this.initialAttackTimeoutId = null;
-      if (!this.isActive()) return;
+      if (!this.isRunnerActive()) return;
       this.initialAttack();
     }, delayMs);
   }
 
   private initialAttack() {
-    if (!this.isActive()) return;
+    if (!this.isRunnerActive()) return;
 
     if (this.myPlayer === null) {
       const myPlayer = this.gameView.playerByClientID(this.clientID);
@@ -103,8 +118,6 @@ export class TestSkinExecution {
     }
 
     const troopCount = this.myPlayer.troops() ?? 1000000;
-    this.eventBus.emit(
-      new SendAttackIntentEvent(null, Math.floor(troopCount / 2)),
-    );
+    this.onAttackIntent(null, Math.floor(troopCount / 2));
   }
 }

tests/client/TestSkinExecution.test.ts

@@ -1,14 +1,8 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { ShowSkinTestModalEvent } from "../../src/client/graphics/layers/SkinTestWinModal";
-import { TestSkinExecution } from "../../src/client/TestSkinExecution";
-import { SendAttackIntentEvent } from "../../src/client/Transport";
-import { EventBus } from "../../src/core/EventBus";
+import { TestSkinExecution } from "../../src/core/execution/TestSkinExecution";
 
 describe("TestSkinExecution", () => {
-  let eventBus: EventBus;
-
   beforeEach(() => {
-    eventBus = new EventBus();
     vi.useFakeTimers();
   });
 
@@ -17,7 +11,7 @@ describe("TestSkinExecution", () => {
     vi.restoreAllMocks();
   });
 
-  it("showModal emits ShowSkinTestModalEvent and prevents scheduled initial attack", () => {
+  it("showModal calls onShowModal and prevents scheduled initial attack", () => {
     const fakePlayer = {
       cosmetics: { pattern: { name: "pattern1", colorPalette: { name: "p" } } },
       troops: () => 100,
@@ -27,15 +21,17 @@ describe("TestSkinExecution", () => {
       playerByClientID: (_: any) => fakePlayer,
     } as any;
 
-    const spyEmit = vi.spyOn(eventBus, "emit");
     const onShowModalRequested = vi.fn();
+    const onAttackIntent = vi.fn();
+    const onShowModal = vi.fn();
 
     const exec = new TestSkinExecution(
       gameView,
-      eventBus,
       "client1" as any,
       () => true,
       onShowModalRequested,
+      onAttackIntent,
+      onShowModal,
     );
 
     exec.start();
@@ -46,21 +42,12 @@ describe("TestSkinExecution", () => {
     // Should have requested runner to stop
     expect(onShowModalRequested).toHaveBeenCalled();
 
-    // Should have emitted the ShowSkinTestModalEvent once with the right payload
-    const emitted = spyEmit.mock.calls.map((c) => c[0]);
-    expect(emitted.some((e) => e instanceof ShowSkinTestModalEvent)).toBe(true);
-    const modalEvent = emitted.find(
-      (e) => e instanceof ShowSkinTestModalEvent,
-    ) as ShowSkinTestModalEvent;
-    expect(modalEvent).toBeDefined();
-    expect(modalEvent.patternName).toBe("pattern1");
+    // Should have called onShowModal with the right payload
+    expect(onShowModal).toHaveBeenCalledWith("pattern1", { name: "p" });
 
-    // Advance timers past the initial attack delay; since showModal cleared timeouts, no SendAttackIntentEvent should be emitted
+    // Advance timers past the initial attack delay; since showModal cleared timeouts, no attack should fire
     vi.advanceTimersByTime(500);
-    const emittedAfter = spyEmit.mock.calls.map((c) => c[0]);
-    expect(emittedAfter.some((e) => e instanceof SendAttackIntentEvent)).toBe(
-      false,
-    );
+    expect(onAttackIntent).not.toHaveBeenCalled();
   });
 
   it("start schedules initial attack if not cancelled", () => {
@@ -73,24 +60,23 @@ describe("TestSkinExecution", () => {
       playerByClientID: (_: any) => fakePlayer,
     } as any;
 
-    const spyEmit = vi.spyOn(eventBus, "emit");
+    const onAttackIntent = vi.fn();
 
     const exec = new TestSkinExecution(
       gameView,
-      eventBus,
       "client1" as any,
       () => true,
       () => {},
+      onAttackIntent,
+      () => {},
     );
 
     exec.start();
 
     // advance past initial attack delay
     vi.advanceTimersByTime(200);
 
-    // initial attack should have emitted a SendAttackIntentEvent
-    expect(
-      spyEmit.mock.calls.some((c) => c[0] instanceof SendAttackIntentEvent),
-    ).toBe(true);
+    // initial attack should have called the onAttackIntent callback
+    expect(onAttackIntent).toHaveBeenCalledWith(null, 50);
   });
 });