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

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

@@ -1,277 +0,0 @@
-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

@@ -1,223 +0,0 @@
-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

@@ -1,210 +0,0 @@
-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 };
-  }
-}