labag 2.4.3 → 2.5.1

package/dist/labag.d.ts

@@ -20,7 +20,7 @@ export declare class LaBaG {
     /** 當前轉出的圖案組合 */
     patterns: [Pattern | null, Pattern | null, Pattern | null];
     /** 遊戲模式列表 */
-    modes: Mode[];
+    modes: Mode<any>[];
     /** 事件監聽器列表 */
     eventListeners: Record<LaBaGEvent, ((game: LaBaG) => void)[]>;
     /**
@@ -49,7 +49,7 @@ export declare class LaBaG {
      * 新增遊戲模式。
      * @param mode - 要新增的模式。
      */
-    addMode(mode: Mode): void;
+    addMode(mode: Mode<any>): void;
     /**
      * 檢查遊戲是否正在進行中（未達次數上限）。
      * @returns 如果遊戲仍在進行中則返回 true，否則返回 false。
@@ -59,7 +59,7 @@ export declare class LaBaG {
      * 取得目前遊戲的相關設定
      */
     getCurrentConfig(): {
-        modes: Mode[];
+        modes: Mode<any>[];
         ranges: {
             threshold: number;
             pattern: Pattern;

package/dist/labag.js

@@ -52,7 +52,10 @@ class LaBaG {
      * @param event - 要觸發的事件名稱。
      */
     emit(event) {
-        [...this.eventListeners[event]].forEach((fn) => fn(this));
+        const listeners = this.eventListeners[event];
+        for (let i = 0; i < listeners.length; i++) {
+            listeners[i](this);
+        }
     }
     /**
      * 新增事件監聽器。
@@ -110,11 +113,12 @@ class LaBaG {
             kachu: 0,
             rrr: 0,
         };
-        activeModes.forEach((mode) => {
-            Object.entries(mode.rates).forEach(([patternName, rate]) => {
-                combinedRates[patternName] += rate;
-            });
-        });
+        for (let i = 0; i < activeModes.length; i++) {
+            const mode = activeModes[i];
+            for (const patternName in mode.rates) {
+                combinedRates[patternName] += mode.rates[patternName];
+            }
+        }
         // 預先計算合併後的區間
         const ranges = [];
         let acc = 0;
@@ -154,22 +158,19 @@ class LaBaG {
     rollSlots() {
         const { ranges } = this.getCurrentConfig();
         const rangesAcc = ranges.length > 0 ? ranges[ranges.length - 1].threshold : 0;
-        // 產生 3 個隨機數字
-        this.randNums = [
-            (0, randInt_1.randInt)(1, rangesAcc),
-            (0, randInt_1.randInt)(1, rangesAcc),
-            (0, randInt_1.randInt)(1, rangesAcc),
-        ];
-        this.randNums.forEach((num, index) => {
-            // 根據預先計算的區間找到對應的圖案
-            const match = ranges.find((r) => num <= r.threshold);
-            if (match) {
-                this.patterns[index] = match.pattern;
+        // 產生 3 個隨機數字並直接尋找對應圖案
+        for (let i = 0; i < 3; i++) {
+            const num = (0, randInt_1.randInt)(1, rangesAcc);
+            this.randNums[i] = num;
+            let matchedPattern = null;
+            for (let j = 0; j < ranges.length; j++) {
+                if (num <= ranges[j].threshold) {
+                    matchedPattern = ranges[j].pattern;
+                    break;
+                }
             }
-            else {
-                this.patterns[index] = null;
-            }
-        });
+            this.patterns[i] = matchedPattern;
+        }
         this.emit("rollSlots");
     }
     /**

package/dist/mode.d.ts

@@ -1,9 +1,16 @@
 import { LaBaG } from "./labag";
 import { LaBaGEvent, Pattern, PatternName } from "./types";
+interface ModeConfig<VariableType extends Record<string, any>> {
+    active: boolean;
+    name: string;
+    rates: Record<PatternName, number>;
+    eventListener?: Partial<Record<LaBaGEvent, (game: LaBaG, mode: Mode<VariableType>) => void>>;
+    variable?: VariableType;
+}
 /**
  * 代表遊戲的一種模式，包含機率設定和事件監聽器。
  */
-export declare class Mode {
+export declare class Mode<VariableType extends Record<string, any> = Record<string, any>> implements ModeConfig<VariableType> {
     /** 模式是否啟用 */
     active: boolean;
     /** 模式名稱 */
@@ -15,9 +22,9 @@ export declare class Mode {
         pattern: Pattern;
     }[];
     /** 事件監聽器 */
-    eventListener: Partial<Record<LaBaGEvent, (game: LaBaG, mode: Mode) => void>>;
+    eventListener: Partial<Record<LaBaGEvent, (game: LaBaG, mode: Mode<VariableType>) => void>>;
     /** 模式專屬的變數儲存空間 */
-    variable: Record<string, any>;
+    variable: VariableType;
     /** 機率總和 */
     /**
      * 建立一個新的模式。
@@ -26,5 +33,6 @@ export declare class Mode {
      * @param rates - 各圖案的機率設定。
      * @param eventListener - 事件監聽器。
      */
-    constructor(active: boolean, name: string, rates: Record<PatternName, number>, eventListener?: Partial<Record<LaBaGEvent, (game: LaBaG, mode: Mode) => void>>, variable?: Record<string, any>);
+    constructor(active: boolean, name: string, rates: Record<PatternName, number>, eventListener?: Partial<Record<LaBaGEvent, (game: LaBaG, mode: Mode<VariableType>) => void>>, variable?: VariableType);
 }
+export {};

package/dist/modes/greenwei.d.ts

@@ -1,3 +1,20 @@
 import { Mode } from "../mode";
-declare const _default: Mode;
+declare const _default: Mode<{
+    times: number;
+    rate: number;
+    randNum: number;
+    count: number;
+    pattern: {
+        name: string;
+        scores: number[];
+    };
+    extendTimes: number;
+    bindPattern: {
+        readonly name: "gss";
+        readonly scores: [800, 400, 180];
+    };
+    bonusTimes: number;
+    requiredBindPatternCount: number;
+    mutiplier: number;
+}>;
 export default _default;

package/dist/modes/index.d.ts

@@ -1,8 +1,94 @@
 export declare const modes: {
-    pikachu: import("..").Mode;
-    superhhh: import("..").Mode;
-    greenwei: import("..").Mode;
-    normal: import("..").Mode;
+    pikachu: import("..").Mode<{
+        times: number;
+        pattern: {
+            name: string;
+            scores: number[];
+        };
+        bindPattern: {
+            readonly name: "kachu";
+            readonly scores: [12000, 8000, 1250];
+        };
+        bonusRounds: number;
+    }>;
+    superhhh: import("..").Mode<{
+        times: number;
+        rate: number;
+        score: number;
+        randNum: number;
+        bindPattern: {
+            readonly name: "hhh";
+            readonly scores: [1500, 800, 300];
+        };
+        bonusTimes: number;
+        pattern: {
+            name: string;
+            scores: number[];
+        };
+        extendTimes: number;
+    }>;
+    greenwei: import("..").Mode<{
+        times: number;
+        rate: number;
+        randNum: number;
+        count: number;
+        pattern: {
+            name: string;
+            scores: number[];
+        };
+        extendTimes: number;
+        bindPattern: {
+            readonly name: "gss";
+            readonly scores: [800, 400, 180];
+        };
+        bonusTimes: number;
+        requiredBindPatternCount: number;
+        mutiplier: number;
+    }>;
+    normal: import("..").Mode<Record<string, any>>;
 };
 export type ModeName = keyof typeof modes;
-export declare const modeList: import("..").Mode[];
+export declare const modeList: (import("..").Mode<{
+    times: number;
+    rate: number;
+    randNum: number;
+    count: number;
+    pattern: {
+        name: string;
+        scores: number[];
+    };
+    extendTimes: number;
+    bindPattern: {
+        readonly name: "gss";
+        readonly scores: [800, 400, 180];
+    };
+    bonusTimes: number;
+    requiredBindPatternCount: number;
+    mutiplier: number;
+}> | import("..").Mode<Record<string, any>> | import("..").Mode<{
+    times: number;
+    pattern: {
+        name: string;
+        scores: number[];
+    };
+    bindPattern: {
+        readonly name: "kachu";
+        readonly scores: [12000, 8000, 1250];
+    };
+    bonusRounds: number;
+}> | import("..").Mode<{
+    times: number;
+    rate: number;
+    score: number;
+    randNum: number;
+    bindPattern: {
+        readonly name: "hhh";
+        readonly scores: [1500, 800, 300];
+    };
+    bonusTimes: number;
+    pattern: {
+        name: string;
+        scores: number[];
+    };
+    extendTimes: number;
+}>)[];

package/dist/modes/normal.d.ts

@@ -1,3 +1,3 @@
 import { Mode } from "../mode";
-declare const _default: Mode;
+declare const _default: Mode<Record<string, any>>;
 export default _default;

package/dist/modes/pikachu.d.ts

@@ -1,3 +1,14 @@
 import { Mode } from "../mode";
-declare const _default: Mode;
+declare const _default: Mode<{
+    times: number;
+    pattern: {
+        name: string;
+        scores: number[];
+    };
+    bindPattern: {
+        readonly name: "kachu";
+        readonly scores: [12000, 8000, 1250];
+    };
+    bonusRounds: number;
+}>;
 export default _default;

package/dist/modes/superhhh.d.ts

@@ -1,3 +1,18 @@
 import { Mode } from "../mode";
-declare const _default: Mode;
+declare const _default: Mode<{
+    times: number;
+    rate: number;
+    score: number;
+    randNum: number;
+    bindPattern: {
+        readonly name: "hhh";
+        readonly scores: [1500, 800, 300];
+    };
+    bonusTimes: number;
+    pattern: {
+        name: string;
+        scores: number[];
+    };
+    extendTimes: number;
+}>;
 export default _default;

package/dist/recordChecker.js

@@ -21,48 +21,39 @@ class RecordChecker {
      * @returns 計算出的分數。
      */
     calculateScore(record) {
-        // 重置遊戲狀態
+        // 警告：此操作會重置並覆蓋當前傳入的遊戲實例狀態
         this.game.init();
         this.game.times = record.times;
-        // 使用 any 類型來存取私有方法
-        const gameAny = this.game;
         for (const round of record.rounds) {
             if (!this.game.isRunning()) {
                 throw new Error("遊戲次數已達上限，無法繼續遊玩。");
             }
             // 1. 回合開始
-            gameAny.roundStart();
+            this.game["roundStart"]();
             // 2. 設定隨機數字與圖案 (模擬 rollSlots)
             const { ranges } = this.game.getCurrentConfig();
-            this.game.randNums = [
-                round.randNums["0"],
-                round.randNums["1"],
-                round.randNums["2"],
-            ];
-            this.game.randNums.forEach((num, index) => {
+            for (let i = 0; i < 3; i++) {
+                const num = round.randNums?.[i.toString()] ?? 0;
+                this.game.randNums[i] = num;
                 const match = ranges.find((r) => num <= r.threshold);
-                if (match) {
-                    this.game.patterns[index] = match.pattern;
-                }
-                else {
-                    this.game.patterns[index] = null;
-                }
-            });
+                this.game.patterns[i] = match ? match.pattern : null;
+            }
             // 觸發 rollSlots 事件，讓模式執行其邏輯 (例如 greenwei 產生隨機數)
-            gameAny.emit("rollSlots");
+            this.game["emit"]("rollSlots");
             // 3. 覆蓋模式的隨機變數 (確保使用紀錄中的數值)
             this.game.modes.forEach((mode) => {
-                if (round.randNums[mode.name] !== undefined) {
-                    mode.variable.randNum = round.randNums[mode.name];
+                const recordedNum = round.randNums?.[mode.name];
+                if (recordedNum !== undefined && mode.variable) {
+                    mode.variable.randNum = recordedNum;
                 }
             });
             // 4. 計算分數
-            gameAny.calculateScore();
+            this.game["calculateScore"]();
             // 5. 回合結束
-            gameAny.roundEnd();
+            this.game["roundEnd"]();
         }
         if (!this.game.isRunning()) {
-            gameAny.gameOver();
+            this.game["gameOver"]();
         }
         return this.game.score;
     }

package/dist/recorder.d.ts

@@ -1,11 +1,11 @@
 import { LaBaG } from "./labag";
 export type RoundRecord = {
-    randNums: Record<string, number>;
+    readonly randNums: Readonly<Record<string, number>>;
 };
 export type GameRecord = {
     times: number;
     score: number;
-    rounds: RoundRecord[];
+    readonly rounds: ReadonlyArray<RoundRecord>;
 };
 export type RecorderOptions = {
     debug?: boolean;
@@ -14,13 +14,10 @@ export declare class Recorder {
     #private;
     private game;
     private score;
-    private onRoundEndBound;
     private started;
     private debug;
     constructor(gameInstance: LaBaG, options?: RecorderOptions);
-    get rounds(): {
-        randNums: Record<string, number>;
-    }[];
+    get rounds(): ReadonlyArray<RoundRecord>;
     private onRoundEnd;
     init(clearExisting?: boolean): void;
     dispose(): void;

package/dist/recorder.js

@@ -5,28 +5,26 @@ class Recorder {
     game;
     #rounds = [];
     score = 0;
-    onRoundEndBound;
     started = false;
     debug = false;
     constructor(gameInstance, options) {
         this.game = gameInstance;
-        this.onRoundEndBound = this.onRoundEnd.bind(this);
-        this.debug = !!options?.debug;
+        this.debug = options?.debug ?? false;
     }
     get rounds() {
-        return this.#rounds.map((r) => ({ ...r }));
+        return this.#rounds;
     }
-    onRoundEnd(g) {
+    onRoundEnd = (g) => {
         const randNums = {};
         g.randNums.forEach((value, key) => {
-            if (!isNaN(value)) {
+            if (typeof value === "number" && !Number.isNaN(value)) {
                 randNums[key] = value;
             }
         });
         // 收集各模式的 randNum（若為數值且有效）
         g.modes.forEach((mode) => {
             const rn = mode?.variable?.randNum;
-            if (!isNaN(rn)) {
+            if (typeof rn === "number" && !Number.isNaN(rn)) {
                 randNums[mode.name] = rn;
             }
         });
@@ -40,7 +38,7 @@ class Recorder {
             });
         this.#rounds.push(round);
         this.score = g.score;
-    }
+    };
     init(clearExisting = true) {
         if (this.started)
             return;
@@ -48,14 +46,14 @@ class Recorder {
             this.clear();
         }
         if (typeof this.game.addEventListener === "function") {
-            this.game.addEventListener("roundEnd", this.onRoundEndBound);
+            this.game.addEventListener("roundEnd", this.onRoundEnd);
             this.started = true;
         }
     }
     dispose() {
         if (!this.started)
             return;
-        this.game.removeEventListener("roundEnd", this.onRoundEndBound);
+        this.game.removeEventListener("roundEnd", this.onRoundEnd);
         this.started = false;
     }
     clear() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "labag",
-  "version": "2.4.3",
+  "version": "2.5.1",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/labag.ts

@@ -23,7 +23,7 @@ export class LaBaG {
   /** 當前轉出的圖案組合 */
   patterns: [Pattern | null, Pattern | null, Pattern | null];
   /** 遊戲模式列表 */
-  modes: Mode[];
+  modes: Mode<any>[];
   /** 事件監聽器列表 */
   eventListeners: Record<LaBaGEvent, ((game: LaBaG) => void)[]>;
 
@@ -55,7 +55,10 @@ export class LaBaG {
    * @param event - 要觸發的事件名稱。
    */
   private emit(event: LaBaGEvent) {
-    [...this.eventListeners[event]].forEach((fn) => fn(this));
+    const listeners = this.eventListeners[event];
+    for (let i = 0; i < listeners.length; i++) {
+      listeners[i](this);
+    }
   }
 
   /**
@@ -83,7 +86,7 @@ export class LaBaG {
    * 新增遊戲模式。
    * @param mode - 要新增的模式。
    */
-  addMode(mode: Mode) {
+  addMode(mode: Mode<any>) {
     this.modes.push(mode);
     // 註冊特定模式的監聽器
     Object.entries(mode.eventListener).forEach(([event, listener]) => {
@@ -120,11 +123,12 @@ export class LaBaG {
       kachu: 0,
       rrr: 0,
     };
-    activeModes.forEach((mode) => {
-      Object.entries(mode.rates).forEach(([patternName, rate]) => {
-        combinedRates[patternName as PatternName] += rate;
-      });
-    });
+    for (let i = 0; i < activeModes.length; i++) {
+      const mode = activeModes[i];
+      for (const patternName in mode.rates) {
+        combinedRates[patternName as PatternName] += mode.rates[patternName as PatternName];
+      }
+    }
 
     // 預先計算合併後的區間
     const ranges: { threshold: number; pattern: Pattern }[] = [];
@@ -170,22 +174,21 @@ export class LaBaG {
     const { ranges } = this.getCurrentConfig();
     const rangesAcc =
       ranges.length > 0 ? ranges[ranges.length - 1].threshold : 0;
-    // 產生 3 個隨機數字
-    this.randNums = [
-      randInt(1, rangesAcc),
-      randInt(1, rangesAcc),
-      randInt(1, rangesAcc),
-    ];
-
-    this.randNums.forEach((num, index) => {
-      // 根據預先計算的區間找到對應的圖案
-      const match = ranges.find((r) => num <= r.threshold);
-      if (match) {
-        this.patterns[index] = match.pattern;
-      } else {
-        this.patterns[index] = null;
+    
+    // 產生 3 個隨機數字並直接尋找對應圖案
+    for (let i = 0; i < 3; i++) {
+      const num = randInt(1, rangesAcc);
+      this.randNums[i] = num;
+      
+      let matchedPattern: Pattern | null = null;
+      for (let j = 0; j < ranges.length; j++) {
+        if (num <= ranges[j].threshold) {
+          matchedPattern = ranges[j].pattern;
+          break;
+        }
       }
-    });
+      this.patterns[i] = matchedPattern;
+    }
 
     this.emit("rollSlots");
   }

package/src/mode.ts

@@ -1,11 +1,22 @@
 import { LaBaG } from "./labag";
 import { patterns } from "./pattern";
 import { LaBaGEvent, Pattern, PatternName } from "./types";
+interface ModeConfig<VariableType extends Record<string, any>> {
+  active: boolean;
+  name: string;
+  rates: Record<PatternName, number>;
+  eventListener?: Partial<
+    Record<LaBaGEvent, (game: LaBaG, mode: Mode<VariableType>) => void>
+  >;
+  variable?: VariableType;
+}
 
 /**
  * 代表遊戲的一種模式，包含機率設定和事件監聽器。
  */
-export class Mode{
+export class Mode<
+  VariableType extends Record<string, any> = Record<string, any>,
+> implements ModeConfig<VariableType> {
   /** 模式是否啟用 */
   active: boolean;
   /** 模式名稱 */
@@ -16,11 +27,11 @@ export class Mode{
   ranges: { threshold: number; pattern: Pattern }[];
   /** 事件監聽器 */
   eventListener: Partial<
-    Record<LaBaGEvent, (game: LaBaG, mode: Mode) => void>
+    Record<LaBaGEvent, (game: LaBaG, mode: Mode<VariableType>) => void>
   >;
 
   /** 模式專屬的變數儲存空間 */
-  variable: Record<string, any>;
+  variable: VariableType;
   /** 機率總和 */
 
   /**
@@ -35,15 +46,15 @@ export class Mode{
     name: string,
     rates: Record<PatternName, number>,
     eventListener?: Partial<
-      Record<LaBaGEvent, (game: LaBaG, mode: Mode) => void>
+      Record<LaBaGEvent, (game: LaBaG, mode: Mode<VariableType>) => void>
     >,
-    variable?: Record<string, any>
+    variable?: VariableType,
   ) {
     this.active = active;
     this.name = name;
     this.rates = rates;
     this.eventListener = eventListener ?? {};
-    this.variable = variable ?? {};
+    this.variable = variable ?? ({} as VariableType);
 
     // 預先計算機率區間
     this.ranges = [];

package/src/recordChecker.ts

@@ -24,58 +24,49 @@ export class RecordChecker {
    * @returns 計算出的分數。
    */
   calculateScore(record: GameRecord): number {
-    // 重置遊戲狀態
+    // 警告：此操作會重置並覆蓋當前傳入的遊戲實例狀態
     this.game.init();
     this.game.times = record.times;
 
-    // 使用 any 類型來存取私有方法
-    const gameAny = this.game as any;
-
     for (const round of record.rounds) {
       if (!this.game.isRunning()) {
         throw new Error("遊戲次數已達上限，無法繼續遊玩。");
       }
 
       // 1. 回合開始
-      gameAny.roundStart();
+      this.game["roundStart"]();
 
       // 2. 設定隨機數字與圖案 (模擬 rollSlots)
       const { ranges } = this.game.getCurrentConfig();
-      
-      this.game.randNums = [
-        round.randNums["0"],
-        round.randNums["1"],
-        round.randNums["2"],
-      ];
-
-      this.game.randNums.forEach((num, index) => {
+
+      for (let i = 0; i < 3; i++) {
+        const num = round.randNums?.[i.toString()] ?? 0;
+        this.game.randNums[i] = num;
+
         const match = ranges.find((r) => num <= r.threshold);
-        if (match) {
-          this.game.patterns[index] = match.pattern;
-        } else {
-          this.game.patterns[index] = null;
-        }
-      });
+        this.game.patterns[i] = match ? match.pattern : null;
+      }
 
       // 觸發 rollSlots 事件，讓模式執行其邏輯 (例如 greenwei 產生隨機數)
-      gameAny.emit("rollSlots");
+      this.game["emit"]("rollSlots");
 
       // 3. 覆蓋模式的隨機變數 (確保使用紀錄中的數值)
       this.game.modes.forEach((mode) => {
-        if (round.randNums[mode.name] !== undefined) {
-          mode.variable.randNum = round.randNums[mode.name];
+        const recordedNum = round.randNums?.[mode.name];
+        if (recordedNum !== undefined && mode.variable) {
+          mode.variable.randNum = recordedNum;
         }
       });
 
       // 4. 計算分數
-      gameAny.calculateScore();
+      this.game["calculateScore"]();
 
       // 5. 回合結束
-      gameAny.roundEnd();
+      this.game["roundEnd"]();
     }
 
     if (!this.game.isRunning()) {
-      gameAny.gameOver();
+      this.game["gameOver"]();
     }
 
     return this.game.score;

package/src/recorder.ts

@@ -1,13 +1,13 @@
 import { LaBaG } from "./labag";
 
 export type RoundRecord = {
-  randNums: Record<string, number>;
+  readonly randNums: Readonly<Record<string, number>>;
 };
 
 export type GameRecord = {
   times: number;
   score: number;
-  rounds: RoundRecord[];
+  readonly rounds: ReadonlyArray<RoundRecord>;
 };
 
 export type RecorderOptions = {
@@ -17,25 +17,23 @@ export class Recorder {
   private game: LaBaG;
   #rounds: RoundRecord[] = [];
   private score: number = 0;
-  private onRoundEndBound: (e: LaBaG) => void;
   private started = false;
   private debug = false;
 
   constructor(gameInstance: LaBaG, options?: RecorderOptions) {
     this.game = gameInstance;
-    this.onRoundEndBound = this.onRoundEnd.bind(this);
-    this.debug = !!options?.debug;
+    this.debug = options?.debug ?? false;
   }
 
-  get rounds() {
-    return this.#rounds.map((r) => ({ ...r }));
+  get rounds(): ReadonlyArray<RoundRecord> {
+    return this.#rounds;
   }
 
-  private onRoundEnd(g: LaBaG) {
+  private onRoundEnd = (g: LaBaG) => {
     const randNums: Record<string, number> = {};
 
     g.randNums.forEach((value, key) => {
-      if (!isNaN(value)) {
+      if (typeof value === "number" && !Number.isNaN(value)) {
         randNums[key] = value;
       }
     });
@@ -43,7 +41,7 @@ export class Recorder {
     // 收集各模式的 randNum（若為數值且有效）
     g.modes.forEach((mode) => {
       const rn = mode?.variable?.randNum;
-      if (!isNaN(rn)) {
+      if (typeof rn === "number" && !Number.isNaN(rn)) {
         randNums[mode.name] = rn;
       }
     });
@@ -60,7 +58,7 @@ export class Recorder {
 
     this.#rounds.push(round);
     this.score = g.score;
-  }
+  };
 
   init(clearExisting = true) {
     if (this.started) return;
@@ -68,14 +66,14 @@ export class Recorder {
       this.clear();
     }
     if (typeof this.game.addEventListener === "function") {
-      this.game.addEventListener("roundEnd", this.onRoundEndBound);
+      this.game.addEventListener("roundEnd", this.onRoundEnd);
       this.started = true;
     }
   }
 
   dispose() {
     if (!this.started) return;
-    this.game.removeEventListener("roundEnd", this.onRoundEndBound);
+    this.game.removeEventListener("roundEnd", this.onRoundEnd);
     this.started = false;
   }
   clear() {