labag 2.5.1 → 2.6.0

package/dist/modes/greenwei.js

@@ -3,87 +3,93 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const pattern_1 = require("../pattern");
 const mode_1 = require("../mode");
 const randInt_1 = require("../utils/randInt");
-exports.default = new mode_1.Mode(false, "greenwei", {
-    gss: 0,
-    hhh: 0,
-    hentai: 0,
-    handson: 0,
-    kachu: 0,
-    rrr: 0,
-}, {
-    gameStart: (_, mode) => {
-        mode.active = false;
-        mode.variable.times = 0;
-        mode.variable.count = 0;
+exports.default = new mode_1.Mode({
+    active: false,
+    name: "greenwei",
+    rates: {
+        gss: 0,
+        hhh: 0,
+        hentai: 0,
+        handson: 0,
+        kachu: 0,
+        rrr: 0,
     },
-    roundStart: (_, mode) => {
-        if (!mode.active)
-            return;
-        mode.variable.times -= 1;
-    },
-    rollSlots: (_, mode) => {
-        mode.variable.randNum = (0, randInt_1.randInt)(1, 100);
-    },
-    calculateScore: (game, mode) => {
-        if (mode.active) {
-            game.marginScore = Math.round(game.marginScore * mode.variable.mutiplier);
-        }
-    },
-    roundEnd: (game, mode) => {
-        const { patterns } = game;
-        const { variable } = mode;
-        let gssCount = 0;
-        let allGSS = true;
-        for (const p of patterns) {
-            if (p?.name === mode.variable.bindPattern.name) {
-                gssCount++;
-            }
-            else {
-                allGSS = false;
-            }
-        }
-        variable.count += gssCount;
-        if (mode.active) {
-            if (allGSS) {
-                variable.times += mode.variable.extendTimes;
-            }
-            if (variable.times <= 0) {
-                mode.active = false;
+    eventListener: {
+        gameStart: (_, mode) => {
+            mode.active = false;
+            mode.variable.times = 0;
+            mode.variable.count = 0;
+        },
+        roundStart: (_, mode) => {
+            if (!mode.active)
+                return;
+            mode.variable.times -= 1;
+        },
+        rollSlots: (_, mode) => {
+            mode.variable.randNum = (0, randInt_1.randInt)(1, 100);
+        },
+        calculateScore: (game, mode) => {
+            if (mode.active) {
+                game.marginScore = Math.round(game.marginScore * mode.variable.mutiplier);
             }
-        }
-        if (!mode.active) {
-            let activated = false;
-            if (variable.randNum <= variable.rate && allGSS) {
-                activated = true;
-                variable.times += mode.variable.extendTimes;
+        },
+        roundEnd: (game, mode) => {
+            const { patterns } = game;
+            const { variable } = mode;
+            let gssCount = 0;
+            let allGSS = true;
+            for (const p of patterns) {
+                if (p?.name === mode.variable.bindPattern.name) {
+                    gssCount++;
+                }
+                else {
+                    allGSS = false;
+                }
             }
-            else if (variable.count >= mode.variable.requiredBindPatternCount) {
-                activated = true;
-                variable.times += mode.variable.bonusTimes;
-                variable.count -= mode.variable.requiredBindPatternCount;
+            variable.count += gssCount;
+            if (mode.active) {
+                if (allGSS) {
+                    variable.times += mode.variable.extendTimes;
+                }
+                if (variable.times <= 0) {
+                    mode.active = false;
+                }
             }
-            if (activated) {
-                mode.active = true;
-                for (let i = 0; i < patterns.length; i++) {
-                    if (patterns[i]?.name === mode.variable.bindPattern.name) {
-                        patterns[i] = variable.pattern;
+            if (!mode.active) {
+                let activated = false;
+                if (variable.randNum <= variable.rate && allGSS) {
+                    activated = true;
+                    variable.times += mode.variable.extendTimes;
+                }
+                else if (variable.count >= mode.variable.requiredBindPatternCount) {
+                    activated = true;
+                    variable.times += mode.variable.bonusTimes;
+                    variable.count -= mode.variable.requiredBindPatternCount;
+                }
+                if (activated) {
+                    mode.active = true;
+                    for (let i = 0; i < patterns.length; i++) {
+                        if (patterns[i]?.name === mode.variable.bindPattern.name) {
+                            patterns[i] = variable.pattern;
+                        }
                     }
                 }
             }
-        }
+        },
     },
-}, {
-    times: 0,
-    rate: 35,
-    randNum: 0,
-    count: 0,
-    pattern: {
-        name: "greenwei",
-        scores: [800, 400, 180],
+    variable: {
+        times: 0,
+        rate: 35,
+        randNum: 0,
+        count: 0,
+        pattern: {
+            name: "greenwei",
+            scores: [800, 400, 180],
+        },
+        extendTimes: 2,
+        bindPattern: pattern_1.patterns[0],
+        bonusTimes: 2,
+        requiredBindPatternCount: 20,
+        mutiplier: 3,
     },
-    extendTimes: 2,
-    bindPattern: pattern_1.patterns[0],
-    bonusTimes: 2,
-    requiredBindPatternCount: 20,
-    mutiplier: 3,
 });

package/dist/modes/index.d.ts

@@ -1,4 +1,4 @@
-export declare const modes: {
+export declare const _modes: {
     pikachu: import("..").Mode<{
         times: number;
         pattern: {
@@ -10,7 +10,7 @@ export declare const modes: {
             readonly scores: [12000, 8000, 1250];
         };
         bonusRounds: number;
-    }>;
+    }, "pikachu">;
     superhhh: import("..").Mode<{
         times: number;
         rate: number;
@@ -26,7 +26,7 @@ export declare const modes: {
             scores: number[];
         };
         extendTimes: number;
-    }>;
+    }, "superhhh">;
     greenwei: import("..").Mode<{
         times: number;
         rate: number;
@@ -44,11 +44,9 @@ export declare const modes: {
         bonusTimes: number;
         requiredBindPatternCount: number;
         mutiplier: number;
-    }>;
-    normal: import("..").Mode<Record<string, any>>;
+    }, "greenwei">;
 };
-export type ModeName = keyof typeof modes;
-export declare const modeList: (import("..").Mode<{
+export declare const modes: (import("..").Mode<{
     times: number;
     rate: number;
     randNum: number;
@@ -65,7 +63,7 @@ export declare const modeList: (import("..").Mode<{
     bonusTimes: number;
     requiredBindPatternCount: number;
     mutiplier: number;
-}> | import("..").Mode<Record<string, any>> | import("..").Mode<{
+}, "greenwei"> | import("..").Mode<{
     times: number;
     pattern: {
         name: string;
@@ -76,7 +74,7 @@ export declare const modeList: (import("..").Mode<{
         readonly scores: [12000, 8000, 1250];
     };
     bonusRounds: number;
-}> | import("..").Mode<{
+}, "pikachu"> | import("..").Mode<{
     times: number;
     rate: number;
     score: number;
@@ -91,4 +89,4 @@ export declare const modeList: (import("..").Mode<{
         scores: number[];
     };
     extendTimes: number;
-}>)[];
+}, "superhhh">)[];

package/dist/modes/index.js

@@ -3,15 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.modeList = exports.modes = void 0;
+exports.modes = exports._modes = void 0;
 const greenwei_1 = __importDefault(require("./greenwei"));
-const normal_1 = __importDefault(require("./normal"));
 const pikachu_1 = __importDefault(require("./pikachu"));
 const superhhh_1 = __importDefault(require("./superhhh"));
-exports.modes = {
-    pikachu: pikachu_1.default,
-    superhhh: superhhh_1.default,
-    greenwei: greenwei_1.default,
-    normal: normal_1.default,
-};
-exports.modeList = Object.values(exports.modes);
+exports._modes = { pikachu: pikachu_1.default, superhhh: superhhh_1.default, greenwei: greenwei_1.default };
+exports.modes = Object.values(exports._modes);

package/dist/modes/pikachu.d.ts

@@ -10,5 +10,5 @@ declare const _default: Mode<{
         readonly scores: [12000, 8000, 1250];
     };
     bonusRounds: number;
-}>;
+}, "pikachu">;
 export default _default;

package/dist/modes/pikachu.js

@@ -2,42 +2,48 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const pattern_1 = require("../pattern");
 const mode_1 = require("../mode");
-exports.default = new mode_1.Mode(false, "pikachu", {
-    gss: 0,
-    hhh: 0,
-    hentai: 0,
-    handson: 0,
-    kachu: 0,
-    rrr: 0,
-}, {
-    gameStart: (_, mode) => {
-        mode.active = false;
-        mode.variable.times = 0;
+exports.default = new mode_1.Mode({
+    active: false,
+    name: "pikachu",
+    rates: {
+        gss: 0,
+        hhh: 0,
+        hentai: 0,
+        handson: 0,
+        kachu: 0,
+        rrr: 0,
     },
-    roundEnd: (game, mode) => {
-        const { patterns } = game;
-        const hasBindPattern = patterns.some((p) => p && p.name === mode.variable.bindPattern.name);
-        if (!game.isRunning() && hasBindPattern) {
-            mode.active = true;
-            game.played -= mode.variable.bonusRounds;
-            mode.variable.times += 1;
-            patterns.forEach((p, i) => {
-                if (p?.name === mode.variable.bindPattern.name) {
-                    patterns[i] = mode.variable.pattern;
-                }
-            });
-            return;
-        }
-        if (mode.active && hasBindPattern) {
-            game.played -= Math.min(mode.variable.times, mode.variable.bonusRounds);
-        }
+    eventListener: {
+        gameStart: (_, mode) => {
+            mode.active = false;
+            mode.variable.times = 0;
+        },
+        roundEnd: (game, mode) => {
+            const { patterns } = game;
+            const hasBindPattern = patterns.some((p) => p && p.name === mode.variable.bindPattern.name);
+            if (!game.isRunning && hasBindPattern) {
+                mode.active = true;
+                game.played -= mode.variable.bonusRounds;
+                mode.variable.times += 1;
+                patterns.forEach((p, i) => {
+                    if (p?.name === mode.variable.bindPattern.name) {
+                        patterns[i] = mode.variable.pattern;
+                    }
+                });
+                return;
+            }
+            if (mode.active && hasBindPattern) {
+                game.played -= Math.min(mode.variable.times, mode.variable.bonusRounds);
+            }
+        },
     },
-}, {
-    times: 0,
-    pattern: {
-        name: "pikachu",
-        scores: [12000, 8000, 1250],
+    variable: {
+        times: 0,
+        pattern: {
+            name: "pikachu",
+            scores: [12000, 8000, 1250],
+        },
+        bindPattern: pattern_1.patterns[4],
+        bonusRounds: 3,
     },
-    bindPattern: pattern_1.patterns[4],
-    bonusRounds: 3,
 });

package/dist/modes/superhhh.d.ts

@@ -14,5 +14,5 @@ declare const _default: Mode<{
         scores: number[];
     };
     extendTimes: number;
-}>;
+}, "superhhh">;
 export default _default;

package/dist/modes/superhhh.js

@@ -3,78 +3,84 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const pattern_1 = require("../pattern");
 const mode_1 = require("../mode");
 const randInt_1 = require("../utils/randInt");
-exports.default = new mode_1.Mode(false, "superhhh", {
-    gss: -19, // 36 -> 17
-    hhh: -19, // 24 -> 5
-    hentai: 1, // 17 -> 18
-    handson: 7, // 12 -> 19
-    kachu: 12, // 8 -> 20
-    rrr: 18, // 3 -> 21
-}, {
-    gameStart: (_, mode) => {
-        mode.active = false;
-        mode.variable.times = 0;
-        mode.variable.score = 0;
+exports.default = new mode_1.Mode({
+    active: false,
+    name: "superhhh",
+    rates: {
+        gss: -19, // 36 -> 17
+        hhh: -19, // 24 -> 5
+        hentai: 1, // 17 -> 18
+        handson: 7, // 12 -> 19
+        kachu: 12, // 8 -> 20
+        rrr: 18, // 3 -> 21
     },
-    roundStart: (_, mode) => {
-        if (!mode.active)
-            return;
-        mode.variable.score = 0;
-        mode.variable.times -= 1;
-    },
-    rollSlots: (_, mode) => {
-        mode.variable.randNum = (0, randInt_1.randInt)(1, 100);
-    },
-    calculateScore: (game, mode) => {
-        if (mode.active)
-            return;
-        if (game.patterns.every((p) => p?.name === mode.variable.bindPattern.name) &&
-            mode.variable.randNum <= mode.variable.rate) {
-            mode.variable.score += Math.round(game.score / 2);
-            game.marginScore += mode.variable.score;
-        }
-    },
-    roundEnd: (game, mode) => {
-        const { patterns } = game;
-        const { variable } = mode;
-        let hhhCount = 0;
-        let allHHH = true;
-        for (const p of patterns) {
-            if (p?.name === mode.variable.bindPattern.name)
-                hhhCount++;
-            else
-                allHHH = false;
-        }
-        if (mode.active) {
-            if (allHHH) {
-                variable.times += mode.variable.extendTimes;
+    eventListener: {
+        gameStart: (_, mode) => {
+            mode.active = false;
+            mode.variable.times = 0;
+            mode.variable.score = 0;
+        },
+        roundStart: (_, mode) => {
+            if (!mode.active)
+                return;
+            mode.variable.score = 0;
+            mode.variable.times -= 1;
+        },
+        rollSlots: (_, mode) => {
+            mode.variable.randNum = (0, randInt_1.randInt)(1, 100);
+        },
+        calculateScore: (game, mode) => {
+            if (mode.active)
+                return;
+            if (game.patterns.every((p) => p?.name === mode.variable.bindPattern.name) &&
+                mode.variable.randNum <= mode.variable.rate) {
+                mode.variable.score += Math.round(game.score / 2);
+                game.marginScore += mode.variable.score;
             }
-            if (variable.times <= 0) {
-                mode.active = false;
+        },
+        roundEnd: (game, mode) => {
+            const { patterns } = game;
+            const { variable } = mode;
+            let hhhCount = 0;
+            let allHHH = true;
+            for (const p of patterns) {
+                if (p?.name === mode.variable.bindPattern.name)
+                    hhhCount++;
+                else
+                    allHHH = false;
+            }
+            if (mode.active) {
+                if (allHHH) {
+                    variable.times += mode.variable.extendTimes;
+                }
+                if (variable.times <= 0) {
+                    mode.active = false;
+                }
             }
-        }
-        if (!mode.active) {
-            if (variable.randNum <= variable.rate && hhhCount > 0) {
-                mode.active = true;
-                variable.times += variable.bonusTimes;
-                for (let i = 0; i < patterns.length; i++) {
-                    if (patterns[i]?.name === mode.variable.bindPattern.name) {
-                        patterns[i] = variable.pattern;
+            if (!mode.active) {
+                if (variable.randNum <= variable.rate && hhhCount > 0) {
+                    mode.active = true;
+                    variable.times += variable.bonusTimes;
+                    for (let i = 0; i < patterns.length; i++) {
+                        if (patterns[i]?.name === mode.variable.bindPattern.name) {
+                            patterns[i] = variable.pattern;
+                        }
                     }
                 }
             }
-        }
+        },
     },
-}, {
-    times: 0,
-    rate: 15,
-    score: 0,
-    randNum: 0,
-    bindPattern: pattern_1.patterns[1],
-    bonusTimes: 6,
-    pattern: {
-        name: "superhhh",
-        scores: [1500, 800, 300],
+    variable: {
+        times: 0,
+        rate: 15,
+        score: 0,
+        randNum: 0,
+        bindPattern: pattern_1.patterns[1],
+        bonusTimes: 6,
+        pattern: {
+            name: "superhhh",
+            scores: [1500, 800, 300],
+        },
+        extendTimes: 2,
     },
-    extendTimes: 2,
 });

package/dist/recordChecker.js

@@ -25,12 +25,14 @@ class RecordChecker {
         this.game.init();
         this.game.times = record.times;
         for (const round of record.rounds) {
-            if (!this.game.isRunning()) {
-                throw new Error("遊戲次數已達上限，無法繼續遊玩。");
+            if (!this.game.isRunning) {
+                break;
             }
             // 1. 回合開始
-            this.game["roundStart"]();
-            // 2. 設定隨機數字與圖案 (模擬 rollSlots)
+            this.game.roundStart();
+            // 2. 觸發 rollSlots 事件，這會執行所有模式的隨機邏輯
+            this.game.rollSlots();
+            // 3. 覆蓋隨機數字與圖案 (確保使用紀錄中的數值)
             const { ranges } = this.game.getCurrentConfig();
             for (let i = 0; i < 3; i++) {
                 const num = round.randNums?.[i.toString()] ?? 0;
@@ -38,22 +40,20 @@ class RecordChecker {
                 const match = ranges.find((r) => num <= r.threshold);
                 this.game.patterns[i] = match ? match.pattern : null;
             }
-            // 觸發 rollSlots 事件，讓模式執行其邏輯 (例如 greenwei 產生隨機數)
-            this.game["emit"]("rollSlots");
-            // 3. 覆蓋模式的隨機變數 (確保使用紀錄中的數值)
+            // 4. 覆蓋模式的隨機變數 (確保使用紀錄中的數值)
             this.game.modes.forEach((mode) => {
                 const recordedNum = round.randNums?.[mode.name];
                 if (recordedNum !== undefined && mode.variable) {
                     mode.variable.randNum = recordedNum;
                 }
             });
-            // 4. 計算分數
-            this.game["calculateScore"]();
-            // 5. 回合結束
-            this.game["roundEnd"]();
+            // 5. 計算分數
+            this.game.calculateScore();
+            // 6. 回合結束
+            this.game.roundEnd();
         }
-        if (!this.game.isRunning()) {
-            this.game["gameOver"]();
+        if (!this.game.isRunning) {
+            this.game.gameOver();
         }
         return this.game.score;
     }

package/dist/test.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("./index");
+const index_2 = require("./index");
 index_1.labag.addEventListener("gameStart", (game) => {
     console.log("Game Started!");
     console.log(`Total Rounds: ${game.times}\n`);
@@ -21,7 +22,8 @@ index_1.labag.addEventListener("roundEnd", (game) => {
     console.log(`Score: ${game.score}\n`);
 });
 index_1.labag.init();
-while (index_1.labag.isRunning()) {
+index_2.recorder.init();
+while (index_1.labag.isRunning) {
     index_1.labag.play();
 }
 console.log("Game Over");
@@ -30,3 +32,7 @@ console.log(`Active Modes at end: ${index_1.labag
     .getCurrentConfig()
     .modes.map((m) => m.name)
     .join(", ")}`);
+console.log(`record: ${JSON.stringify(index_2.recorder.getRecord(), null, 2)}`);
+console.log(index_1.checker.check(index_2.recorder.getRecord())
+    ? "Record is valid!"
+    : "Record is invalid!");

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+import { modes } from "src/modes";
 import { patterns } from "src/pattern";
 /**
  * 拉霸遊戲的事件類型。
@@ -16,3 +17,4 @@ export type Pattern = {
  * 圖案名稱的型別。
  */
 export type PatternName = (typeof patterns)[number]["name"];
+export type ModeName = (typeof modes)[number]["name"] | "normal";

package/package.json

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

package/src/index.ts

@@ -1,13 +1,14 @@
 import { LaBaG } from "./labag";
-import { modeList, ModeName } from "./modes";
+import { modes } from "./modes";
 import { LaBaGEvent, Pattern, PatternName } from "./types";
 import { Mode } from "./mode";
 import { patterns } from "./pattern";
-import { Recorder, GameRecord } from './recorder';
+import { Recorder, GameRecord } from "./recorder";
 import { RecordChecker } from "./recordChecker";
+import { ModeName } from "./types/index";
 
 const labag = new LaBaG();
-modeList.forEach((mode) => {
+modes.forEach((mode) => {
   labag.addMode(mode);
 });
 const recorder = new Recorder(labag);
@@ -16,7 +17,7 @@ export {
   labag,
   recorder,
   checker,
-  modeList,
+  modes,
   patterns,
   LaBaG,
   Recorder,
@@ -25,6 +26,6 @@ export {
   type LaBaGEvent,
   type Pattern,
   type PatternName,
+  type GameRecord,
   type ModeName,
-  type GameRecord
 };