labag 2.6.7 → 3.0.1

package/dist/index.d.ts

@@ -1,12 +1,3 @@
 import { LaBaG } from "./labag";
-import { modes } 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";
-import { ModeName } from "./types";
-declare const labag: LaBaG;
-declare const recorder: Recorder;
-declare const checker: RecordChecker;
-export { labag, recorder, checker, modes, patterns, LaBaG, Recorder, RecordChecker, Mode, type LaBaGEvent, type Pattern, type PatternName, type GameRecord, type ModeName, };
+import { Pattern, Payout } from "./types";
+export { LaBaG, Pattern, Payout };

package/dist/index.js

@@ -1,24 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mode = exports.RecordChecker = exports.Recorder = exports.LaBaG = exports.patterns = exports.modes = exports.checker = exports.recorder = exports.labag = void 0;
+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, "modes", { enumerable: true, get: function () { return modes_1.modes; } });
-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");
-Object.defineProperty(exports, "Recorder", { enumerable: true, get: function () { return recorder_1.Recorder; } });
-const recordChecker_1 = require("./recordChecker");
-Object.defineProperty(exports, "RecordChecker", { enumerable: true, get: function () { return recordChecker_1.RecordChecker; } });
-const labag = new labag_1.LaBaG();
-exports.labag = labag;
-modes_1.modes.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/labag.d.ts

