labag 1.0.0

package/src/index.ts

@@ -0,0 +1,143 @@
+import PDatas from "@/json/PDatas.json";
+import { P, PData } from "@/types/P";
+import { LaBaG } from "./types/LaBaG";
+import { Mode, ModeNames } from "./types/Mode";
+import { RandInt } from "./utils/RandInt";
+import { PlayLaBaG } from "./types/PlayLaBaG";
+import { JsonLaBaG } from "./types/JsonLaBaG";
+
+Object.values(PDatas).forEach((Pdata: PData) => {
+  new P(Pdata.code, Pdata.scores, Pdata.rates);
+});
+const Modes: Record<Exclude<ModeNames, "Normal">, Mode> = {
+  // 超級阿禾
+  SuperHHH: {
+    InMode: false,
+    Rate: 15,
+    Times: 0,
+    Score: 0,
+    RandNum: 0,
+    Random(): void {
+      this.RandNum = RandInt();
+    },
+    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;
+
+        if (Game.Ps.every((p) => p?.Code === "B")) {
+          this.Times += 2;
+        }
+        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 (Game.Ps.every((p) => p?.Code === "B")) {
+            this.Score = Math.round((Game.Score * Game.ScoreTime) / 2);
+            Game.MarginScore += this.Score;
+          }
+        }
+      }
+    },
+  },
+
+  GreenWei: {
+    InMode: false,
+    Rate: 35,
+    Times: 0,
+    Score: 0, // 咖波累積數
+    RandNum: 0,
+    Random(): void {
+      this.RandNum = RandInt();
+    },
+    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;
+        }
+        if (this.Times <= 0) {
+          this.InMode = false;
+          Game.JudgeMode();
+          Game.ModeToScreen = true;
+        }
+      } 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;
+          }
+          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;
+          }
+          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;
+        }
+      }
+    },
+  },
+};
+
+export { LaBaG, PlayLaBaG, JsonLaBaG, Modes, ModeNames, P, PData, PDatas };

package/src/json/PDatas.json

@@ -0,0 +1,38 @@
+{
+  "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]
+  }
+}

package/src/types/JsonLaBaG.ts

@@ -0,0 +1,70 @@
+import { P } from "./P";
+import { BaseLaBaG } from "./LaBaG";
+import { Modes } from "..";
+
+export class JsonLaBaG extends BaseLaBaG {
+  jsonData: BaseLaBaG["AllData"];
+  dataIndex: number;
+  constructor() {
+    super();
+    this.jsonData = {};
+    this.dataIndex = 0;
+  }
+
+  SetupData(data: BaseLaBaG["AllData"]): void {
+    this.jsonData = data;
+  }
+
+  Reset(): void {
+    super.Reset();
+    this.dataIndex = 0;
+  }
+
+  Random(): void {
+    const currData = this.jsonData[this.dataIndex];
+    if (!currData) {
+      super.Random();
+      return;
+    }
+
+    try {
+      const RandNums: [number, number, number] = [
+        currData["RandNum[0]"] ?? 0,
+        currData["RandNum[1]"] ?? 0,
+        currData["RandNum[2]"] ?? 0,
+      ];
+
+      Modes.SuperHHH.RandNum = currData["SuperHHH"] ?? 0;
+      Modes.GreenWei.RandNum = currData["GreenWei"] ?? 0;
+
+      const RateRange = this.RateRanges[this.NowMode()];
+      const PCodes = Object.keys(P.Obj);
+
+      RandNums.forEach((RandNum, i) => {
+        const code = PCodes.find((_, j) => RandNum <= RateRange[j]);
+        if (code) {
+          this.Ps[i] = P.Obj[code];
+        }
+      });
+
+      // 累積 GreenWei 分數
+      this.Ps.forEach((p) => {
+        if (
+          p?.Code === "A" &&
+          Modes.GreenWei.Score !== undefined &&
+          Modes.GreenWei.Score < 20
+        ) {
+          Modes.GreenWei.Score += 1;
+        }
+      });
+    } catch (error) {
+      console.error("Error in Random():", error);
+      super.Random();
+    }
+  }
+
+  Result(): void {
+    super.Result();
+    this.dataIndex++;
+  }
+}

