labag 2.6.6 → 3.0.0

package/src/labag.ts

@@ -1,308 +1,57 @@
-import { Mode } from "./mode";
-import { patterns } from "./pattern";
-import { Pattern, LaBaGEvent, PatternName, ModeName } from "./types";
+import { Pattern, Payout } from "./types";
 import { randInt } from "./utils/randInt";
 
-/**
- * 拉霸遊戲的主要類別。
- */
-export 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 = 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: [],
+export class LaBaG {
+  patterns: Pattern[];
+  reel: Pattern[];
+  payouts: Payout[];
+
+  constructor(patterns: Pattern[], payouts: Payout[]) {
+    this.patterns = patterns;
+    this.reel = [patterns[0], patterns[1], patterns[2]];
+    this.payouts = payouts;
+  }
+  spin() {
+    this.reel = [
+      this.randomPattern(),
+      this.randomPattern(),
+      this.randomPattern(),
+    ];
+    const reward = this.caculateReward(this.reel);
+    return {
+      reel: this.reel,
+      reward,
     };
-
-    this.__defaultMode__ = new 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 = randInt(1, rangesAcc);
-            game.randNums[i] = num;
-
-            let matchedPattern: Pattern | null = 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 - 要觸發的事件名稱。
-   */
-  private emit(event: LaBaGEvent) {
-    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: LaBaGEvent, callbackFn: (game: LaBaG) => void) {
-    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: LaBaGEvent, callbackFn: (game: LaBaG) => void) {
-    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: Mode<any>) {
-    this.modes.push(mode);
-    // 註冊特定模式的監聽器
-    Object.entries(mode.eventListener).forEach(([event, listener]) => {
-      if (listener) {
-        this.addEventListener(event as LaBaGEvent, (game) =>
-          listener(game, mode),
-        );
-      }
-    });
-  }
-
-  /**
-   * 取得目前遊戲的相關設定
-   */
-  getCurrentConfig() {
-    const activeModes = this.modes.filter((m) => m.active);
-    if (activeModes.length === 0) {
-      throw new Error("目前沒有啟用中的模式，無法轉動拉霸機。");
-    }
-    // 合併所有啟用中模式的機率設定
-    const combinedRates: Record<PatternName, number> = {
-      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 as PatternName] +=
-          mode.rates[patternName as PatternName];
+  randomPattern(): Pattern {
+    const totalWeight = this.patterns.reduce(
+      (sum, pattern) => sum + pattern.weight,
+      0,
+    );
+    const randNum = randInt(1, totalWeight);
+    let cumulativeWeight = 0;
+    for (const pattern of this.patterns) {
+      cumulativeWeight += pattern.weight;
+      if (randNum <= cumulativeWeight) {
+        return pattern;
       }
     }
-
-    // 預先計算合併後的區間
-    const ranges: { threshold: number; pattern: Pattern }[] = [];
-    let acc = 0;
-    for (const pattern of patterns) {
-      const rate = combinedRates[pattern.name];
-      if (rate !== undefined) {
-        acc += rate;
-        ranges.push({ threshold: acc, pattern });
-      }
-    }
-
-    return { modes: activeModes, ranges };
-  }
-
-  init() {
-    this.emit("gameStart");
-  }
-
-  roundStart() {
-    this.emit("roundStart");
-  }
-
-  rollSlots() {
-    this.emit("rollSlots");
-  }
-
-  calculateScore() {
-    this.emit("calculateScore");
-  }
-
-  roundEnd() {
-    this.emit("roundEnd");
-  }
-
-  gameOver() {
-    this.emit("gameOver");
+    throw new Error("No pattern found");
   }
 
-  play() {
-    if (!this.isRunning) {
-      throw new Error("遊戲已結束，無法繼續遊玩。");
+  caculateReward(reels: Pattern[]): number {
+    const patternCounts: { [key: string]: number } = {};
+    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: ModeName) {
-    return this.modes.find((m) => m.name === name);
-  }
-
-  get isRunning() {
-    return this.played < this.times;
+    return totalReward;
   }
 }

package/src/test.ts

@@ -1,45 +0,0 @@
-import { checker, labag } from "./index";
-import { recorder } from "./index";
-labag.addEventListener("gameStart", (game) => {
-  console.log("Game Started!");
-  console.log(`Total Rounds: ${game.times}\n`);
-});
-labag.addEventListener("roundStart", (game) => {
-  console.log(`--- Round ${game.rounds} Start ---`);
-});
-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(", ")}`,
-  );
-});
-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`);
-});
-
-labag.init();
-recorder.init();
-
-while (labag.isRunning) {
-  labag.play();
-}
-
-console.log("Game Over");
-console.log(`Final Score: ${labag.score}`);
-console.log(
-  `Active Modes at end: ${labag
-    .getCurrentConfig()
-    .modes.map((m) => m.name)
-    .join(", ")}`,
-);
-console.log(`record: ${JSON.stringify(recorder.getRecord(), null, 2)}`);
-console.log(
-  checker.check(recorder.getRecord())
-    ? "Record is valid!"
-    : "Record is invalid!",
-);

package/src/types/index.ts

