labag 2.3.3 → 2.3.4

package/dist/index.d.ts

@@ -2,5 +2,10 @@ import { LaBaG } from "./labag";
 import { modeList, ModeName } from "./modes";
 import { LaBaGEvent, Pattern, PatternName } from "./types";
 import { Mode } from "./mode";
+import { patterns } from "./pattern";
+import { Recorder, GameRecord } from './recorder';
+import { RecordChecker } from "./recordChecker";
 declare const labag: LaBaG;
-export { labag, modeList, LaBaG, Mode, type LaBaGEvent, type Pattern, type PatternName, type ModeName, };
+declare const recorder: Recorder;
+declare const checker: RecordChecker;
+export { labag, recorder, checker, modeList, patterns, LaBaG, Mode, type LaBaGEvent, type Pattern, type PatternName, type ModeName, type GameRecord };

package/dist/index.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mode = exports.LaBaG = exports.modeList = exports.labag = void 0;
+exports.Mode = exports.LaBaG = exports.patterns = exports.modeList = exports.checker = exports.recorder = exports.labag = void 0;
 const labag_1 = require("./labag");
 Object.defineProperty(exports, "LaBaG", { enumerable: true, get: function () { return labag_1.LaBaG; } });
 const modes_1 = require("./modes");
 Object.defineProperty(exports, "modeList", { enumerable: true, get: function () { return modes_1.modeList; } });
 const mode_1 = require("./mode");
 Object.defineProperty(exports, "Mode", { enumerable: true, get: function () { return mode_1.Mode; } });
+const pattern_1 = require("./pattern");
+Object.defineProperty(exports, "patterns", { enumerable: true, get: function () { return pattern_1.patterns; } });
+const recorder_1 = require("./recorder");
+const recordChecker_1 = require("./recordChecker");
 const labag = new labag_1.LaBaG();
 exports.labag = labag;
 modes_1.modeList.forEach((mode) => {
     labag.addMode(mode);
 });
+const recorder = new recorder_1.Recorder(labag);
+exports.recorder = recorder;
+const checker = new recordChecker_1.RecordChecker(labag);
+exports.checker = checker;

package/dist/recordChecker.d.ts

@@ -0,0 +1,18 @@
+import { LaBaG } from "./labag";
+import { GameRecord } from "./recorder";
+export declare class RecordChecker {
+    private game;
+    constructor(game: LaBaG);
+    /**
+     * 驗證紀錄的分數是否正確。
+     * @param record - 要驗證的遊戲紀錄。
+     * @returns 如果計算出的分數與紀錄中的分數一致則返回 true，否則返回 false。
+     */
+    check(record: GameRecord): boolean;
+    /**
+     * 根據紀錄還原並計算分數。
+     * @param record - 遊戲紀錄。
+     * @returns 計算出的分數。
+     */
+    calculateScore(record: GameRecord): number;
+}

