labag 1.2.1 → 2.0.0

package/dist/mode.d.ts

@@ -0,0 +1,30 @@
+import { LaBaG } from "./labag";
+import { LaBaGEvent, Pattern, PatternName } from "./types";
+/**
+ * 代表遊戲的一種模式，包含機率設定和事件監聽器。
+ */
+export declare class Mode {
+    /** 模式是否啟用 */
+    active: boolean;
+    /** 模式名稱 */
+    name: string;
+    /** 各圖案出現的機率 */
+    rates: Record<PatternName, number>;
+    ranges: {
+        threshold: number;
+        pattern: Pattern;
+    }[];
+    /** 事件監聽器 */
+    eventListener: Partial<Record<LaBaGEvent, (game: LaBaG, mode: Mode) => void>>;
+    /** 模式專屬的變數儲存空間 */
+    variable: Record<string, any>;
+    /** 機率總和 */
+    /**
+     * 建立一個新的模式。
+     * @param active - 是否啟用此模式。
+     * @param name - 模式名稱。
+     * @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>);
+}

package/dist/mode.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mode = void 0;
+const pattern_1 = require("./pattern");
+/**
+ * 代表遊戲的一種模式，包含機率設定和事件監聽器。
+ */
+class Mode {
+    /** 模式是否啟用 */
+    active;
+    /** 模式名稱 */
+    name;
+    /** 各圖案出現的機率 */
+    rates;
+    // 預先計算的區間，用於高效查找
+    ranges;
+    /** 事件監聽器 */
+    eventListener;
+    /** 模式專屬的變數儲存空間 */
+    variable;
+    /** 機率總和 */
+    /**
+     * 建立一個新的模式。
+     * @param active - 是否啟用此模式。
+     * @param name - 模式名稱。
+     * @param rates - 各圖案的機率設定。
+     * @param eventListener - 事件監聽器。
+     */
+    constructor(active, name, rates, eventListener, variable) {
+        this.active = active;
+        this.name = name;
+        this.rates = rates;
+        this.eventListener = eventListener ?? {};
+        this.variable = variable ?? {};
+        // 預先計算機率區間
+        this.ranges = [];
+        let acc = 0;
+        // 遍歷定義的圖案以確保順序一致
+        for (const pattern of pattern_1.patterns) {
+            const rate = rates[pattern.name];
+            if (rate !== undefined) {
+                acc += rate;
+                this.ranges.push({ threshold: acc, pattern });
+            }
+        }
+        if (acc > 100) {
+            console.warn(`模式 "${name}" 的機率總和超過 100%，請檢查設定。`);
+        }
+    }
+}
+exports.Mode = Mode;

package/dist/pattern.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 定義遊戲中可用的圖案及其分數。
+ */
+export declare const patterns: readonly [{
+    readonly name: "gss";
+    readonly scores: [800, 400, 180];
+}, {
+    readonly name: "hhh";
+    readonly scores: [1500, 800, 300];
+}, {
+    readonly name: "hentai";
+    readonly scores: [2500, 1200, 500];
+}, {
+    readonly name: "handson";
+    readonly scores: [2900, 1450, 690];
+}, {
+    readonly name: "kachu";
+    readonly scores: [12000, 8000, 1250];
+}, {
+    readonly name: "rrr";
+    readonly scores: [20000, 12000, 2500];
+}];

package/dist/pattern.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patterns = void 0;
+/**
+ * 定義遊戲中可用的圖案及其分數。
+ */
+exports.patterns = [
+    {
+        name: "gss",
+        scores: [800, 400, 180],
+    },
+    {
+        name: "hhh",
+        scores: [1500, 800, 300],
+    },
+    {
+        name: "hentai",
+        scores: [2500, 1200, 500],
+    },
+    {
+        name: "handson",
+        scores: [2900, 1450, 690],
+    },
+    {
+        name: "kachu",
+        scores: [12000, 8000, 1250],
+    },
+    {
+        name: "rrr",
+        scores: [20000, 12000, 2500],
+    },
+];

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+index_1.default.addEventListener("gameStart", (game) => {
+    console.log("Game Started!");
+    console.log(`Total Rounds: ${game.times}\n`);
+});
+index_1.default.addEventListener("roundStart", (game) => {
+    console.log(`--- Round ${game.rounds} Start ---`);
+});
+index_1.default.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.default.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.default.init();
+while (index_1.default.isRunning()) {
+    index_1.default.play();
+}
+console.log("Game Over");
+console.log(`Final Score: ${index_1.default.score}`);
+console.log(`Active Modes at end: ${index_1.default
+    .getCurrentConfig()
+    .modes.map((m) => m.name)
+    .join(", ")}`);

package/dist/types/index.d.ts

@@ -0,0 +1,18 @@
+import { patterns } from "src/pattern";
+/**
+ * 拉霸遊戲的事件類型。
+ */
+export type LaBaGEvent = "gameOver" | "gameStart" | "roundStart" | "roundEnd" | "rollSlots" | "calculateScore";
+/**
+ * 代表一個圖案及其對應的分數。
+ */
+export type Pattern = {
+    /** 圖案名稱 */
+    name: string;
+    /** 對應的分數陣列 */
+    scores: number[];
+};
+/**
+ * 圖案名稱的型別。
+ */
+export type PatternName = (typeof patterns)[number]["name"];

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/RandInt.d.ts

@@ -1 +1,7 @@
-export declare function RandInt(min: number, max: number): number;
+/**
+ * 產生一個介於 min 和 max 之間的隨機整數（包含 min 和 max）。
+ * @param min - 最小值。
+ * @param max - 最大值。
+ * @returns 介於 min 和 max 之間的隨機整數。
+ */
+export declare const randInt: (min: number, max: number) => number;

package/dist/utils/RandInt.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RandInt = RandInt;
-function RandInt(min, max) {
-    return Math.floor(Math.random() * (max - min + 1)) + min;
-}
+exports.randInt = void 0;
+/**
+ * 產生一個介於 min 和 max 之間的隨機整數（包含 min 和 max）。
+ * @param min - 最小值。
+ * @param max - 最大值。
+ * @returns 介於 min 和 max 之間的隨機整數。
+ */
+const randInt = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
+exports.randInt = randInt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "labag",
-  "version": "1.2.1",
+  "version": "2.0.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,7 @@
   },
   "keywords": [],
   "author": "",