@@ -1,31 +1,12 @@
-import { LaBaG } from "src/labag";
-import { modes } from "src/modes";
-import { patterns } from "src/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 PatternName = (typeof patterns)[number]["name"];
-
-export type ModeName = (typeof modes)[number]["name"] | "normal";
+export type Payout = {
+  id: string;
+  pattern_id: Pattern["id"];
+  match_count: number;
+  reward: number;
+};

package/src/mode.ts

@@ -1,90 +0,0 @@
-import { LaBaG } from "./labag";
-import { patterns } from "./pattern";
-import { LaBaGEvent, Pattern, PatternName } from "./types";
-interface ModeConfig<
-  VariableType extends Record<string, any>,
-  N extends string = string,
-> {
-  active: boolean;
-  name: N;
-  rates: Record<PatternName, number>;
-  eventListener?: Partial<
-    Record<LaBaGEvent, (game: LaBaG, mode: Mode<VariableType>) => void>
-  >;
-  variable?: VariableType;
-}
-
-/**
- * 代表遊戲的一種模式，包含機率設定和事件監聽器。
- */
-export class Mode<
-  VariableType extends Record<string, any> = Record<string, any>,
-  N extends string = string,
-> implements ModeConfig<VariableType, N> {
-  /** 模式是否啟用 */
-  active: boolean;
-  /** 模式名稱 */
-  name: N;
-  /** 各圖案出現的機率 */
-  rates: Record<PatternName, number>;
-  // 預先計算的區間，用於高效查找
-  ranges: { threshold: number; pattern: Pattern }[];
-  /** 事件監聽器 */
-  eventListener: Partial<
-    Record<LaBaGEvent, (game: LaBaG, mode: Mode<VariableType>) => void>
-  >;
-
-  /** 模式專屬的變數儲存空間 */
-  variable: VariableType;
-  /** 機率總和 */
-
-  /**
-   * 建立一個新的遊戲模式。
-   * @param config 模式的設定，包括啟用狀態、名稱、機率、事件監聽器和專屬變數。
-   * @remarks 會根據提供的機率設定預先計算出對應的區間，以便在遊戲中快速查找圖案。
-   * @example
-   * const myMode = new Mode({
-   *   active: false,
-   *   name: "myMode",
-   *  rates: {
-   *    gss: 10,
-   *   hhh: 20,
-   *   hentai: 30,
-   *   handson: 20,
-   *   kachu: 10,
-   *   rrr: 10,
-   * },
-   *  eventListener: {
-   *   gameStart: (game, mode) => {
-   *    console.log("遊戲開始了！", mode.name);
-   * },
-   *  roundEnd: (game, mode) => {
-   *   console.log("一輪結束了！", mode.name);
-   * },
-   * },
-   * variable: {
-   *  myCustomValue: 123,
-   * },
-   * });
-   */
-  constructor(config: ModeConfig<VariableType, N>) {
-    const { active, name, rates, eventListener, variable } = config;
-    this.active = active;
-    this.name = name;
-    this.rates = rates;
-    this.eventListener = eventListener ?? {};
-    this.variable = variable ?? ({} as VariableType);
-
-    // 預先計算機率區間
-    this.ranges = [];
-    let acc = 0;
-    // 遍歷定義的圖案以確保順序一致
-    for (const pattern of patterns) {
-      const rate = rates[pattern.name];
-      if (rate !== undefined) {
-        acc += rate;
-        this.ranges.push({ threshold: acc, pattern });
-      }
-    }
-  }
-}

package/src/modes/greenwei.ts

@@ -1,97 +0,0 @@
-import { patterns } from "../pattern";
-import { Mode } from "../mode";
-import { randInt } from "../utils/randInt";
-
-export default new Mode({
-  active: false,
-  name: "greenwei",
-  rates: {
-    gss: 0,
-    hhh: 0,
-    hentai: 0,
-    handson: 0,
-    kachu: 0,
-    rrr: 0,
-  },
-  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 = 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;
-        }
-      }
-      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;
-            }
-          }
-        }
-      }
-    },
-  },
-  variable: {
-    times: 0,
-    rate: 35,
-    randNum: 0,
-    count: 0,
-    pattern: {
-      name: "greenwei",
-      scores: [800, 400, 180],
-    },
-    extendTimes: 2,
-    bindPattern: patterns[0],
-    bonusTimes: 2,
-    requiredBindPatternCount: 20,
-    mutiplier: 3,
-  },
-});

package/src/modes/index.ts

@@ -1,5 +0,0 @@
-import greenwei from "./greenwei";
-import pikachu from "./pikachu";
-import superhhh from "./superhhh";
-
-export const modes = [pikachu, greenwei, superhhh] as const;

package/src/modes/pikachu.ts

@@ -1,52 +0,0 @@
-import { patterns } from "../pattern";
-import { Mode } from "../mode";
-
-export default new Mode({
-  active: false,
-  name: "pikachu",
-  rates: {
-    gss: 0,
-    hhh: 0,
-    hentai: 0,
-    handson: 0,
-    kachu: 0,
-    rrr: 0,
-  },
-  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);
-      }
-    },
-  },
-  variable: {
-    times: 0,
-    pattern: {
-      name: "pikachu",
-      scores: [12000, 8000, 1250],
-    },
-    bindPattern: patterns[4],
-    bonusRounds: 3,
-  },
-});