@omnitronix/bonnys-fortune-game-engine 1.3.1 → 1.3.2

package/src/logic/bonnys-fortune.spin-generator.ts

@@ -0,0 +1,277 @@
+import { BonnysFortuneGameLogicConfigInterface } from './game-logic-config.interface';
+import { Reel } from '../domain/reel';
+import { ReelStripsConfig } from '../domain/reel-strips-config';
+import { RngService } from '../rng/rng-service';
+
+export class BonnysFortuneSpinGenerator {
+  constructor(private readonly rngService: RngService) {}
+
+  public async generateScreenWithLayout(
+    reelStripsConfig: ReelStripsConfig,
+    layout: { reels: number; rows: number },
+    optionWeights: number[],
+    commandId: string,
+    actionId: string,
+  ): Promise<number[][]> {
+    const { reels, rows } = layout;
+
+    const selectedOptionIndex = await this.selectReelOption(
+      optionWeights,
+      commandId,
+      `${actionId}_reel_option_selection`,
+    );
+
+    return Promise.all(
+      Array.from({ length: reels }, async (_, reelIndex) =>
+        this.drawReelColumn(
+          reelStripsConfig.getReel(reelIndex),
+          rows,
+          selectedOptionIndex,
+          commandId,
+          actionId,
+          reelIndex,
+        ),
+      ),
+    );
+  }
+
+  public async generateBaseScreen(
+    config: BonnysFortuneGameLogicConfigInterface,
+    reelStripsConfig: ReelStripsConfig,
+    commandId: string,
+    actionId: string,
+  ): Promise<number[][]> {
+    const { reels, rows } = config.baseGame.baseGameConfig.layout;
+    const optionWeights =
+      config.baseGame.baseGameConfig.reelsOptions.optionWeights;
+
+    const selectedOptionIndex = await this.selectReelOption(
+      optionWeights,
+      commandId,
+      `${actionId}_reel_option_selection`,
+    );
+
+    return Promise.all(
+      Array.from({ length: reels }, async (_, reelIndex) =>
+        this.drawReelColumn(
+          reelStripsConfig.getReel(reelIndex),
+          rows,
+          selectedOptionIndex,
+          commandId,
+          actionId,
+          reelIndex,
+        ),
+      ),
+    );
+  }
+
+  private async selectReelOption(
+    optionWeights: number[],
+    commandId: string,
+    actionId: string,
+  ): Promise<number> {
+    const total = optionWeights.reduce((acc, w) => acc + w, 0);
+    const result = await this.rngService.getSingleNumber(
+      0,
+      total - 1,
+      commandId,
+      actionId,
+    );
+    const rand = result.value;
+    let cumulative = 0;
+    for (let i = 0; i < optionWeights.length; i++) {
+      cumulative += optionWeights[i];
+      if (rand < cumulative) {
+        return i;
+      }
+    }
+    return optionWeights.length - 1;
+  }
+
+  private async drawReelColumn(
+    reel: Reel,
+    rowsCount: number,
+    optionIndex: number,
+    commandId: string,
+    actionId: string,
+    reelIndex: number,
+  ): Promise<number[]> {
+    const stopActionId = `${actionId}_reel_${reelIndex}_stop`;
+    const option = reel.getOption(optionIndex);
+
+    const resultStop = await this.rngService.getSingleNumber(
+      0,
+      option.length - 1,
+      commandId,
+      stopActionId,
+    );
+    const stopPos = resultStop.value;
+
+    return Array.from({ length: rowsCount }, (_, row) =>
+      option.getSymbolAt(stopPos + row),
+    );
+  }
+
+  public async applyBonusSymbols(
+    screen: number[][],
+    config: BonnysFortuneGameLogicConfigInterface,
+    commandId: string,
+    actionId: string,
+  ): Promise<number[][]> {
+    const screenCopy = screen.map((col) => [...col]);
+    const reelsCount = config.baseGame.baseGameConfig.layout.reels;
+
+    const hWeights = [
+      config.baseGame.paidHSymbolWeights.None,
+      config.baseGame.paidHSymbolWeights.H1,
+      config.baseGame.paidHSymbolWeights.H2,
+      config.baseGame.paidHSymbolWeights.H3,
+    ];
+
+    const pickedHIndex = await this.getRandomWeightedIndex(
+      hWeights,
+      commandId,
+      `${actionId}_h_symbol_selection`,
+    );
+
+    if (pickedHIndex > 0) {
+      const hName = `H${pickedHIndex}` as 'H1' | 'H2' | 'H3';
+      const hId =
+        config.baseGame.symbolMultipliers.find((s) => s.name === hName)
+          ?.symbolId ?? 0;
+      await this.placeHSymbols(
+        screenCopy,
+        reelsCount,
+        config.baseGame.paidHSymbolReelWeights,
+        hName,
+        hId,
+        commandId,
+        `${actionId}_h_symbols`,
+      );
+    } else {
+      await this.placeScatterSymbols(
+        screenCopy,
+        reelsCount,
+        config.baseGame.paidScatterReelWeights,
+        config.baseGame.symbolDefinitions.specialSymbols.SCATTER,
+        commandId,
+        `${actionId}_scatter_symbols`,
+      );
+    }
+
+    return screenCopy;
+  }
+
+  private async placeHSymbols(
+    screen: number[][],
+    reelsCount: number,
+    reelWeights: Record<string, number[]>,
+    symbolName: 'H1' | 'H2' | 'H3',
+    symbolId: number,
+    commandId: string,
+    actionId: string,
+  ): Promise<void> {
+    const result = await this.rngService.getSingleNumber(
+      0,
+      reelsCount - 1,
+      commandId,
+      `${actionId}_guaranteed_reel`,
+    );
+    const guaranteedReel = result.value;
+    await this.placeSymbolRandomlyOnReel(
+      screen,
+      guaranteedReel,
+      symbolId,
+      commandId,
+      `${actionId}_guaranteed_placement`,
+    );
+
+    for (let reel = 0; reel < reelsCount; reel++) {
+      if (reel === guaranteedReel) continue;
+      const weights = reelWeights[symbolName];
+      if (
+        weights &&
+        (await this.getRandomWeightedIndex(
+          weights,
+          commandId,
+          `${actionId}_reel_${reel}_weighted`,
+        )) === 0
+      ) {
+        await this.placeSymbolRandomlyOnReel(
+          screen,
+          reel,
+          symbolId,
+          commandId,
+          `${actionId}_reel_${reel}_placement`,
+        );
+      }
+    }
+  }
+
+  private async placeScatterSymbols(
+    screen: number[][],
+    reelsCount: number,
+    scatterWeights: Record<string, number[]>,
+    scatterId: number,
+    commandId: string,
+    actionId: string,
+  ): Promise<void> {
+    for (let reel = 0; reel < reelsCount; reel++) {
+      const weights =
+        scatterWeights[`reel${reel + 1}` as keyof typeof scatterWeights];
+      if (
+        weights &&
+        (await this.getRandomWeightedIndex(
+          weights,
+          commandId,
+          `${actionId}_scatter_reel_${reel}`,
+        )) === 0
+      ) {
+        await this.placeSymbolRandomlyOnReel(
+          screen,
+          reel,
+          scatterId,
+          commandId,
+          `${actionId}_scatter_placement_${reel}`,
+        );
+      }
+    }
+  }
+
+  private async placeSymbolRandomlyOnReel(
+    screen: number[][],
+    reel: number,
+    symbolId: number,
+    commandId: string,
+    actionId: string,
+  ): Promise<void> {
+    const result = await this.rngService.getSingleNumber(
+      0,
+      screen[reel].length - 1,
+      commandId,
+      actionId,
+    );
+    screen[reel][result.value] = symbolId;
+  }
+
+  private async getRandomWeightedIndex(
+    weights: number[],
+    commandId: string,
+    actionId: string,
+  ): Promise<number> {
+    const total = weights.reduce((acc, w) => acc + w, 0);
+    const result = await this.rngService.getSingleNumber(
+      0,
+      total - 1,
+      commandId,
+      actionId,
+    );
+    const rand = result.value;
+    let cumulative = 0;
+    for (let i = 0; i < weights.length; i++) {
+      cumulative += weights[i];
+      if (rand < cumulative) return i;
+    }
+    return weights.length - 1;
+  }
+}