package/src/types/LaBaG.ts

@@ -0,0 +1,221 @@
+import { P } from "@/types/P";
+import { Mode, ModeNames } from "@/types/Mode";
+import { RandInt } from "../utils/RandInt";
+import { Modes } from "..";
+
+export interface LaBaG {
+  AllData: Record<string, Record<string, number>>;
+  OneData: Record<string, number>;
+  DataIndex: number;
+
+  Times: number;
+  Played: number;
+
+  Score: number;
+  MarginScore: number;
+
+  Ps: [P | null, P | null, P | null];
+
+  RateRanges: Record<ModeNames, number[]>;
+  ScoreTimes: Record<ModeNames, number>;
+  ScoreTime: number;
+
+  ModeToScreen: boolean;
+
+  GameRunning(): boolean;
+  NowMode(): ModeNames;
+  Reset(): void;
+  Random(): void;
+  CalculateScore(): void;
+  Result(): void;
+  JudgeMode(): void;
+  Logic(): void;
+}
+
+export class BaseLaBaG implements LaBaG {
+  AllData: Record<string, Record<string, number>> = {};
+  OneData: Record<string, number> = {};
+  DataIndex: number = 0;
+
+  Times: number = 30;
+  Played: number = 0;
+
+  Score: number = 0;
+  MarginScore: number = 0;
+
+  Ps: [P | null, P | null, P | null] = [null, null, null];
+
+  RateRanges: Record<ModeNames, number[]> = [
+    "Normal",
+    "SuperHHH",
+    "GreenWei",
+    "PiKaChu",
+  ].reduce((Ranges: Record<ModeNames, number[]>, mode: string) => {
+    const res: number[] = [];
+    let accRate: number = 0;
+    for (const p of Object.values(P.Obj)) {
+      accRate += p.Rates[mode as ModeNames];
+      res.push(accRate);
+    }
+    Ranges[mode as ModeNames] = res;
+    return Ranges;
+  }, {} as Record<ModeNames, number[]>);
+
+  ScoreTimes: Record<ModeNames, number> = {
+    Normal: 1,
+    SuperHHH: 1,
+    GreenWei: 3,
+    PiKaChu: 1,
+  };
+  ScoreTime: number = 1;
+
+  ModeToScreen: boolean = false;
+
+  constructor() {}
+
+  GameRunning(): boolean {
+    //遊戲進行
+    return this.Times > this.Played;
+  }
+
+  NowMode(): ModeNames {
+    // 查找當前模式
+    const mode = Object.entries(Modes).find(
+      ([_, mode]: [string, Mode]) => mode.InMode ?? false
+    );
+    return mode ? (mode[0] as ModeNames) : "Normal";
+  }
+
+  Reset() {
+    // 重置
+    this.AllData = {};
+    this.DataIndex = 0;
+
+    this.Played = 0;
+    this.Score = 0;
+    this.MarginScore = 0;
+    this.ScoreTime = 1;
+
+    this.Ps = [null, null, null];
+
+    Object.values(Modes).forEach((mode: Mode) => {
+      if (mode.InMode !== undefined) mode.InMode = false;
+      if (mode.Score !== undefined) mode.Score = 0;
+      if (mode.RandNum !== undefined) mode.RandNum = 0;
+      if (mode.Times !== undefined) mode.Times = 0;
+    });
+  }
+
+  Random(): void {
+    const RandNums: [number, number, number] = Array.from({ length: 3 }, () =>
+      RandInt()
+    ) as [number, number, number];
+
+    RandNums.forEach((RandNum: number, index: number) => {
+      this.OneData[`RandNums[${index}]`] = RandNum;
+    });
+
+    Object.values(Modes).forEach((mode: Mode) => {
+      mode.Random?.();
+    });
+    this.OneData["SuperHHH"] = Modes.SuperHHH.RandNum as number;
+    this.OneData["GreenWei"] = Modes.GreenWei.RandNum as number;
+
+    const RateRange: number[] = this.RateRanges[this.NowMode()];
+    const PCodes: string[] = Object.keys(P.Obj);
+    RandNums.forEach((RandNum: number, i: number) => {
+      const code = PCodes.find((_, j: number) => RandNum <= RateRange[j]);
+      if (code) {
+        this.Ps[i] = P.Obj[code];
+      }
+    });
+
+    // 累積咖波累積數
+    this.Ps.forEach((p) => {
+      if (Modes.GreenWei.Score !== undefined) {
+        if (p?.Code === "A" && Modes.GreenWei.Score < 20) {
+          Modes.GreenWei.Score += 1;
+        }
+      }
+    });
+  }
+  CalculateScore(): void {
+    //計算分數
+    const UniqueCount: number = new Set(this.Ps.map((p) => p?.Code)).size;
+    switch (UniqueCount) {
+      case 1: // 三個一樣
+        this.MarginScore += this.Ps[0]?.Scores?.[0] as number;
+        break;
+      case 2: // 兩個一樣
+        if (this.Ps[0]?.Code === this.Ps[1]?.Code) {
+          this.MarginScore += this.Ps[0]?.Scores?.[1] as number;
+          this.MarginScore += this.Ps[2]?.Scores?.[2] as number;
+          this.MarginScore = Math.round(this.MarginScore / 1.4);
+        } else if (this.Ps[1]?.Code === this.Ps[2]?.Code) {
+          this.MarginScore += this.Ps[1]?.Scores?.[1] as number;
+          this.MarginScore += this.Ps[0]?.Scores?.[2] as number;
+          this.MarginScore = Math.round(this.MarginScore / 1.4);
+        } else if (this.Ps[2]?.Code === this.Ps[0]?.Code) {
+          this.MarginScore += this.Ps[2]?.Scores?.[1] as number;
+          this.MarginScore += this.Ps[1]?.Scores?.[2] as number;
+          this.MarginScore = Math.round(this.MarginScore / 1.4);
+        }
+        break;
+      case 3: // 三個不一樣
+        this.MarginScore += this.Ps[0]?.Scores?.[2] as number;
+        this.MarginScore += this.Ps[1]?.Scores?.[2] as number;
+        this.MarginScore += this.Ps[2]?.Scores?.[2] as number;
+        this.MarginScore = Math.round(this.MarginScore / 3);
+        break;
+    }
+
+    // 根據當前模式更新加分倍數
+    this.ScoreTime = this.ScoreTimes[this.NowMode()];
+    this.MarginScore *= this.ScoreTime;
+  }
+  Result(): void {
+    // 結果
+    this.Played += 1;
+    this.DataIndex += 1;
+    this.Score += this.MarginScore;
+    this.AllData[`${this.DataIndex}`] = this.OneData;
+  }
+  JudgeMode(): void {
+    if (!this.GameRunning()) {
+      Modes.PiKaChu.Judge?.(this);
+      return;
+    }
+
+    const mode: ModeNames = this.NowMode();
+    switch (mode) {
+      case "Normal":
+      case "PiKaChu":
+        Modes.SuperHHH.Judge?.(this);
+        if (!Modes.SuperHHH.InMode) {
+          Modes.GreenWei.Judge?.(this);
+        }
+        break;
+      case "SuperHHH":
+        Modes.SuperHHH.Judge?.(this);
+        break;
+      case "GreenWei":
+        Modes.GreenWei.Judge?.(this);
+        break;
+    }
+  }
+  Logic(): void {
+    // 邏輯流程
+    this.Reset();
+    while (this.GameRunning()) {
+      this.ModeToScreen = false;
+      this.OneData = {};
+
+      this.MarginScore = 0;
+
+      this.Random();
+      this.CalculateScore();
+      this.Result();
+      this.JudgeMode();
+    }
+  }
+}