@@ -1,99 +1,13 @@
-import { Mode } from "./mode";
-import { Pattern, LaBaGEvent, ModeName } from "./types";
-/**
- * 拉霸遊戲的主要類別。
- */
+import { Pattern, Payout } from "./types";
 export declare class LaBaG {
-    /** 總遊玩次數限制 */
-    times: number;
-    /** 已遊玩次數 */
-    played: number;
-    /** 當前進行的輪次 */
-    rounds: number;
-    /** 當前分數 */
-    score: number;
-    /** 邊際分數 */
-    marginScore: number;
-    /** 產生的隨機數字 */
-    randNums: number[];
-    /** 當前轉出的圖案組合 */
-    patterns: [Pattern | null, Pattern | null, Pattern | null];
-    /** 遊戲模式列表 */
-    modes: Mode[];
-    /** 事件監聽器列表 */
-    eventListeners: Record<LaBaGEvent, ((game: LaBaG) => void)[]>;
-    __defaultMode__: Mode;
-    constructor(times?: number);
-    /**
-     * 觸發指定事件。
-     * @param event - 要觸發的事件名稱。
-     */
-    private emit;
-    /**
-     * 新增事件監聽器。
-     * @param event - 要監聽的事件名稱。
-     * @param listener - 事件觸發時要執行的函式。
-     * @remarks 可以為同一事件添加多個監聽器，這些監聽器將按照添加的順序依次執行。
-     * @example
-     * game.addEventListener("gameStart", (game) => {
-     *   console.log("遊戲開始了！");
-     * });
-     * game.addEventListener("roundEnd", (game) => {
-     *  console.log("一輪結束了！");
-     * });
-     */
-    addEventListener(event: LaBaGEvent, callbackFn: (game: LaBaG) => void): void;
-    /**
-     * 移除事件監聽器。
-     * @param event - 要移除監聽器的事件名稱。
-     * @param listener - 要移除的監聽器函式。
-     * @remarks 這將從指定事件的監聽器列表中移除第一個匹配的函式。
-     * @example
-     * const onGameStart = (game) => {
-     *   console.log("遊戲開始了！");
-     * };
-     * game.addEventListener("gameStart", onGameStart);
-     * // 之後如果想要移除這個監聽器：
-     * game.removeEventListener("gameStart", onGameStart);
-     */
-    removeEventListener(event: LaBaGEvent, callbackFn: (game: LaBaG) => void): void;
-    /**
-     * 新增遊戲模式。
-     * @param mode - 要新增的遊戲模式實例。
-     * @remarks 這將把指定的模式添加到遊戲的模式列表中，並自動註冊該模式定義的事件監聽器。
-     * @example
-     * const myMode = new Mode({
-     *  active: false,
-     * name: "myMode",
-     * rates: {
-     *  gss: 10,
-     *  hhh: 20,
-     *  hentai: 30,
-     *  handson: 20,
-     *  kachu: 10,
-     *  rrr: 10,
-     * },
-     * });
-     * game.addMode(myMode);
-     */
-    addMode(mode: Mode<any>): void;
-    /**
-     * 取得目前遊戲的相關設定
-     */
-    getCurrentConfig(): {
-        modes: Mode<Record<string, any>, string>[];
-        ranges: {
-            threshold: number;
-            pattern: Pattern;
-        }[];
+    patterns: Pattern[];
+    reels: Pattern[];
+    payouts: Payout[];
+    constructor(patterns: Pattern[], payouts: Payout[]);
+    spin(): {
+        reels: Pattern[];
+        reward: number;
     };
-    init(): void;
-    roundStart(): void;
-    rollSlots(): void;
-    calculateScore(): void;
-    roundEnd(): void;
-    gameOver(): void;
-    play(): void;
-    getMode(name: ModeName): Mode<Record<string, any>, string> | undefined;
-    get isRunning(): boolean;
+    randomPattern(): Pattern;
+    caculateReward(reels: Pattern[]): number;
 }

package/dist/labag.js

@@ -1,283 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LaBaG = void 0;
-const mode_1 = require("./mode");
-const pattern_1 = require("./pattern");
 const randInt_1 = require("./utils/randInt");
-/**
- * 拉霸遊戲的主要類別。
- */
 class LaBaG {
-    /** 總遊玩次數限制 */
-    times;
-    /** 已遊玩次數 */
-    played;
-    /** 當前進行的輪次 */
-    rounds;
-    /** 當前分數 */
-    score;
-    /** 邊際分數 */
-    marginScore;
-    /** 產生的隨機數字 */
-    randNums;
-    /** 當前轉出的圖案組合 */
     patterns;
-    /** 遊戲模式列表 */
-    modes;
-    /** 事件監聽器列表 */
-    eventListeners;
-    __defaultMode__;
-    constructor(times = 30) {
-        this.times = times;
-        this.played = 0;
-        this.rounds = 0;
-        this.score = 0;
-        this.marginScore = 0;
-        this.randNums = [];
-        this.patterns = [null, null, null];
-        this.modes = [];
-        this.eventListeners = {
-            gameOver: [],
-            gameStart: [],
-            roundStart: [],
-            roundEnd: [],
-            rollSlots: [],
-            calculateScore: [],
+    reels;
+    payouts;
+    constructor(patterns, payouts) {
+        this.patterns = patterns;
+        this.reels = [patterns[0], patterns[1], patterns[2]];
+        this.payouts = payouts;
+    }
+    spin() {
+        this.reels = [
+            this.randomPattern(),
+            this.randomPattern(),
+            this.randomPattern(),
+        ];
+        const reward = this.caculateReward(this.reels);
+        return {
+            reels: this.reels,
+            reward,
         };
-        this.__defaultMode__ = new mode_1.Mode({
-            active: true,
-            name: "normal",
-            rates: {
-                gss: 36,
-                hhh: 24,
-                hentai: 17,
-                handson: 12,
-                kachu: 8,
-                rrr: 3,
-            },
-            eventListener: {
-                gameStart: (game) => {
-                    game.played = 0;
-                    game.rounds = 0;
-                    game.score = 0;
-                    game.marginScore = 0;
-                    game.randNums = [];
-                    game.patterns = [null, null, null];
-                },
-                roundStart: (game) => {
-                    game.played += 1;
-                    game.rounds += 1;
-                    game.marginScore = 0;
-                },
-                rollSlots: (game) => {
-                    const { ranges } = game.getCurrentConfig();
-                    const rangesAcc = ranges.length > 0 ? ranges[ranges.length - 1].threshold : 0;
-                    // 產生 3 個隨機數字並直接尋找對應圖案
-                    for (let i = 0; i < 3; i++) {
-                        const num = (0, randInt_1.randInt)(1, rangesAcc);
-                        game.randNums[i] = num;
-                        let matchedPattern = null;
-                        for (let j = 0; j < ranges.length; j++) {
-                            if (num <= ranges[j].threshold) {
-                                matchedPattern = ranges[j].pattern;
-                                break;
-                            }
-                        }
-                        game.patterns[i] = matchedPattern;
-                    }
-                },
-                calculateScore: (game, mode) => {
-                    const [p1, p2, p3] = game.patterns;
-                    if (!p1 || !p2 || !p3) {
-                        game.marginScore = 0;
-                        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 / mode.variable.twoMatchDivisor);
-                    }
-                    else {
-                        // 三個圖案皆不同
-                        this.marginScore += p1.scores[2];
-                        this.marginScore += p2.scores[2];
-                        this.marginScore += p3.scores[2];
-                        this.marginScore = Math.round(this.marginScore / mode.variable.allDifferentDivisor);
-                    }
-                },
-                roundEnd: (game) => {
-                    game.score += game.marginScore;
-                },
-            },
-            variable: {
-                twoMatchDivisor: 1.4,
-                allDifferentDivisor: 3,
-            },
-        });
-        this.addMode(this.__defaultMode__);
     }
-    /**
-     * 觸發指定事件。
-     * @param event - 要觸發的事件名稱。
-     */
-    emit(event) {
-        const listeners = this.eventListeners[event];
-        for (let i = 0; i < listeners.length; i++) {
-            listeners[i](this);
-        }
-    }
-    /**
-     * 新增事件監聽器。
-     * @param event - 要監聽的事件名稱。
-     * @param listener - 事件觸發時要執行的函式。
-     * @remarks 可以為同一事件添加多個監聽器，這些監聽器將按照添加的順序依次執行。
-     * @example
-     * game.addEventListener("gameStart", (game) => {
-     *   console.log("遊戲開始了！");
-     * });
-     * game.addEventListener("roundEnd", (game) => {
-     *  console.log("一輪結束了！");
-     * });
-     */
-    addEventListener(event, callbackFn) {
-        this.eventListeners[event].push(callbackFn);
-    }
-    /**
-     * 移除事件監聽器。
-     * @param event - 要移除監聽器的事件名稱。
-     * @param listener - 要移除的監聽器函式。
-     * @remarks 這將從指定事件的監聽器列表中移除第一個匹配的函式。
-     * @example
-     * const onGameStart = (game) => {
-     *   console.log("遊戲開始了！");
-     * };
-     * game.addEventListener("gameStart", onGameStart);
-     * // 之後如果想要移除這個監聽器：
-     * game.removeEventListener("gameStart", onGameStart);
-     */
-    removeEventListener(event, callbackFn) {
-        const listeners = this.eventListeners[event];
-        const index = listeners.indexOf(callbackFn);
-        if (index !== -1) {
-            listeners.splice(index, 1);
-        }
-    }
-    /**
-     * 新增遊戲模式。
-     * @param mode - 要新增的遊戲模式實例。
-     * @remarks 這將把指定的模式添加到遊戲的模式列表中，並自動註冊該模式定義的事件監聽器。
-     * @example
-     * const myMode = new Mode({
-     *  active: false,
-     * name: "myMode",
-     * rates: {
-     *  gss: 10,
-     *  hhh: 20,
-     *  hentai: 30,
-     *  handson: 20,
-     *  kachu: 10,
-     *  rrr: 10,
-     * },
-     * });
-     * game.addMode(myMode);
-     */
-    addMode(mode) {
-        this.modes.push(mode);
-        // 註冊特定模式的監聽器
-        Object.entries(mode.eventListener).forEach(([event, listener]) => {
-            if (listener) {
-                this.addEventListener(event, (game) => listener(game, mode));
-            }
-        });
-    }
-    /**
-     * 取得目前遊戲的相關設定
-     */
-    getCurrentConfig() {
-        const activeModes = this.modes.filter((m) => m.active);
-        if (activeModes.length === 0) {
-            throw new Error("目前沒有啟用中的模式，無法轉動拉霸機。");
-        }
-        // 合併所有啟用中模式的機率設定
-        const combinedRates = {
-            gss: 0,
-            hhh: 0,
-            hentai: 0,
-            handson: 0,
-            kachu: 0,
-            rrr: 0,
-        };
-        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;
-        for (const pattern of pattern_1.patterns) {
-            const rate = combinedRates[pattern.name];
-            if (rate !== undefined) {
-                acc += rate;
-                ranges.push({ threshold: acc, pattern });
+    randomPattern() {
+        const totalWeight = this.patterns.reduce((sum, pattern) => sum + pattern.weight, 0);
+        const randNum = (0, randInt_1.randInt)(1, totalWeight);
+        let cumulativeWeight = 0;
+        for (const pattern of this.patterns) {
+            cumulativeWeight += pattern.weight;
+            if (randNum <= cumulativeWeight) {
+                return pattern;
             }
         }
-        return { modes: activeModes, ranges };
-    }
-    init() {
-        this.emit("gameStart");
-    }
-    roundStart() {
-        this.emit("roundStart");
-    }
-    rollSlots() {
-        this.emit("rollSlots");
-    }
-    calculateScore() {
-        this.emit("calculateScore");
+        throw new Error("No pattern found");
     }
-    roundEnd() {
-        this.emit("roundEnd");
-    }
-    gameOver() {
-        this.emit("gameOver");
-    }
-    play() {
-        if (!this.isRunning) {
-            throw new Error("遊戲已結束，無法繼續遊玩。");
+    caculateReward(reels) {
+        const patternCounts = {};
+        for (const pattern of reels) {
+            patternCounts[pattern.id] = (patternCounts[pattern.id] || 0) + 1;
         }
-        this.roundStart();
-        this.rollSlots();
-        this.calculateScore();
-        this.roundEnd();
-        if (!this.isRunning) {
-            this.gameOver();
+        let totalReward = 0;
+        for (const payout of this.payouts) {
+            if (patternCounts[payout.pattern_id] === payout.match_count) {
+                totalReward += payout.reward;
+            }
         }
-    }
-    getMode(name) {
-        return this.modes.find((m) => m.name === name);
-    }
-    get isRunning() {
-        return this.played < this.times;
+        return totalReward;
     }
 }
 exports.LaBaG = LaBaG;

package/dist/test.js

@@ -1,38 +1,24 @@
 "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`);
-});
-index_1.labag.addEventListener("roundStart", (game) => {
-    console.log(`--- Round ${game.rounds} Start ---`);
-});
-index_1.labag.addEventListener("rollSlots", (game) => {
-    const { modes, ranges } = game.getCurrentConfig();
-    console.log(`Active Modes: ${modes.map((m) => m.name).join(", ")}`);
-    console.log(`Probability Ranges: ${ranges
-        .map((r) => `${r.pattern.name}<=${r.threshold}`)
-        .join(", ")}`);
-});
-index_1.labag.addEventListener("roundEnd", (game) => {
-    console.log(game.patterns.map((p) => (p ? p.name : "null")).join(" | "));
-    console.log(`Margin Score: ${game.marginScore}`);
-    console.log(`Score: ${game.score}\n`);
-});
-index_1.labag.init();
-index_2.recorder.init();
-while (index_1.labag.isRunning) {
-    index_1.labag.play();
+const labag_1 = require("./labag");
+const patterns = [
+    { id: "A", weight: 50, image: "A.png" },
+    { id: "B", weight: 30, image: "B.png" },
+    { id: "C", weight: 20, image: "C.png" },
+];
+const payouts = [
+    { id: "payout1", pattern_id: "A", match_count: 3, reward: 100 },
+    { id: "payout2", pattern_id: "B", match_count: 3, reward: 50 },
+    { id: "payout3", pattern_id: "C", match_count: 3, reward: 20 },
+    { id: "payout4", pattern_id: "A", match_count: 2, reward: 10 },
+    { id: "payout5", pattern_id: "B", match_count: 2, reward: 5 },
+    { id: "payout6", pattern_id: "C", match_count: 2, reward: 2 },
+];
+const labag = new labag_1.LaBaG(patterns, payouts);
+let totalReward = 0;
+for (let i = 0; i < 10; i++) {
+    const result = labag.spin();
+    console.log(`Spin ${i + 1}:`, result);
+    totalReward += result.reward;
 }
-console.log("Game Over");
-console.log(`Final Score: ${index_1.labag.score}`);
-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!");
+console.log("Total Reward:", totalReward);

package/dist/types/index.d.ts

@@ -1,20 +1,11 @@
-import { modes } from "../modes";
-import { patterns } from "../pattern";
-/**
- * 拉霸遊戲的事件類型。
- */
-export type LaBaGEvent = "gameOver" | "gameStart" | "roundStart" | "roundEnd" | "rollSlots" | "calculateScore";
-/**
- * 代表一個圖案及其對應的分數。
- */
 export type Pattern = {
-    /** 圖案名稱 */
-    name: string;
-    /** 對應的分數陣列 */
-    scores: number[];
+    id: string;
+    weight: number;
+    image: string;
+};
+export type Payout = {
+    id: string;
+    pattern_id: Pattern["id"];
+    match_count: number;
+    reward: number;
 };
-/**
- * 圖案名稱的型別。
- */
-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.6.7",
+  "version": "3.0.1",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -1,31 +1,4 @@
 import { LaBaG } from "./labag";
-import { modes } 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";
-import { ModeName } from "./types";
+import { Pattern, Payout } from "./types";
 
-const labag = new LaBaG();
-modes.forEach((mode) => {
-  labag.addMode(mode);
-});
-const recorder = new Recorder(labag);
-const checker = new RecordChecker(labag);
-export {
-  labag,
-  recorder,
-  checker,
-  modes,
-  patterns,
-  LaBaG,
-  Recorder,
-  RecordChecker,
-  Mode,
-  type LaBaGEvent,
-  type Pattern,
-  type PatternName,
-  type GameRecord,
-  type ModeName,
-};
+export { LaBaG, Pattern, Payout };