package/src/logic/bonnys-fortune.types.ts

@@ -0,0 +1,223 @@
+export interface WinLine {
+  symbol: number;
+  consecutiveReels: number;
+  ways: number;
+  multiplier: number;
+  win: number;
+  positions: [number, number][];
+}
+
+export interface MeterState {
+  symbolName: string;
+  symbolId: number;
+  threshold: number;
+  progress: number;
+  level: number;
+}
+
+export type MetersState = Record<string, MeterState>;
+
+export interface BonnysFortunePublicState {
+  currentBetAmount: number;
+  bonusMeters: MetersState;
+}
+
+export interface BonnysFortunePrivateState {
+  screen?: number[][];
+  nextSpinType: SpinType;
+  pendingBonuses: BonusTrigger[];
+  activeBonus?: BonusTrigger;
+  bonusMetersByAmount: Record<number, MetersState>;
+}
+
+export interface BonusTrigger {
+  bonusId: string;
+  bonusType: string;
+  betAmount: number;
+}
+
+export interface SpinResult {
+  spinType: string;
+  playerWinning: number;
+  nextSpinType: SpinType | string;
+}
+
+export interface SpinResultResponse<T extends SpinResult> {
+  result: T;
+  publicState: BonnysFortunePublicState;
+  privateState: BonnysFortunePrivateState;
+}
+
+export interface BonnysFortuneBaseGameSpinResult extends SpinResult {
+  spinType: SpinType.BASE_GAME_SPIN;
+  screen: number[][];
+  winResult: {
+    totalWin: number;
+    winningLines: WinLine[];
+  };
+  triggeredBonus?: BonusTrigger;
+}
+
+export interface TreasureHuntSpinResult extends SpinResult {
+  spinType: SpinType;
+  selection: string;
+  multiplier: number;
+  multiplierCounts: Record<string, number>;
+  winningMultiplier: number | null;
+  winningCount: number;
+  totalMultiplier: number;
+}
+
+export interface FreeSpinResult {
+  spinType: SpinType.BONUS_GAME_2_SPIN;
+  screen: number[][];
+  winResult: {
+    totalWin: number;
+    winningLines: WinLine[];
+  };
+  playerWinning: number;
+  nextSpinType: SpinType;
+  multiplier: number;
+}
+
+export interface SteeringToTheFortuneResult {
+  spinType: SpinType;
+  playerWinning: number;
+  nextSpinType: SpinType;
+  prizeType: string;
+  prizeValue: number | string;
+  totalMultiplier: number;
+  triggeredBonus?: BonusTrigger;
+}
+
+export interface CollectFeatureSpinResult {
+  spinIndex: number;
+  spinType: SpinType;
+  symbols: string[];
+  slashed: boolean[];
+  currentValues: number;
+  currentMultipliers: number;
+  totalValues: number;
+  totalMultipliers: number;
+  playerWinning: number;
+  totalWin: number;
+  spinsLeft: number;
+  nextSpinType: SpinType;
+}
+
+export interface BonusRoundResult<TSpin extends SpinResult> {
+  results: SpinResultResponse<TSpin>[];
+  publicState: BonnysFortunePublicState;
+  privateState: BonnysFortunePrivateState;
+}
+
+export interface BonusRoundResultWithActiveBonus<TSpin extends SpinResult>
+  extends BonusRoundResult<TSpin> {
+  activeBonus: BonusTrigger;
+}
+
+export type BonnysFortuneGameLogicSpinResult =
+  | SpinResultResponse<BonnysFortuneBaseGameSpinResult>
+  | SpinResultResponse<FreeSpinResult>
+  | SpinResultResponse<TreasureHuntSpinResult>
+  | SpinResultResponse<SteeringToTheFortuneResult>
+  | SpinResultResponse<CollectFeatureSpinResult>;
+
+export type BonnysFortuneBonusGameLogicSpinResult =
+  | BonusRoundResult<FreeSpinResult>
+  | BonusRoundResult<TreasureHuntSpinResult>
+  | BonusRoundResult<SteeringToTheFortuneResult>
+  | BonusRoundResult<CollectFeatureSpinResult>;
+
+export type StartBonusRoundResult =
+  | BonusRoundResultWithActiveBonus<FreeSpinResult>
+  | BonusRoundResultWithActiveBonus<TreasureHuntSpinResult>
+  | BonusRoundResultWithActiveBonus<SteeringToTheFortuneResult>
+  | BonusRoundResultWithActiveBonus<CollectFeatureSpinResult>;
+
+export enum SpinType {
+  BASE_GAME_SPIN = 'BASE_GAME_SPIN',
+  BONUS_GAME_1_SPIN = 'BONUS_GAME_1_SPIN',
+  BONUS_GAME_2_SPIN = 'BONUS_GAME_2_SPIN',
+  BONUS_GAME_3_SPIN = 'BONUS_GAME_3_SPIN',
+  COLLECT_FEATURE_SPIN = 'COLLECT_FEATURE_SPIN',
+}
+
+export enum PrizeType {
+  MULTIPLIER = 'MULTIPLIER',
+  BONUS = 'BONUS',
+}
+
+export interface ExtractedConfigData {
+  baseMin: number;
+  baseMax: number;
+  WILD: number;
+  reels: number;
+  rows: number;
+  minLength: number;
+  maxLength: number;
+  multipliers: Map<number, Record<string, number>>;
+}
+
+export type SymbolsCountMatrix = number[][];
+
+export type SymbolPositionsMatrix = boolean[][][];
+
+export interface SymbolAnalysisResult {
+  symbolsCount: SymbolsCountMatrix;
+  symbolPositions: SymbolPositionsMatrix;
+}
+
+export interface FindWinningLinesParams {
+  symbolsCount: SymbolsCountMatrix;
+  symbolPositions: SymbolPositionsMatrix;
+  configData: ExtractedConfigData;
+  betStake: number;
+  currentMultiplier: number;
+}
+
+export interface CalculateWinsResult {
+  totalWin: number;
+  winningLines: WinLine[];
+}
+
+export interface CheatTriggerBonusOutcome {
+  triggeredBonus: BonusTrigger;
+}
+
+export interface CheatUpdateBonusMeterProgressOutcome {
+  updatedMeter: MeterState;
+}
+
+export interface CheatTriggerBonusResult {
+  publicState: BonnysFortunePublicState;
+  privateState: BonnysFortunePrivateState;
+  outcome: CheatTriggerBonusOutcome;
+}
+
+export interface CheatUpdateBonusMeterProgressResult {
+  publicState: BonnysFortunePublicState;
+  privateState: BonnysFortunePrivateState;
+  outcome: CheatUpdateBonusMeterProgressOutcome;
+}
+
+export interface GetSymbolsOutcome {
+  symbolId: number;
+  name: string;
+  multipliers: Record<'x3' | 'x4' | 'x5', number>;
+  isWild: boolean | undefined;
+  isScatter: boolean | undefined;
+}
+
+export interface GetSymbolsResult {
+  symbols: GetSymbolsOutcome[];
+}
+
+export type BonnysFortuneOutcome =
+  | BonnysFortuneGameLogicSpinResult
+  | BonnysFortuneBonusGameLogicSpinResult
+  | SymbolsCountMatrix
+  | CheatTriggerBonusOutcome
+  | CheatUpdateBonusMeterProgressOutcome
+  | GetSymbolsOutcome
+  | null;