package/src/types/Mode.ts

@@ -0,0 +1,13 @@
+import { LaBaG } from "./LaBaG";
+
+export type Mode = {
+  InMode?: boolean;
+  Rate?: number;
+  Times?: number;
+  Score?: number;
+  RandNum?: number;
+  Random?: () => void;
+  Judge?: (Game: LaBaG) => void;
+};
+
+export type ModeNames = "Normal" | "GreenWei" | "SuperHHH" | "PiKaChu";

package/src/types/P.ts

@@ -0,0 +1,34 @@
+import { ModeNames } from "./Mode";
+
+export type PData = {
+  name: string;
+  code: string;
+  rates: Record<ModeNames, number>;
+  scores: [number, number, number];
+};
+
+export class P {
+  static Obj: Record<string, P> = {};
+
+  Code: string | null;
+  Scores: [number, number, number];
+  Rates: Record<ModeNames, number>;
+  constructor(
+    Code: string | null = null,
+    Scores: [number, number, number] = [0, 0, 0],
+    Rates: Record<ModeNames, number> = {
+      Normal: 0,
+      SuperHHH: 0,
+      GreenWei: 0,
+      PiKaChu: 0,
+    }
+  ) {
+    this.Code = Code;
+    this.Scores = Scores;
+    this.Rates = Rates;
+
+    if (this.Code && !P.Obj[this.Code]) {
+      P.Obj[this.Code] = this;
+    }
+  }
+}