package/dist/recordChecker.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordChecker = void 0;
+class RecordChecker {
+    game;
+    constructor(game) {
+        this.game = game;
+    }
+    /**
+     * 驗證紀錄的分數是否正確。
+     * @param record - 要驗證的遊戲紀錄。
+     * @returns 如果計算出的分數與紀錄中的分數一致則返回 true，否則返回 false。
+     */
+    check(record) {
+        const calculatedScore = this.calculateScore(record);
+        return calculatedScore === record.score;
+    }
+    /**
+     * 根據紀錄還原並計算分數。
+     * @param record - 遊戲紀錄。
+     * @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();
+            // 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) => {
+                const match = ranges.find((r) => num <= r.threshold);
+                if (match) {
+                    this.game.patterns[index] = match.pattern;
+                }
+                else {
+                    this.game.patterns[index] = null;
+                }
+            });
+            // 觸發 rollSlots 事件，讓模式執行其邏輯 (例如 greenwei 產生隨機數)
+            gameAny.emit("rollSlots");
+            // 3. 覆蓋模式的隨機變數 (確保使用紀錄中的數值)
+            this.game.modes.forEach((mode) => {
+                if (round.randNums[mode.name] !== undefined) {
+                    mode.variable.randNum = round.randNums[mode.name];
+                }
+            });
+            // 4. 計算分數
+            gameAny.calculateScore();
+            // 5. 回合結束
+            gameAny.roundEnd();
+        }
+        if (!this.game.isRunning()) {
+            gameAny.gameOver();
+        }
+        return this.game.score;
+    }
+}
+exports.RecordChecker = RecordChecker;

package/dist/recorder.d.ts

@@ -0,0 +1,29 @@
+import { LaBaG } from "./labag";
+export type RoundRecord = {
+    randNums: Record<string, number>;
+};
+export type GameRecord = {
+    times: number;
+    score: number;
+    rounds: RoundRecord[];
+};
+export type RecorderOptions = {
+    debug?: boolean;
+};
+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>;
+    }[];
+    private onRoundEnd;
+    init(clearExisting?: boolean): void;
+    dispose(): void;
+    clear(): void;
+    getRecord(): GameRecord;
+}

package/dist/recorder.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Recorder = void 0;
+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;
+    }
+    get rounds() {
+        return this.#rounds.map((r) => ({ ...r }));
+    }
+    onRoundEnd(g) {
+        const randNums = {};
+        g.randNums.forEach((value, key) => {
+            if (!isNaN(value)) {
+                randNums[key] = value;
+            }
+        });
+        // 收集各模式的 randNum（若為數值且有效）
+        g.modes.forEach((mode) => {
+            const rn = mode?.variable?.randNum;
+            if (!isNaN(rn)) {
+                randNums[mode.name] = rn;
+            }
+        });
+        const round = {
+            randNums,
+        };
+        if (this.debug)
+            console.debug("recorder:onRoundEnd", {
+                round,
+                score: g.score,
+            });
+        this.#rounds.push(round);
+        this.score = g.score;
+    }
+    init(clearExisting = true) {
+        if (this.started)
+            return;
+        if (clearExisting) {
+            this.clear();
+        }
+        if (typeof this.game.addEventListener === "function") {
+            this.game.addEventListener("roundEnd", this.onRoundEndBound);
+            this.started = true;
+        }
+    }
+    dispose() {
+        if (!this.started)
+            return;
+        this.game.removeEventListener("roundEnd", this.onRoundEndBound);
+        this.started = false;
+    }
+    clear() {
+        if (this.debug)
+            console.debug("clear");
+        this.score = 0;
+        this.#rounds = [];
+    }
+    getRecord() {
+        if (this.debug)
+            console.debug("get");
+        return {
+            times: this.game.times,
+            score: this.score,
+            rounds: this.#rounds,
+        };
+    }
+}
+exports.Recorder = Recorder;

package/package.json

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

package/src/index.ts

@@ -2,18 +2,27 @@ import { LaBaG } from "./labag";
 import { modeList, ModeName } from "./modes";
 import { LaBaGEvent, Pattern, PatternName } from "./types";
 import { Mode } from "./mode";
+import { patterns } from "./pattern";
+import { Recorder, GameRecord } from './recorder';
+import { RecordChecker } from "./recordChecker";
 
 const labag = new LaBaG();
 modeList.forEach((mode) => {
   labag.addMode(mode);
 });
+const recorder = new Recorder(labag);
+const checker = new RecordChecker(labag);
 export {
   labag,
+  recorder,
+  checker,
   modeList,
+  patterns,
   LaBaG,
   Mode,
   type LaBaGEvent,
   type Pattern,
   type PatternName,
   type ModeName,
+  type GameRecord
 };

package/src/recordChecker.ts

@@ -0,0 +1,84 @@
+import { LaBaG } from "./labag";
+import { GameRecord } from "./recorder";
+
+export class RecordChecker {
+  private game: LaBaG;
+
+  constructor(game: LaBaG) {
+    this.game = game;
+  }
+
+  /**
+   * 驗證紀錄的分數是否正確。
+   * @param record - 要驗證的遊戲紀錄。
+   * @returns 如果計算出的分數與紀錄中的分數一致則返回 true，否則返回 false。
+   */
+  check(record: GameRecord): boolean {
+    const calculatedScore = this.calculateScore(record);
+    return calculatedScore === record.score;
+  }
+
+  /**
+   * 根據紀錄還原並計算分數。
+   * @param record - 遊戲紀錄。
+   * @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();
+
+      // 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) => {
+        const match = ranges.find((r) => num <= r.threshold);
+        if (match) {
+          this.game.patterns[index] = match.pattern;
+        } else {
+          this.game.patterns[index] = null;
+        }
+      });
+
+      // 觸發 rollSlots 事件，讓模式執行其邏輯 (例如 greenwei 產生隨機數)
+      gameAny.emit("rollSlots");
+
+      // 3. 覆蓋模式的隨機變數 (確保使用紀錄中的數值)
+      this.game.modes.forEach((mode) => {
+        if (round.randNums[mode.name] !== undefined) {
+          mode.variable.randNum = round.randNums[mode.name];
+        }
+      });
+
+      // 4. 計算分數
+      gameAny.calculateScore();
+
+      // 5. 回合結束
+      gameAny.roundEnd();
+    }
+
+    if (!this.game.isRunning()) {
+      gameAny.gameOver();
+    }
+
+    return this.game.score;
+  }
+}
+

package/src/recorder.ts

@@ -0,0 +1,95 @@
+import { LaBaG } from "./labag";
+
+export type RoundRecord = {
+  randNums: Record<string, number>;
+};
+
+export type GameRecord = {
+  times: number;
+  score: number;
+  rounds: RoundRecord[];
+};
+
+export type RecorderOptions = {
+  debug?: boolean; // 若為 true，會以 console.debug 輸出紀錄
+};
+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;
+  }
+
+  get rounds() {
+    return this.#rounds.map((r) => ({ ...r }));
+  }
+
+  private onRoundEnd(g: LaBaG) {
+    const randNums: Record<string, number> = {};
+
+    g.randNums.forEach((value, key) => {
+      if (!isNaN(value)) {
+        randNums[key] = value;
+      }
+    });
+
+    // 收集各模式的 randNum（若為數值且有效）
+    g.modes.forEach((mode) => {
+      const rn = mode?.variable?.randNum;
+      if (!isNaN(rn)) {
+        randNums[mode.name] = rn;
+      }
+    });
+
+    const round: RoundRecord = {
+      randNums,
+    };
+
+    if (this.debug)
+      console.debug("recorder:onRoundEnd", {
+        round,
+        score: g.score,
+      });
+
+    this.#rounds.push(round);
+    this.score = g.score;
+  }
+
+  init(clearExisting = true) {
+    if (this.started) return;
+    if (clearExisting) {
+      this.clear();
+    }
+    if (typeof this.game.addEventListener === "function") {
+      this.game.addEventListener("roundEnd", this.onRoundEndBound);
+      this.started = true;
+    }
+  }
+
+  dispose() {
+    if (!this.started) return;
+    this.game.removeEventListener("roundEnd", this.onRoundEndBound);
+    this.started = false;
+  }
+  clear() {
+    if (this.debug) console.debug("clear");
+    this.score = 0;
+    this.#rounds = [];
+  }
+
+  getRecord(): GameRecord {
+    if (this.debug) console.debug("get");
+    return {
+      times: this.game.times,
+      score: this.score,
+      rounds: this.#rounds,
+    };
+  }
+}