package/src/logic/bonnys-fortune.win-calculator.ts

@@ -0,0 +1,210 @@
+import {
+  CalculateWinsResult,
+  ExtractedConfigData,
+  FindWinningLinesParams,
+  SpinType,
+  SymbolAnalysisResult,
+  SymbolPositionsMatrix,
+  SymbolsCountMatrix,
+  WinLine,
+} from './bonnys-fortune.types';
+
+import { BonnysFortuneGameLogicConfigInterface } from './game-logic-config.interface';
+import { NumberHelper } from '../helpers/number-helper';
+
+export class BonnysFortuneWinCalculator {
+  public static calculateWins(
+    screen: number[][],
+    config: BonnysFortuneGameLogicConfigInterface,
+    betStake: number,
+    currentMultiplier: number,
+    spinType: SpinType,
+    spinTypeIndex?: number, // Index of spin type in bonus game 2 config
+  ): CalculateWinsResult {
+    if (!this.isEligibleSpin(spinType))
+      return { totalWin: 0, winningLines: [] };
+
+    const configData = this.buildConfigData(config, spinType, spinTypeIndex);
+    const { symbolsCount, symbolPositions } = this.analyzeScreenSymbols(
+      screen,
+      configData,
+    );
+
+    return this.findWinningLines({
+      symbolsCount,
+      symbolPositions,
+      configData,
+      betStake,
+      currentMultiplier,
+    });
+  }
+
+  private static isEligibleSpin(spinType: SpinType): boolean {
+    return (
+      spinType === SpinType.BASE_GAME_SPIN ||
+      spinType === SpinType.BONUS_GAME_2_SPIN
+    );
+  }
+
+  private static buildConfigData(
+    config: BonnysFortuneGameLogicConfigInterface,
+    spinType: SpinType,
+    spinTypeIndex?: number,
+  ): ExtractedConfigData {
+    const { minIndex: baseMin, maxIndex: baseMax } =
+      config.baseGame.symbolDefinitions.baseSymbols;
+    const WILD = config.baseGame.symbolDefinitions.specialSymbols.WILD;
+
+    let rows: number, reels: number, minLength: number, maxLength: number;
+
+    if (
+      spinType === SpinType.BONUS_GAME_2_SPIN &&
+      spinTypeIndex !== undefined
+    ) {
+      const spinConfig =
+        config.bonusGames.bonusGame2.config.spinTypes[spinTypeIndex];
+      rows = spinConfig.layout.rows;
+      reels = spinConfig.reelsOptionsWeights.length;
+      minLength = config.baseGame.baseGameConfig.winConfig.minLength;
+      maxLength = config.baseGame.baseGameConfig.winConfig.maxLength;
+    } else {
+      rows = config.baseGame.baseGameConfig.layout.rows;
+      reels = config.baseGame.baseGameConfig.layout.reels;
+      minLength = config.baseGame.baseGameConfig.winConfig.minLength;
+      maxLength = config.baseGame.baseGameConfig.winConfig.maxLength;
+    }
+
+    const multipliers = new Map<number, Record<string, number>>();
+    for (const symbolConfig of config.baseGame.symbolMultipliers) {
+      multipliers.set(symbolConfig.symbolId, symbolConfig.multipliers || {});
+    }
+
+    return {
+      baseMin,
+      baseMax,
+      WILD,
+      reels,
+      rows,
+      minLength,
+      maxLength,
+      multipliers,
+    };
+  }
+
+  private static analyzeScreenSymbols(
+    screen: number[][],
+    configData: ExtractedConfigData,
+  ): SymbolAnalysisResult {
+    const { baseMin, baseMax, WILD, reels, rows } = configData;
+
+    const symbolsCount: SymbolsCountMatrix = Array.from(
+      { length: baseMax - baseMin + 1 },
+      () => Array(reels).fill(0),
+    );
+
+    const symbolPositions: SymbolPositionsMatrix = Array.from(
+      { length: baseMax - baseMin + 1 },
+      () => Array.from({ length: reels }, () => Array(rows).fill(false)),
+    );
+
+    for (let reel = 0; reel < reels; reel++) {
+      for (let row = 0; row < rows; row++) {
+        const symbol = screen[reel][row];
+        if (symbol >= baseMin && symbol <= baseMax) {
+          const index = symbol - baseMin;
+          symbolsCount[index][reel]++;
+          symbolPositions[index][reel][row] = true;
+        } else if (symbol === WILD) {
+          this.markWildPositions(
+            baseMin,
+            baseMax,
+            reel,
+            row,
+            symbolsCount,
+            symbolPositions,
+          );
+        }
+      }
+    }
+
+    return { symbolsCount, symbolPositions };
+  }
+
+  private static markWildPositions(
+    baseMin: number,
+    baseMax: number,
+    reel: number,
+    row: number,
+    symbolsCount: SymbolsCountMatrix,
+    symbolPositions: SymbolPositionsMatrix,
+  ): void {
+    for (let baseSymbol = baseMin; baseSymbol <= baseMax; baseSymbol++) {
+      const index = baseSymbol - baseMin;
+      symbolsCount[index][reel]++;
+      symbolPositions[index][reel][row] = true;
+    }
+  }
+
+  private static findWinningLines({
+    symbolsCount,
+    symbolPositions,
+    configData,
+    betStake,
+    currentMultiplier,
+  }: FindWinningLinesParams): CalculateWinsResult {
+    const { baseMin, baseMax, reels, rows, minLength, maxLength, multipliers } =
+      configData;
+
+    let totalWin = 0;
+    const winningLines: WinLine[] = [];
+
+    for (let symbol = baseMin; symbol <= baseMax; symbol++) {
+      const idx = symbol - baseMin;
+      let ways = 1;
+      let consecutiveReels = 0;
+      const positions: [number, number][] = [];
+
+      for (let reel = 0; reel < reels; reel++) {
+        const countOnReel = symbolsCount[idx][reel];
+        if (countOnReel > 0) {
+          consecutiveReels++;
+          ways = NumberHelper.safeMultiply(ways, countOnReel, 6);
+          for (let row = 0; row < rows; row++) {
+            if (symbolPositions[idx][reel][row]) positions.push([reel, row]);
+          }
+        } else break;
+      }
+
+      if (consecutiveReels >= minLength && consecutiveReels <= maxLength) {
+        const multiplier =
+          multipliers.get(symbol)?.[`x${consecutiveReels}`] ?? 0;
+        if (multiplier > 0) {
+          let winAmount = ways;
+          winAmount = NumberHelper.safeMultiply(winAmount, multiplier, 6);
+          winAmount = NumberHelper.safeMultiply(winAmount, betStake, 6);
+          winAmount = NumberHelper.safeMultiply(
+            winAmount,
+            currentMultiplier,
+            6,
+          );
+          winAmount = NumberHelper.toFixedNumber(winAmount, 2);
+
+          totalWin = NumberHelper.safeSum(totalWin, winAmount, 6);
+
+          winningLines.push({
+            symbol,
+            consecutiveReels,
+            ways,
+            multiplier,
+            win: winAmount,
+            positions,
+          });
+        }
+      }
+    }
+
+    totalWin = NumberHelper.toFixedNumber(totalWin, 2);
+
+    return { totalWin, winningLines };
+  }
+}