labag 3.0.1 → 3.1.0

package/README.md

@@ -1,7 +1,6 @@
+# LaBaG (Slot Machine Engine)
 
-# LaBaG
-
-LaBaG 是一款用 TypeScript 撰寫的高彈性拉霸機遊戲引擎，支援多種模式、事件監聽、組合得分，適合用於遊戲開發、教學或自訂玩法。
+LaBaG 是一款用 TypeScript 撰寫的高彈性拉霸機 (Slot Machine) 遊戲引擎，支援多種模式、自訂圖案權重與中獎組合，適合用於遊戲開發、教學或自訂玩法。
 
 [![npm version](https://img.shields.io/npm/v/labag.svg)](https://www.npmjs.com/package/labag)
 
@@ -9,112 +8,120 @@ LaBaG 是一款用 TypeScript 撰寫的高彈性拉霸機遊戲引擎，支援
 
 ## 特色
 
-- 支援多種拉霸模式（可自訂/擴充）
-- 圖案與分數組合彈性設定
-- 事件監聽機制，方便擴充互動
-- TypeScript 強型別，易於二次開發
+- 🎰 **高度客製化**：支援自訂圖案 (Pattern) 與中獎規則 (Payout)。
+- ⚖️ **權重控制**：可設定每個圖案出現的權重 (Weight)，控制機率。
+- 💰 **彈性獎勵計算**：自動計算中獎組合與獎勵金額。
+- 🔧 **TypeScript 強型別**：提供完整的型別定義，開發更安心。
 
 ---
 
 ## 安裝
 
+使用 npm 安裝：
+
 ```bash
 npm install labag
 ```
 
 ---
 
-## 基本用法
+## 快速開始
+
+### 1. 引入模組
 
 ```typescript
-import { labag, modeList, LaBaG } from "labag";
-
-labag.init();
-while (labag.isRunning()) {
- labag.play();
- // 可在此取得 labag.patterns, labag.score 等資訊
-}
-console.log(labag.score);
+import { LaBaG, Pattern, Payout } from "labag";
 ```
 
-### 事件監聽
+### 2. 定義圖案 (Patterns)
+
+設定每個圖案的 ID、權重 (出現機率) 與圖片路徑。
 
 ```typescript
-labag.addEventListener("roundEnd", (game) => {
- console.log(game.patterns, game.marginScore, game.score);
-});
+const patterns: Pattern[] = [
+  { id: 1, weight: 10, image: "cherry.png" }, // 稀有
+  { id: 2, weight: 20, image: "bell.png" },
+  { id: 3, weight: 50, image: "bar.png" },    // 常見
+];
 ```
 
----
-
-## API 介紹
+### 3. 定義中獎規則 (Payouts)
 
-### 主要類別
+設定當特定圖案出現特定次數時的獎勵。
 
-- `LaBaG`：拉霸機主體，管理分數、模式、事件等
-- `Mode`：遊戲模式，決定圖案機率與特殊行為
-- `Pattern`：圖案及分數設定
+```typescript
+const payouts: Payout[] = [
+  { id: 1, pattern_id: 1, match_count: 3, reward: 1000 }, // 3個櫻桃 -> 1000分
+  { id: 2, pattern_id: 1, match_count: 2, reward: 50 },   // 2個櫻桃 -> 50分
+  { id: 3, pattern_id: 2, match_count: 3, reward: 500 },  // 3個鈴鐺 -> 500分
+];
+```
 
-### 主要方法
+### 4. 建立實例並開始遊玩
 
-- `labag.init()`：初始化遊戲
-- `labag.play()`：執行一次拉霸
-- `labag.isRunning()`：判斷是否還可繼續遊玩
-- `labag.addMode(mode)`：新增模式
-- `labag.addEventListener(event, fn)`：註冊事件
+```typescript
+const game = new LaBaG(patterns, payouts);
 
-### 主要屬性
+// 進行一次拉霸
+const result = game.spin();
 
-- `labag.score`：目前總分
-- `labag.patterns`：本輪轉出的圖案陣列
-- `labag.modes`：目前所有模式
+console.log("轉出圖案:", result.reels);
+console.log("獲得獎勵:", result.reward);
+```
 
 ---
 
-## 內建模式
+## API 參考
 
-| 模式名稱   | 說明                     |
-|------------|--------------------------|
-| normal     | 標準機率分布             |
-| greenwei   | 特殊加倍與觸發條件       |
-| pikachu    | 特殊復活與替換           |
-| superhhh   | 高風險高報酬             |
+### `LaBaG` 類別
 
-可自訂/擴充模式，詳見 `src/modes/` 範例。
+#### `constructor(patterns: Pattern[], payouts: Payout[])`
 
----
+初始化拉霸機引擎。
 
-## 圖案與分數
+- `patterns`: 圖案列表，包含權重設定。
+- `payouts`: 中獎規則列表。
 
-| 圖案名稱   | 三連分數 | 雙連分數 | 單出分數 |
-|------------|----------|----------|----------|
-| gss        | 800      | 400      | 180      |
-| hhh        | 1500     | 800      | 300      |
-| hentai     | 2500     | 1200     | 500      |
-| handson    | 2900     | 1450     | 690      |
-| kachu      | 12000    | 8000     | 1250     |
-| rrr        | 20000    | 12000    | 2500     |
+#### `spin()`
 
----
+進行一次拉霸，隨機產生結果並計算獎勵。
+
+- **回傳值**: `{ reels: Pattern[], reward: number }`
+  - `reels`: 轉出的圖案陣列 (預設為 3 個)。
+  - `reward`: 計算出的總獎勵金額。
+
+#### `randomPattern(): Pattern`
 
-## 事件列表
+根據權重隨機抽取一個圖案。
 
-| 事件名稱       | 說明             |
-|----------------|------------------|
-| gameStart      | 遊戲開始         |
-| roundStart     | 每輪開始         |
-| rollSlots      | 轉動產生圖案     |
-| calculateScore | 計算分數         |
-| roundEnd       | 每輪結束         |
-| gameOver       | 遊戲結束         |
+#### `caculateReward(reels: Pattern[]): number`
+
+計算給定圖案組合的總獎勵。
 
 ---
 
-## 進階用法
+## 型別定義
+
+### `Pattern`
 
-- 可自訂模式（繼承 `Mode` 並設定 eventListener）
-- 可自訂圖案與分數
-- 可串接前端 UI 或 CLI
+```typescript
+type Pattern = {
+  id: string | number;
+  weight: number; // 出現權重，數字越大機率越高
+  image: string;  // 圖片路徑或代碼
+};
+```
+
+### `Payout`
+
+```typescript
+type Payout = {
+  id: string | number;
+  pattern_id: Pattern["id"]; // 對應的圖案 ID
+  match_count: number;       // 需要出現的次數 (例如 3 代表出現 3 次)
+  reward: number;            // 獎勵金額
+};
+```
 
 ---
 

package/dist/labag.d.ts

@@ -4,10 +4,11 @@ export declare class LaBaG {
     reels: Pattern[];
     payouts: Payout[];
     constructor(patterns: Pattern[], payouts: Payout[]);
-    spin(): {
+    spin(bet: number): {
         reels: Pattern[];
         reward: number;
+        multiplier: number;
     };
     randomPattern(): Pattern;
-    caculateReward(reels: Pattern[]): number;
+    calculateMultiplier(reels: Pattern[]): number;
 }

package/dist/labag.js

@@ -11,16 +11,18 @@ class LaBaG {
         this.reels = [patterns[0], patterns[1], patterns[2]];
         this.payouts = payouts;
     }
-    spin() {
+    spin(bet) {
         this.reels = [
             this.randomPattern(),
             this.randomPattern(),
             this.randomPattern(),
         ];
-        const reward = this.caculateReward(this.reels);
+        const multiplier = this.calculateMultiplier(this.reels);
+        const reward = bet * multiplier;
         return {
             reels: this.reels,
             reward,
+            multiplier,
         };
     }
     randomPattern() {
@@ -35,18 +37,18 @@ class LaBaG {
         }
         throw new Error("No pattern found");
     }
-    caculateReward(reels) {
+    calculateMultiplier(reels) {
         const patternCounts = {};
         for (const pattern of reels) {
             patternCounts[pattern.id] = (patternCounts[pattern.id] || 0) + 1;
         }
-        let totalReward = 0;
+        let totalMultiplier = 0;
         for (const payout of this.payouts) {
             if (patternCounts[payout.pattern_id] === payout.match_count) {
-                totalReward += payout.reward;
+                totalMultiplier += payout.multiplier;
             }
         }
-        return totalReward;
+        return totalMultiplier;
     }
 }
 exports.LaBaG = LaBaG;

package/dist/test.js

@@ -1,24 +1,172 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const labag_1 = require("./labag");
+// --- 設定 (Configuration) ---
+const BET_AMOUNT = 200;
+const SIMULATION_COUNT = 1_000_000;
+// --- 資料定義 (Data Definitions) ---
 const patterns = [
-    { id: "A", weight: 50, image: "A.png" },
-    { id: "B", weight: 30, image: "B.png" },
-    { id: "C", weight: 20, image: "C.png" },
+    {
+        id: 1,
+        weight: 36,
+        image: "https://fanyu.vercel.app/api/album/item/1mDK1ewfLiV3fAB1HbjvwdSaDTdJdBGG3",
+    },
+    {
+        id: 2,
+        weight: 24,
+        image: "https://fanyu.vercel.app/api/album/item/1oB-uZhPPfjfTtG4CITnb3_E-Ops9JTA0",
+    },
+    {
+        id: 3,
+        weight: 17,
+        image: "https://fanyu.vercel.app/api/album/item/1bMJdRB8uerQZfGYINzBI9Vaw32bZljl2",
+    },
+    {
+        id: 4,
+        weight: 12,
+        image: "https://fanyu.vercel.app/api/album/item/1In8LF1wVfLXpPkp57a20zX84QgsAeLQx",
+    },
+    {
+        id: 5,
+        weight: 8,
+        image: "https://fanyu.vercel.app/api/album/item/1Zo_PjrXm-4TBrL2cLAeFkEl1el9kTR56",
+    },
+    {
+        id: 6,
+        weight: 3,
+        image: "https://fanyu.vercel.app/api/album/item/19NMnVgcb-9IsknNcfe9TpCyPBIcGnhQU",
+    },
 ];
 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 },
+    { id: 1, match_count: 2, pattern_id: 1, reward: 56 },
+    { id: 2, match_count: 3, pattern_id: 1, reward: 242 },
+    { id: 3, match_count: 2, pattern_id: 2, reward: 119 },
+    { id: 4, match_count: 3, pattern_id: 2, reward: 578 },
+    { id: 5, match_count: 2, pattern_id: 3, reward: 266 },
+    { id: 6, match_count: 3, pattern_id: 3, reward: 1345 },
+    { id: 7, match_count: 2, pattern_id: 4, reward: 571 },
+    { id: 8, match_count: 3, pattern_id: 4, reward: 3503 },
+    { id: 9, match_count: 2, pattern_id: 5, reward: 2136 },
+    { id: 10, match_count: 3, pattern_id: 5, reward: 11727 },
+    { id: 11, match_count: 2, pattern_id: 6, reward: 18708 },
+    { id: 12, match_count: 3, pattern_id: 6, reward: 182200 },
 ];
-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;
+// --- 輔助函式 (Helpers) ---
+/**
+格式化數字為貨幣或百分比 (Format numbers as currency or percentage)
+*/
+const formatCurrency = (val) => new Intl.NumberFormat("en-US", {
+    style: "decimal",
+    minimumFractionDigits: 0,
+}).format(val);
+/**
+ * 格式化百分比
+ */
+const formatPct = (val) => `${val.toFixed(4)}%`;
+/**
+ * 根據圖案和賠率計算理論統計數據。
+ * 假設滾輪獨立且賠率條件互斥（例如每次旋轉只有一種賠彩）。
+ */
+function calculateTheoreticalStats(patterns, payouts, bet) {
+    const totalWeight = patterns.reduce((sum, p) => sum + p.weight, 0);
+    let ev = 0;
+    let varianceSum = 0; // E[X^2]
+    const hitProbabilities = {};
+    for (const payout of payouts) {
+        const pattern = patterns.find((p) => p.id === payout.pattern_id);
+        if (!pattern)
+            continue;
+        const p = pattern.weight / totalWeight;
+        // 二項分布概率計算特定圖案數量 (假設 3 個滾輪)
+        // Binomial probability for specific pattern count (assuming 3 reels)
+        // k=3: p^3
+        // k=2: C(3,2) * p^2 * (1-p) = 3 * p^2 * (1-p)
+        const prob = payout.match_count === 3 ? Math.pow(p, 3) : 3 * Math.pow(p, 2) * (1 - p);
+        ev += prob * payout.reward;
+        // 假設賠率互斥: E[X^2] = sum(prob * reward^2)
+        // Assuming disjoint payouts: E[X^2] = sum(prob * reward^2)
+        varianceSum += prob * Math.pow(payout.reward, 2);
+        hitProbabilities[payout.reward] =
+            (hitProbabilities[payout.reward] || 0) + prob;
+    }
+    const variance = varianceSum - Math.pow(ev, 2);
+    const stdDev = Math.sqrt(variance);
+    const rtp = (ev / bet) * 100;
+    return { ev, rtp, stdDev, hitProbabilities };
 }
-console.log("Total Reward:", totalReward);
+// --- 模擬邏輯 (Simulation Logic) ---
+function runSimulation(game, count) {
+    let totalReward = 0;
+    let winCount = 0;
+    let maxWin = 0;
+    const hitFrequency = {};
+    for (let i = 0; i < count; i++) {
+        const result = game.spin();
+        totalReward += result.reward;
+        if (result.reward > 0) {
+            winCount++;
+            if (result.reward > maxWin)
+                maxWin = result.reward;
+            hitFrequency[result.reward] = (hitFrequency[result.reward] || 0) + 1;
+        }
+    }
+    return {
+        totalReward,
+        winCount,
+        maxWin,
+        hitFrequency,
+    };
+}
+// --- 主要執行區塊 (Main Execution) ---
+// 1. 理論分析 (Theoretical Analysis)
+console.log("正在計算理論數值...");
+const theo = calculateTheoreticalStats(patterns, payouts, BET_AMOUNT);
+console.log("==========================================");
+console.log("           理論分析 (Theoretical)          ");
+console.log("==========================================");
+console.log(`理論期望值 (EV) : ${theo.ev.toFixed(2)}`);
+console.log(`理論 RTP        : ${theo.rtp.toFixed(2)}%`);
+console.log(`標準差 (SD)     : ${theo.stdDev.toFixed(2)}`);
+console.log("------------------------------------------");
+// 2. 模擬 (Simulation)
+console.log(`\n正在執行模擬 (n=${formatCurrency(SIMULATION_COUNT)})...`);
+const game = new labag_1.LaBaG(patterns, payouts);
+const sim = runSimulation(game, SIMULATION_COUNT);
+const simEV = sim.totalReward / SIMULATION_COUNT;
+const simRTP = (simEV / BET_AMOUNT) * 100;
+const simHitRate = (sim.winCount / SIMULATION_COUNT) * 100;
+// RTP 的信賴區間 (95% CI): 平均值 +/- 1.96 * (標準差 / sqrt(N))
+// 標準誤差 (Standard Error) = 標準差 / sqrt(模擬次數)
+const standardError = theo.stdDev / Math.sqrt(SIMULATION_COUNT);
+// 信賴區間的邊際誤差 (Margin of Error) = 1.96 * 標準誤差
+const marginOfError = 1.96 * standardError;
+// RTP 的誤差百分比 = (邊際誤差 / 投注金額) * 100
+const rtpMargin = (marginOfError / BET_AMOUNT) * 100;
+console.log("==========================================");
+console.log("           模擬結果 (Simulation)          ");
+console.log("==========================================");
+console.log(`總投注           : ${formatCurrency(BET_AMOUNT * SIMULATION_COUNT)}`);
+console.log(`總獎金           : ${formatCurrency(sim.totalReward)}`);
+console.log(`模擬期望值 (EV)   : ${simEV.toFixed(2)}`);
+console.log(`模擬 RTP          : ${simRTP.toFixed(2)}% (95% CI: ±${rtpMargin.toFixed(2)}%)`);
+console.log(`命中率           : ${simHitRate.toFixed(2)}%`);
+console.log(`最大單次獎金      : ${sim.maxWin}`);
+console.log(`誤差 (Sim - Theo) : ${(simRTP - theo.rtp).toFixed(2)}%`);
+console.log("\n==========================================");
+console.log("           獎金分布比較 (Distribution)     ");
+console.log("==========================================");
+console.log(`| 獎金   | 理論機率    | 模擬頻率    | 模擬次數  |`);
+console.log(`|--------|------------|------------|----------|`);
+// 取得理論和模擬中的所有唯一獎金，以確保表格完整
+// Get all unique rewards from both theoretical and simulation to ensure complete table
+const allRewards = Array.from(new Set([
+    ...Object.keys(theo.hitProbabilities).map(Number),
+    ...Object.keys(sim.hitFrequency).map(Number),
+])).sort((a, b) => a - b);
+for (const reward of allRewards) {
+    const theoProb = (theo.hitProbabilities[reward] || 0) * 100;
+    const simCount = sim.hitFrequency[reward] || 0;
+    const simProb = (simCount / SIMULATION_COUNT) * 100;
+    console.log(`| ${reward.toString().padEnd(6)} | ${formatPct(theoProb).padEnd(10)} | ${formatPct(simProb).padEnd(10)} | ${simCount.toString().padStart(8)} |`);
+}
+console.log("==========================================");

package/dist/types/index.d.ts

@@ -7,5 +7,5 @@ export type Payout = {
     id: string;
     pattern_id: Pattern["id"];
     match_count: number;
-    reward: number;
+    multiplier: number;
 };

package/package.json

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

package/src/labag.ts

@@ -11,16 +11,18 @@ export class LaBaG {
     this.reels = [patterns[0], patterns[1], patterns[2]];
     this.payouts = payouts;
   }
-  spin() {
+  spin(bet: number): { reels: Pattern[]; reward: number; multiplier: number } {
     this.reels = [
       this.randomPattern(),
       this.randomPattern(),
       this.randomPattern(),
     ];
-    const reward = this.caculateReward(this.reels);
+    const multiplier = this.calculateMultiplier(this.reels);
+    const reward = bet * multiplier;
     return {
       reels: this.reels,
       reward,
+      multiplier,
     };
   }
 
@@ -40,17 +42,18 @@ export class LaBaG {
     throw new Error("No pattern found");
   }
 
-  caculateReward(reels: Pattern[]): number {
+  calculateMultiplier(reels: Pattern[]): number {
     const patternCounts: { [key: string]: number } = {};
     for (const pattern of reels) {
       patternCounts[pattern.id] = (patternCounts[pattern.id] || 0) + 1;
     }
-    let totalReward = 0;
+
+    let totalMultiplier = 0;
     for (const payout of this.payouts) {
       if (patternCounts[payout.pattern_id] === payout.match_count) {
-        totalReward += payout.reward;
+        totalMultiplier += payout.multiplier;
       }
     }
-    return totalReward;
+    return totalMultiplier;
   }
 }

package/src/test.ts

@@ -1,26 +1,217 @@
 import { LaBaG } from "./labag";
+import { Pattern, Payout } from "./types";
 
-const patterns = [
-  { id: "A", weight: 50 , image: "A.png"},
-  { id: "B", weight: 30 , image: "B.png"},
-  { id: "C", weight: 20 , image: "C.png"},
+// --- 設定 (Configuration) ---
+const BET_AMOUNT = 200;
+const SIMULATION_COUNT = 1_000_000;
+
+// --- 資料定義 (Data Definitions) ---
+const patterns: Pattern[] = [
+  {
+    id: 1,
+    weight: 36,
+    image:
+      "https://fanyu.vercel.app/api/album/item/1mDK1ewfLiV3fAB1HbjvwdSaDTdJdBGG3",
+  },
+  {
+    id: 2,
+    weight: 24,
+    image:
+      "https://fanyu.vercel.app/api/album/item/1oB-uZhPPfjfTtG4CITnb3_E-Ops9JTA0",
+  },
+  {
+    id: 3,
+    weight: 17,
+    image:
+      "https://fanyu.vercel.app/api/album/item/1bMJdRB8uerQZfGYINzBI9Vaw32bZljl2",
+  },
+  {
+    id: 4,
+    weight: 12,
+    image:
+      "https://fanyu.vercel.app/api/album/item/1In8LF1wVfLXpPkp57a20zX84QgsAeLQx",
+  },
+  {
+    id: 5,
+    weight: 8,
+    image:
+      "https://fanyu.vercel.app/api/album/item/1Zo_PjrXm-4TBrL2cLAeFkEl1el9kTR56",
+  },
+  {
+    id: 6,
+    weight: 3,
+    image:
+      "https://fanyu.vercel.app/api/album/item/19NMnVgcb-9IsknNcfe9TpCyPBIcGnhQU",
+  },
 ];
 
-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 payouts: Payout[] = [
+  { id: 1, match_count: 2, pattern_id: 1, reward: 56 },
+  { id: 2, match_count: 3, pattern_id: 1, reward: 242 },
+  { id: 3, match_count: 2, pattern_id: 2, reward: 119 },
+  { id: 4, match_count: 3, pattern_id: 2, reward: 578 },
+  { id: 5, match_count: 2, pattern_id: 3, reward: 266 },
+  { id: 6, match_count: 3, pattern_id: 3, reward: 1345 },
+  { id: 7, match_count: 2, pattern_id: 4, reward: 571 },
+  { id: 8, match_count: 3, pattern_id: 4, reward: 3503 },
+  { id: 9, match_count: 2, pattern_id: 5, reward: 2136 },
+  { id: 10, match_count: 3, pattern_id: 5, reward: 11727 },
+  { id: 11, match_count: 2, pattern_id: 6, reward: 18708 },
+  { id: 12, match_count: 3, pattern_id: 6, reward: 182200 },
 ];
 
-const labag = new LaBaG(patterns, payouts);
+// --- 輔助函式 (Helpers) ---
+
+/**
+格式化數字為貨幣或百分比 (Format numbers as currency or percentage)
+*/
+const formatCurrency = (val: number) =>
+  new Intl.NumberFormat("en-US", {
+    style: "decimal",
+    minimumFractionDigits: 0,
+  }).format(val);
+
+/**
+ * 格式化百分比
+ */
+const formatPct = (val: number) => `${val.toFixed(4)}%`;
+
+/**
+ * 根據圖案和賠率計算理論統計數據。
+ * 假設滾輪獨立且賠率條件互斥（例如每次旋轉只有一種賠彩）。
+ */
+function calculateTheoreticalStats(
+  patterns: Pattern[],
+  payouts: Payout[],
+  bet: number,
+) {
+  const totalWeight = patterns.reduce((sum, p) => sum + p.weight, 0);
+  let ev = 0;
+  let varianceSum = 0; // E[X^2]
+  const hitProbabilities: Record<number, number> = {};
+
+  for (const payout of payouts) {
+    const pattern = patterns.find((p) => p.id === payout.pattern_id);
+    if (!pattern) continue;
+
+    const p = pattern.weight / totalWeight;
+    // 二項分布概率計算特定圖案數量 (假設 3 個滾輪)
+    // Binomial probability for specific pattern count (assuming 3 reels)
+    // k=3: p^3
+    // k=2: C(3,2) * p^2 * (1-p) = 3 * p^2 * (1-p)
+    const prob =
+      payout.match_count === 3 ? Math.pow(p, 3) : 3 * Math.pow(p, 2) * (1 - p);
+
+    ev += prob * payout.reward;
+    // 假設賠率互斥: E[X^2] = sum(prob * reward^2)
+    // Assuming disjoint payouts: E[X^2] = sum(prob * reward^2)
+    varianceSum += prob * Math.pow(payout.reward, 2);
+
+    hitProbabilities[payout.reward] =
+      (hitProbabilities[payout.reward] || 0) + prob;
+  }
+
+  const variance = varianceSum - Math.pow(ev, 2);
+  const stdDev = Math.sqrt(variance);
+  const rtp = (ev / bet) * 100;
+
+  return { ev, rtp, stdDev, hitProbabilities };
+}
+
+// --- 模擬邏輯 (Simulation Logic) ---
+function runSimulation(game: LaBaG, count: number) {
+  let totalReward = 0;
+  let winCount = 0;
+  let maxWin = 0;
+  const hitFrequency: Record<number, number> = {};
+
+  for (let i = 0; i < count; i++) {
+    const result = game.spin();
+    totalReward += result.reward;
+
+    if (result.reward > 0) {
+      winCount++;
+      if (result.reward > maxWin) maxWin = result.reward;
+      hitFrequency[result.reward] = (hitFrequency[result.reward] || 0) + 1;
+    }
+  }
+
+  return {
+    totalReward,
+    winCount,
+    maxWin,
+    hitFrequency,
+  };
+}
+
+// --- 主要執行區塊 (Main Execution) ---
+
+// 1. 理論分析 (Theoretical Analysis)
+console.log("正在計算理論數值...");
+const theo = calculateTheoreticalStats(patterns, payouts, BET_AMOUNT);
+
+console.log("==========================================");
+console.log("           理論分析 (Theoretical)          ");
+console.log("==========================================");
+console.log(`理論期望值 (EV) : ${theo.ev.toFixed(2)}`);
+console.log(`理論 RTP        : ${theo.rtp.toFixed(2)}%`);
+console.log(`標準差 (SD)     : ${theo.stdDev.toFixed(2)}`);
+console.log("------------------------------------------");
+
+// 2. 模擬 (Simulation)
+console.log(`\n正在執行模擬 (n=${formatCurrency(SIMULATION_COUNT)})...`);
+const game = new LaBaG(patterns, payouts);
+const sim = runSimulation(game, SIMULATION_COUNT);
+
+const simEV = sim.totalReward / SIMULATION_COUNT;
+const simRTP = (simEV / BET_AMOUNT) * 100;
+const simHitRate = (sim.winCount / SIMULATION_COUNT) * 100;
+
+// RTP 的信賴區間 (95% CI): 平均值 +/- 1.96 * (標準差 / sqrt(N))
+// 標準誤差 (Standard Error) = 標準差 / sqrt(模擬次數)
+const standardError = theo.stdDev / Math.sqrt(SIMULATION_COUNT);
+// 信賴區間的邊際誤差 (Margin of Error) = 1.96 * 標準誤差
+const marginOfError = 1.96 * standardError;
+// RTP 的誤差百分比 = (邊際誤差 / 投注金額) * 100
+const rtpMargin = (marginOfError / BET_AMOUNT) * 100;
+
+console.log("==========================================");
+console.log("           模擬結果 (Simulation)          ");
+console.log("==========================================");
+console.log(
+  `總投注           : ${formatCurrency(BET_AMOUNT * SIMULATION_COUNT)}`,
+);
+console.log(`總獎金           : ${formatCurrency(sim.totalReward)}`);
+console.log(`模擬期望值 (EV)   : ${simEV.toFixed(2)}`);
+console.log(
+  `模擬 RTP          : ${simRTP.toFixed(2)}% (95% CI: ±${rtpMargin.toFixed(2)}%)`,
+);
+console.log(`命中率           : ${simHitRate.toFixed(2)}%`);
+console.log(`最大單次獎金      : ${sim.maxWin}`);
+console.log(`誤差 (Sim - Theo) : ${(simRTP - theo.rtp).toFixed(2)}%`);
+
+console.log("\n==========================================");
+console.log("           獎金分布比較 (Distribution)     ");
+console.log("==========================================");
+console.log(`| 獎金   | 理論機率    | 模擬頻率    | 模擬次數  |`);
+console.log(`|--------|------------|------------|----------|`);
+
+// 取得理論和模擬中的所有唯一獎金，以確保表格完整
+// Get all unique rewards from both theoretical and simulation to ensure complete table
+const allRewards = Array.from(
+  new Set([
+    ...Object.keys(theo.hitProbabilities).map(Number),
+    ...Object.keys(sim.hitFrequency).map(Number),
+  ]),
+).sort((a, b) => a - b);
+
+for (const reward of allRewards) {
+  const theoProb = (theo.hitProbabilities[reward] || 0) * 100;
+  const simCount = sim.hitFrequency[reward] || 0;
+  const simProb = (simCount / SIMULATION_COUNT) * 100;
 
-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(
+    `| ${reward.toString().padEnd(6)} | ${formatPct(theoProb).padEnd(10)} | ${formatPct(simProb).padEnd(10)} | ${simCount.toString().padStart(8)} |`,
+  );
 }
-console.log("Total Reward:", totalReward);
+console.log("==========================================");

package/src/types/index.ts

@@ -8,5 +8,5 @@ export type Payout = {
   id: string;
   pattern_id: Pattern["id"];
   match_count: number;
-  reward: number;
+  multiplier: number;
 };