package/src/types/PlayLaBaG.ts

@@ -0,0 +1,80 @@
+import { Modes } from "..";
+import { BaseLaBaG } from "./LaBaG";
+import { ModeNames } from "./Mode";
+
+export class PlayLaBaG extends BaseLaBaG {
+  Reset(): void {
+    super.Reset();
+    console.log("遊戲已重置");
+  }
+
+  Random(): void {
+    super.Random();
+    console.log(`機率區間: ${this.RateRanges[this.NowMode()]}`);
+    console.log(`超級阿禾隨機數為: ${Modes.SuperHHH.RandNum}`);
+    console.log(`綠光阿瑋隨機數為: ${Modes.GreenWei.RandNum}`);
+    console.log(`咖波累積數：${Modes.GreenWei.Score}`);
+  }
+
+  CalculateScore(): void {
+    super.CalculateScore();
+    console.log(`加分倍數: ${this.ScoreTime}`);
+  }
+
+  Result(): void {
+    super.Result();
+    console.log("");
+    console.log(
+      `| ${this.Ps[0]?.Code} | ${this.Ps[1]?.Code} | ${this.Ps[2]?.Code} |`
+    );
+    console.log(`+ ${this.MarginScore}`);
+    console.log(`目前分數: ${this.Score}`);
+    console.log(`剩餘次數: ${this.Times - this.Played}`);
+  }
+
+  JudgeMode(): void {
+    super.JudgeMode();
+    const mode: ModeNames = this.NowMode();
+    switch (mode) {
+      case "SuperHHH":
+        if (this.ModeToScreen) {
+          console.log("超級阿禾出現");
+          if (Modes.SuperHHH.Score !== 0) {
+            console.log(`(超級阿禾加倍分: ${Modes.SuperHHH.Score})`);
+          }
+        } else {
+          if (this.Ps.every((p) => p?.Code === "B")) {
+            console.log("全阿禾，次數不消耗且+1！");
+          }
+        }
+        console.log(`超級阿禾剩餘次數:${Modes.SuperHHH.Times}次`);
+        break;
+      case "GreenWei":
+        if (this.ModeToScreen) {
+          console.log("綠光阿瑋出現");
+        } else {
+          if (this.Ps.every((p) => p?.Code === "A")) {
+            console.log("全咖波，次數不消耗！");
+          }
+        }
+        console.log(`綠光阿瑋剩餘次數:${Modes.GreenWei.Times}次`);
+        break;
+      case "PiKaChu":
+        if (this.ModeToScreen) {
+          console.log("皮卡丘為你充電");
+          console.log(`已觸發 ${Modes.PiKaChu.Times} 次皮卡丘充電`);
+        }
+        break;
+    }
+  }
+
+  Logic(): void {
+    this.ModeToScreen = false;
+    this.OneData = {};
+    this.MarginScore = 0;
+    this.Random();
+    this.CalculateScore();
+    this.Result();
+    this.JudgeMode();
+  }
+}

package/src/types/declaration.d.ts

@@ -0,0 +1,5 @@
+declare module "@/json/PDatas.json" {
+  import { PData } from "@/types/P";
+  const value: Record<string, PData>;
+  export default value;
+}

package/src/utils/RandInt.ts

@@ -0,0 +1,5 @@
+export function RandInt(): number {
+  const min: number = 1;
+  const max: number = 100;
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}