-  "license": "ISC",
+  "license": "MIT",
   "type": "commonjs",
   "devDependencies": {
     "typescript": "^5.8.3"

package/src/index.ts

@@ -1,188 +1,210 @@
-import { LaBaG, OneDataType, AllDataType } from "./types/LaBaG";
-import { Mode, ModeNames } from "./types/Mode";
-import { RandInt } from "./utils/RandInt";
-import { PlayLaBaG } from "./types/PlayLaBaG";
-import { JsonLaBaG } from "./types/JsonLaBaG";
-import { P, PData } from "./types/P";
-import { parseScore, verifyScore } from './utils/data';
+import { LaBaG } from "./labag";
+import { Mode } from "./mode";
+import { randInt } from "./utils/randInt";
 
-const PDatas: Record<string, PData> = {
-  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],
-  },
-};
+const labag = new LaBaG();
 
-Object.values(PDatas).forEach((pd: PData) => {
-  new P(pd.name, pd.code, pd.scores, pd.rates);
-});
-
-const Modes: Record<Exclude<ModeNames, "Normal">, Mode> = {
-  // 超級阿禾
-  SuperHHH: {
-    InMode: false,
-    Rate: 15,
-    Times: 0,
-    Score: 0,
-    RandNum: 0,
-    Random(): void {
-      this.RandNum = RandInt(1, 100);
+const modes: ConstructorParameters<typeof Mode>[] = [
+  [
+    false,
+    "superhhh",
+    {
+      gss: 19,
+      hhh: 5,
+      hentai: 19,
+      handson: 19,
+      kachu: 19,
+      rrr: 19,
     },
-    Judge(Game: LaBaG): void {
-      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;
+    {
+      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 = randInt(1, 100);
+      },
+      roundEnd: (game, mode) => {
+        const { patterns } = game;
+        const { variable } = mode;
 
-        if (Game.Ps.every((p) => p?.code === "B")) {
-          this.Times += 2;
+        let hhhCount = 0;
+        let allHHH = true;
+        for (const p of patterns) {
+          if (p?.name === "hhh") hhhCount++;
+          else allHHH = false;
         }
-        if (this.Times <= 0) {
-          this.InMode = false;
-          Game.JudgeMode();
-          Game.ModeToScreen = true;
-        }
-      } 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 (Game.Ps.every((p) => p?.code === "B")) {
-            this.Score = Math.round((Game.Score * Game.ScoreTime) / 2);
-            Game.Score += this.Score;
+          if (variable.times <= 0) {
+            mode.active = false;
+          }
+        } 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(): void {
-      this.RandNum = RandInt(1, 100);
+    {
+      times: 0,
+      rate: 15,
+      score: 0,
+      randNum: 0,
+      pattern: {
+        name: "superhhh",
+        scores: [1500, 800, 300],
+      },
     },
-    Judge(Game: LaBaG): void {
-      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 = 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: LaBaG) {
-      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,
+    },
+  ],
+];
+
+for (const modeArgs of modes) {
+  const mode = new Mode(...modeArgs);
+  labag.addMode(mode);
+}
 
-export {
-  Modes,
-  PDatas,
-  parseScore,
-  verifyScore,
-};
+export default labag;