labag 1.2.2 → 2.0.0

package/dist/index.d.ts

@@ -1,9 +1,3 @@
-import { LaBaG, OneDataType, AllDataType } from "./types/LaBaG";
-import { Mode, ModeNames } from "./types/Mode";
-import { PlayLaBaG } from "./types/PlayLaBaG";
-import { JsonLaBaG } from "./types/JsonLaBaG";
-import { P, PData } from "./types/P";
-import { parseScore, verifyScore } from './utils/data';
-declare const PDatas: Record<string, PData>;
-declare const Modes: Record<Exclude<ModeNames, "Normal">, Mode>;
-export { OneDataType, AllDataType, LaBaG, PlayLaBaG, JsonLaBaG, Modes, ModeNames, P, PData, PDatas, parseScore, verifyScore, };
+import { LaBaG } from "./labag";
+declare const labag: LaBaG;
+export default labag;

package/dist/index.js

@@ -1,178 +1,208 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyScore = exports.parseScore = exports.PDatas = exports.P = exports.Modes = exports.JsonLaBaG = exports.PlayLaBaG = void 0;
-const RandInt_1 = require("./utils/RandInt");
-const PlayLaBaG_1 = require("./types/PlayLaBaG");
-Object.defineProperty(exports, "PlayLaBaG", { enumerable: true, get: function () { return PlayLaBaG_1.PlayLaBaG; } });
-const JsonLaBaG_1 = require("./types/JsonLaBaG");
-Object.defineProperty(exports, "JsonLaBaG", { enumerable: true, get: function () { return JsonLaBaG_1.JsonLaBaG; } });
-const P_1 = require("./types/P");
-Object.defineProperty(exports, "P", { enumerable: true, get: function () { return P_1.P; } });
-const data_1 = require("./utils/data");
-Object.defineProperty(exports, "parseScore", { enumerable: true, get: function () { return data_1.parseScore; } });
-Object.defineProperty(exports, "verifyScore", { enumerable: true, get: function () { return data_1.verifyScore; } });
-const PDatas = {
-    Gss: {
-        name: "咖波",
-        code: "A",
-        rates: { Normal: 36, SuperHHH: 19, GreenWei: 36, PiKaChu: 36 },
-        scores: [800, 400, 180],
-    },
-    Hhh: {
-        name: "阿禾",
-        code: "B",
-        rates: { Normal: 24, SuperHHH: 5, GreenWei: 24, PiKaChu: 24 },
-        scores: [1500, 800, 300],
-    },
-    Hentai: {
-        name: "猥褻男",
-        code: "C",
-        rates: { Normal: 17, SuperHHH: 19, GreenWei: 17, PiKaChu: 17 },
-        scores: [2500, 1200, 500],
-    },
-    Handsun: {
-        name: "文傑",
-        code: "D",
-        rates: { Normal: 12, SuperHHH: 19, GreenWei: 12, PiKaChu: 12 },
-        scores: [2900, 1450, 690],
-    },
-    Kachu: {
-        name: "皮卡丘",
-        code: "E",
-        rates: { Normal: 8, SuperHHH: 19, GreenWei: 8, PiKaChu: 8 },
-        scores: [12000, 8000, 1250],
-    },
-    Rrr: {
-        name: "館長",
-        code: "F",
-        rates: { Normal: 3, SuperHHH: 19, GreenWei: 3, PiKaChu: 3 },
-        scores: [20000, 12000, 2500],
-    },
-};
-exports.PDatas = PDatas;
-Object.values(PDatas).forEach((pd) => {
-    new P_1.P(pd.name, pd.code, pd.scores, pd.rates);
-});
-const Modes = {
-    // 超級阿禾
-    SuperHHH: {
-        InMode: false,
-        Rate: 15,
-        Times: 0,
-        Score: 0,
-        RandNum: 0,
-        Random() {
-            this.RandNum = (0, RandInt_1.RandInt)(1, 100);
+const labag_1 = require("./labag");
+const mode_1 = require("./mode");
+const randInt_1 = require("./utils/randInt");
+const labag = new labag_1.LaBaG();
+const modes = [
+    [
+        false,
+        "superhhh",
+        {
+            gss: 19,
+            hhh: 5,
+            hentai: 19,
+            handson: 19,
+            kachu: 19,
+            rrr: 19,
         },
-        Judge(Game) {
-            if (!Game.GameRunning() ||
-                this.RandNum === undefined ||
-                this.Times === undefined ||
-                this.Rate === undefined ||
-                this.Score === undefined) {
-                return;
-            }
-            this.Score = 0; // Reset score
-            if (this.InMode) {
-                this.Times -= 1;
-                if (Game.Ps.every((p) => p?.code === "B")) {
-                    this.Times += 2;
-                }
-                if (this.Times <= 0) {
-                    this.InMode = false;
-                    Game.JudgeMode();
-                    Game.ModeToScreen = true;
+        {
+            gameStart: (_, mode) => {
+                mode.active = false;
+                mode.variable.times = 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);
+            },
+            roundEnd: (game, mode) => {
+                const { patterns } = game;
+                const { variable } = mode;
+                let hhhCount = 0;
+                let allHHH = true;
+                for (const p of patterns) {
+                    if (p?.name === "hhh")
+                        hhhCount++;
+                    else
+                        allHHH = false;
                 }
-            }
-            else {
-                if (this.RandNum <= this.Rate && Game.Ps.some((p) => p?.code === "B")) {
-                    this.InMode = true;
-                    this.Times += 6;
-                    Game.ModeToScreen = true;
-                    if (Modes.PiKaChu.InMode) {
-                        Modes.PiKaChu.InMode = false;
+                if (mode.active) {
+                    if (allHHH) {
+                        variable.times += 2;
+                    }
+                    if (variable.times <= 0) {
+                        mode.active = false;
                     }
-                    // 超級阿禾加倍
-                    if (Game.Ps.every((p) => p?.code === "B")) {
-                        this.Score = Math.round((Game.Score * Game.ScoreTime) / 2);
-                        Game.Score += this.Score;
+                }
+                else {
+                    if (variable.randNum <= variable.rate && hhhCount > 0) {
+                        mode.active = true;
+                        variable.times += 6;
+                        for (let i = 0; i < patterns.length; i++) {
+                            if (patterns[i]?.name === "hhh") {
+                                patterns[i] = variable.pattern;
+                            }
+                        }
                     }
                 }
-            }
+            },
         },
-    },
-    GreenWei: {
-        InMode: false,
-        Rate: 35,
-        Times: 0,
-        Score: 0, // 咖波累積數
-        RandNum: 0,
-        Random() {
-            this.RandNum = (0, RandInt_1.RandInt)(1, 100);
+        {
+            times: 0,
+            rate: 15,
+            score: 0,
+            randNum: 0,
+            pattern: {
+                name: "superhhh",
+                scores: [1500, 800, 300],
+            },
         },
-        Judge(Game) {
-            if (!Game.GameRunning() ||
-                this.RandNum === undefined ||
-                this.Times === undefined ||
-                this.Rate === undefined ||
-                this.Score === undefined) {
-                return;
-            }
-            if (this.InMode) {
-                this.Times -= 1;
-                if (Game.Ps.every((p) => p?.code === "A")) {
-                    this.Times += 1;
+    ],
+    [
+        false,
+        "greenwei",
+        {
+            gss: 36,
+            hhh: 24,
+            hentai: 17,
+            handson: 12,
+            kachu: 8,
+            rrr: 3,
+        },
+        {
+            gameStart: (_, mode) => {
+                mode.active = false;
+                mode.variable.times = 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 * 3);
                 }
-                if (this.Times <= 0) {
-                    this.InMode = false;
-                    Game.JudgeMode();
-                    Game.ModeToScreen = true;
+            },
+            roundEnd: (game, mode) => {
+                const { patterns } = game;
+                const { variable } = mode;
+                let gssCount = 0;
+                let allGSS = true;
+                for (const p of patterns) {
+                    if (p?.name === "gss")
+                        gssCount++;
+                    else
+                        allGSS = false;
                 }
-            }
-            else {
-                if (this.RandNum <= this.Rate &&
-                    Game.Ps.every((p) => p?.code === "A")) {
-                    this.InMode = true;
-                    this.Times += 2;
-                    Game.ModeToScreen = true;
-                    if (Modes.PiKaChu.InMode) {
-                        Modes.PiKaChu.InMode = false;
+                variable.count += gssCount;
+                if (mode.active) {
+                    if (allGSS) {
+                        variable.times += 1;
+                    }
+                    if (variable.times <= 0) {
+                        mode.active = false;
                     }
-                    return;
                 }
-                else if (this.Score >= 20) {
-                    // 咖波累積數達到 20
-                    this.InMode = true;
-                    this.Times += 2;
-                    this.Score = 0;
-                    Game.ModeToScreen = true;
-                    if (Modes.PiKaChu.InMode) {
-                        Modes.PiKaChu.InMode = false;
+                else {
+                    let activated = false;
+                    if (variable.randNum <= variable.rate && allGSS) {
+                        activated = true;
+                        variable.times += 2;
+                    }
+                    else if (variable.count >= 20) {
+                        activated = true;
+                        variable.times += 2;
+                        variable.count -= 20;
+                    }
+                    if (activated) {
+                        mode.active = true;
+                        for (let i = 0; i < patterns.length; i++) {
+                            if (patterns[i]?.name === "gss") {
+                                patterns[i] = variable.pattern;
+                            }
+                        }
                     }
-                    return;
                 }
-            }
+            },
         },
-    },
-    PiKaChu: {
-        InMode: false,
-        Times: 0,
-        Judge(Game) {
-            if (!Game.GameRunning() && this.Times !== undefined) {
-                // 關掉其他模式
-                Modes.SuperHHH.InMode = false;
-                Modes.GreenWei.InMode = false;
-                if (Game.Ps.some((p) => p?.code === "E")) {
-                    this.InMode = true;
-                    Game.Played -= 5;
-                    this.Times += 1;
-                    Game.ModeToScreen = true;
-                }
-                else {
-                    this.InMode = false;
+        {
+            times: 0,
+            rate: 35,
+            randNum: 0,
+            count: 0,
+            pattern: {
+                name: "greenwei",
+                scores: [800, 400, 180],
+            },
+        },
+    ],
+    [
+        false,
+        "pikachu",
+        {
+            gss: 36,
+            hhh: 24,
+            hentai: 17,
+            handson: 12,
+            kachu: 8,
+            rrr: 3,
+        },
+        {
+            gameStart: (_, mode) => {
+                mode.active = false;
+                mode.variable.times = 0;
+            },
+            roundEnd: (game, mode) => {
+                if (!game.isRunning() &&
+                    game.patterns.some((p) => p && p.name === "kachu")) {
+                    mode.active = true;
+                    game.played -= 5;
+                    mode.variable.times += 1;
                 }
-            }
+            },
+        },
+        {
+            times: 0,
+            pattern: {
+                name: "pikachu",
+                scores: [12000, 8000, 1250],
+            },
+        },
+    ],
+    [
+        true,
+        "normal",
+        {
+            gss: 36,
+            hhh: 24,
+            hentai: 17,
+            handson: 12,
+            kachu: 8,
+            rrr: 3,
         },
-    },
-};
-exports.Modes = Modes;
+    ],
+];
+for (const modeArgs of modes) {
+    const mode = new mode_1.Mode(...modeArgs);
+    labag.addMode(mode);
+}
+exports.default = labag;

package/dist/labag.d.ts

@@ -0,0 +1,78 @@
+import { Mode } from "./mode";
+import { Pattern, LaBaGEvent } from "./types";
+/**
+ * 拉霸遊戲的主要類別。
+ */
+export declare class LaBaG {
+    /** 總遊玩次數限制 */
+    times: number;
+    /** 已遊玩次數 */
+    played: number;
+    /** 當前進行的輪次 */
+    rounds: number;
+    /** 當前分數 */
+    score: number;
+    /** 邊際分數 */
+    marginScore: number;
+    /** 當前轉出的圖案組合 */
+    patterns: [Pattern | null, Pattern | null, Pattern | null];
+    /** 遊戲模式列表 */
+    modes: Mode[];
+    /** 事件監聽器列表 */
+    eventListeners: Record<LaBaGEvent, ((game: LaBaG) => void)[]>;
+    /**
+     * 初始化拉霸遊戲。
+     * @param times - 總遊玩次數，預設為 30。
+     */
+    constructor(times?: number);
+    /**
+     * 觸發指定事件。
+     * @param event - 要觸發的事件名稱。
+     */
+    private emit;
+    /**
+     * 新增事件監聽器。
+     * @param event - 事件名稱。
+     * @param listener - 監聽器函式。
+     */
+    addEventListener(event: LaBaGEvent, callbackFn: (game: LaBaG) => void): void;
+    /**
+     * 新增遊戲模式。
+     * @param mode - 要新增的模式。
+     */
+    addMode(mode: Mode): void;
+    /**
+     * 檢查遊戲是否正在進行中（未達次數上限）。
+     * @returns 如果遊戲仍在進行中則返回 true，否則返回 false。
+     */
+    isRunning(): boolean;
+    /**
+     * 取得目前遊戲的相關設定
+     */
+    getCurrentConfig(): {
+        modes: Mode[];
+        ranges: {
+            threshold: number;
+            pattern: Pattern;
+        }[];
+    };
+    /**
+     * 初始化遊戲狀態。
+     */
+    init(): void;
+    /**
+     * 新的一小輪開始。
+     */
+    private roundStart;
+    /**
+     * 轉動拉霸機，產生隨機圖案。
+     */
+    private rollSlots;
+    /**
+     * 計算分數。
+     */
+    private calculateScore;
+    private roundEnd;
+    private gameOver;
+    play(): void;
+}

package/dist/labag.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LaBaG = void 0;
+const pattern_1 = require("./pattern");
+const randInt_1 = require("./utils/randInt");
+/**
+ * 拉霸遊戲的主要類別。
+ */
+class LaBaG {
+    /** 總遊玩次數限制 */
+    times;
+    /** 已遊玩次數 */
+    played;
+    /** 當前進行的輪次 */
+    rounds;
+    /** 當前分數 */
+    score;
+    /** 邊際分數 */
+    marginScore;
+    /** 當前轉出的圖案組合 */
+    patterns;
+    /** 遊戲模式列表 */
+    modes;
+    /** 事件監聽器列表 */
+    eventListeners;
+    /**
+     * 初始化拉霸遊戲。
+     * @param times - 總遊玩次數，預設為 30。
+     */
+    constructor(times = 30) {
+        this.times = times;
+        this.played = 0;
+        this.rounds = 0;
+        this.score = 0;
+        this.marginScore = 0;
+        this.patterns = [null, null, null];
+        this.modes = [];
+        this.eventListeners = {
+            gameOver: [],
+            gameStart: [],
+            roundStart: [],
+            roundEnd: [],
+            rollSlots: [],
+            calculateScore: [],
+        };
+    }
+    /**
+     * 觸發指定事件。
+     * @param event - 要觸發的事件名稱。
+     */
+    emit(event) {
+        this.eventListeners[event].forEach((fn) => fn(this));
+    }
+    /**
+     * 新增事件監聽器。
+     * @param event - 事件名稱。
+     * @param listener - 監聽器函式。
+     */
+    addEventListener(event, callbackFn) {
+        this.eventListeners[event].push(callbackFn);
+    }
+    /**
+     * 新增遊戲模式。
+     * @param mode - 要新增的模式。
+     */
+    addMode(mode) {
+        this.modes.push(mode);
+        // 註冊特定模式的監聽器
+        Object.entries(mode.eventListener).forEach(([event, listener]) => {
+            if (listener) {
+                this.addEventListener(event, (game) => listener(game, mode));
+            }
+        });
+    }
+    /**
+     * 檢查遊戲是否正在進行中（未達次數上限）。
+     * @returns 如果遊戲仍在進行中則返回 true，否則返回 false。
+     */
+    isRunning() {
+        return this.played < this.times;
+    }
+    /**
+     * 取得目前遊戲的相關設定
+     */
+    getCurrentConfig() {
+        const activeModes = this.modes.filter((m) => m.active);
+        if (activeModes.length === 0) {
+            console.warn("目前沒有啟用中的模式，無法轉動拉霸機。");
+            return { modes: activeModes, ranges: [] };
+        }
+        // 合併所有啟用中模式的機率設定
+        const combinedRates = {
+            gss: 0,
+            hhh: 0,
+            hentai: 0,
+            handson: 0,
+            kachu: 0,
+            rrr: 0,
+        };
+        activeModes.forEach((mode) => {
+            Object.entries(mode.rates).forEach(([patternName, rate]) => {
+                combinedRates[patternName] += rate;
+            });
+        });
+        // 預先計算合併後的區間
+        const ranges = [];
+        let acc = 0;
+        for (const pattern of pattern_1.patterns) {
+            const rate = combinedRates[pattern.name];
+            if (rate !== undefined) {
+                acc += rate;
+                ranges.push({ threshold: acc, pattern });
+            }
+        }
+        return { modes: activeModes, ranges };
+    }
+    /**
+     * 初始化遊戲狀態。
+     */
+    init() {
+        this.played = 0;
+        this.score = 0;
+        this.marginScore = 0;
+        this.patterns = [null, null, null];
+        this.rounds = 0;
+        this.emit("gameStart");
+    }
+    /**
+     * 新的一小輪開始。
+     */
+    roundStart() {
+        this.played += 1;
+        this.rounds += 1;
+        this.marginScore = 0;
+        this.emit("roundStart");
+    }
+    /**
+     * 轉動拉霸機，產生隨機圖案。
+     */
+    rollSlots() {
+        const { ranges } = this.getCurrentConfig();
+        const rangesAcc = ranges.length > 0 ? ranges[ranges.length - 1].threshold : 0;
+        // 產生 3 個隨機數字
+        const randomNums = [
+            (0, randInt_1.randInt)(1, rangesAcc),
+            (0, randInt_1.randInt)(1, rangesAcc),
+            (0, randInt_1.randInt)(1, rangesAcc),
+        ];
+        randomNums.forEach((num, index) => {
+            // 根據預先計算的區間找到對應的圖案
+            const match = ranges.find((r) => num <= r.threshold);
+            if (match) {
+                this.patterns[index] = match.pattern;
+            }
+            else {
+                this.patterns[index] = null;
+            }
+        });
+        this.emit("rollSlots");
+    }
+    /**
+     * 計算分數。
+     */
+    calculateScore() {
+        const [p1, p2, p3] = this.patterns;
+        if (!p1 || !p2 || !p3) {
+            console.warn("圖案未正確生成，無法計算分數。");
+            return;
+        }
+        if (p1.name === p2.name && p2.name === p3.name) {
+            // 三個圖案相同
+            this.marginScore += p1.scores[0];
+        }
+        else if (p1.name === p2.name ||
+            p2.name === p3.name ||
+            p1.name === p3.name) {
+            // 兩個圖案相同
+            if (p1.name === p2.name) {
+                this.marginScore += p1.scores[1];
+                this.marginScore += p3.scores[2];
+            }
+            else if (p2.name === p3.name) {
+                this.marginScore += p2.scores[1];
+                this.marginScore += p1.scores[2];
+            }
+            else {
+                this.marginScore += p1.scores[1];
+                this.marginScore += p2.scores[2];
+            }
+            this.marginScore = Math.round(this.marginScore / 1.4);
+        }
+        else {
+            // 三個圖案皆不同
+            this.marginScore += p1.scores[2];
+            this.marginScore += p2.scores[2];
+            this.marginScore += p3.scores[2];
+            this.marginScore = Math.round(this.marginScore / 3);
+        }
+        this.emit("calculateScore");
+    }
+    roundEnd() {
+        this.score += this.marginScore;
+        this.emit("roundEnd");
+    }
+    gameOver() {
+        this.emit("gameOver");
+    }
+    play() {
+        if (!this.isRunning()) {
+            console.warn("遊戲次數已達上限，無法繼續遊玩。");
+            return;
+        }
+        this.roundStart();
+        this.rollSlots();
+        this.calculateScore();
+        this.roundEnd();
+        if (!this.isRunning()) {
+            this.gameOver();
+        }
+    }
+}
+exports.LaBaG = LaBaG;