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

package/src/logic/handlers/free-spins-bonus.handler.ts

@@ -0,0 +1,119 @@
+import {
+  BonnysFortunePrivateState,
+  BonnysFortunePublicState,
+  BonusRoundResult,
+  FreeSpinResult,
+  SpinResultResponse,
+  SpinType,
+} from '../bonnys-fortune.types';
+
+import { BonnysFortuneGameLogicConfigInterface } from '../game-logic-config.interface';
+import { BonnysFortuneSpinGenerator } from '../bonnys-fortune.spin-generator';
+import { BonnysFortuneWinCalculator } from '../bonnys-fortune.win-calculator';
+import { GameSpinInputDto } from '../../domain/types/game-spin-input.dto';
+import { NumberHelper } from '../../helpers/number-helper';
+import { ReelStripsConfig } from '../../domain/reel-strips-config';
+import { RngService } from '../../rng/rng-service';
+
+export class FreeSpinsBonusHandler {
+  constructor(private rngService: RngService) {}
+
+  public async generateFullBonusRound(
+    params: GameSpinInputDto,
+    publicState: BonnysFortunePublicState,
+    privateState: BonnysFortunePrivateState,
+    config: BonnysFortuneGameLogicConfigInterface,
+    reelStripsConfig: ReelStripsConfig,
+    commandId: string,
+  ): Promise<BonusRoundResult<FreeSpinResult>> {
+    const betStake = this.getBetStake(params, config);
+    const spinGenerator = new BonnysFortuneSpinGenerator(this.rngService);
+    const spinTypes = config.bonusGames.bonusGame2.config.spinTypes;
+    const weights = spinTypes.map((st) => st.weight);
+    const total = weights.reduce((a, b) => NumberHelper.safeSum(a, b, 2), 0);
+
+    const result = await this.rngService.getSingleNumber(
+      0,
+      total - 1,
+      commandId,
+      'free_spins_type_selection',
+    );
+    const rand = result.value;
+
+    let spinTypeIndex = 0;
+    let cumulative = 0;
+    for (let i = 0; i < weights.length; i++) {
+      cumulative += weights[i];
+      if (rand < cumulative) {
+        spinTypeIndex = i;
+        break;
+      }
+    }
+    const spinTypeConfig = spinTypes[spinTypeIndex];
+
+    const results: SpinResultResponse<FreeSpinResult>[] = [];
+    let spinsLeft = spinTypeConfig.spins;
+
+    while (spinsLeft > 0) {
+      const screen = await spinGenerator.generateScreenWithLayout(
+        reelStripsConfig,
+        spinTypeConfig.layout,
+        spinTypeConfig.reelsOptionsWeights,
+        commandId,
+        `free_spin_${spinsLeft}`,
+      );
+
+      const winResult = BonnysFortuneWinCalculator.calculateWins(
+        screen,
+        config,
+        NumberHelper.toFixedNumber(betStake, 2),
+        NumberHelper.toFixedNumber(spinTypeConfig.multiplier, 2),
+        SpinType.BONUS_GAME_2_SPIN,
+        spinTypeIndex,
+      );
+
+      results.push({
+        result: {
+          spinType: SpinType.BONUS_GAME_2_SPIN,
+          screen,
+          winResult,
+          playerWinning: NumberHelper.toFixedNumber(winResult.totalWin, 2),
+          nextSpinType:
+            spinsLeft === 1
+              ? SpinType.BASE_GAME_SPIN
+              : SpinType.BONUS_GAME_2_SPIN,
+          multiplier: NumberHelper.toFixedNumber(spinTypeConfig.multiplier, 2),
+        },
+        publicState: publicState,
+        privateState: {
+          ...privateState,
+          nextSpinType:
+            spinsLeft === 1
+              ? SpinType.BASE_GAME_SPIN
+              : SpinType.BONUS_GAME_2_SPIN,
+          activeBonus: spinsLeft === 1 ? undefined : privateState.activeBonus,
+        },
+      });
+
+      spinsLeft--;
+    }
+
+    return {
+      results,
+      publicState,
+      privateState,
+    };
+  }
+
+  private getBetStake(
+    params: GameSpinInputDto,
+    config: BonnysFortuneGameLogicConfigInterface,
+  ): number {
+    const baseBet = config.baseGame.baseGameConfig.baseBet;
+    return NumberHelper.safeDivide(
+      params.betAmount,
+      params.creditsPerLine === baseBet ? params.creditsPerLine : baseBet,
+      3,
+    );
+  }
+}

package/src/logic/handlers/steering-to-the-fortune-bonus.handler.ts

@@ -0,0 +1,118 @@
+import {
+  BonnysFortunePrivateState,
+  BonnysFortunePublicState,
+  BonusRoundResult,
+  BonusTrigger,
+  PrizeType,
+  SpinResultResponse,
+  SpinType,
+  SteeringToTheFortuneResult,
+} from '../bonnys-fortune.types';
+
+import { BonnysFortuneGameLogicConfigInterface } from '../game-logic-config.interface';
+import { GameSpinInputDto } from '../../domain/types/game-spin-input.dto';
+import { NumberHelper } from '../../helpers/number-helper';
+import { RngService } from '../../rng/rng-service';
+import { UuidHelper } from '../../helpers/uuid-helper';
+import { getSpinTypeForBonus } from './base-game.handler';
+
+export class SteeringToTheFortuneBonusHandler {
+  constructor(private rngService: RngService) {}
+
+  public async generateFullBonusRound(
+    params: GameSpinInputDto,
+    publicState: BonnysFortunePublicState,
+    privateState: BonnysFortunePrivateState,
+    config: BonnysFortuneGameLogicConfigInterface,
+    commandId: string,
+  ): Promise<BonusRoundResult<SteeringToTheFortuneResult>> {
+    const betStake = this.getBetStake(params, config);
+    const wheelResults = config.bonusGames.bonusGame3.config.wheelResults;
+
+    const selectedIndex = await this.weightedDraw(
+      wheelResults.map((w) => w.weight),
+      commandId,
+      'steering_fortune_wheel_selection',
+    );
+    const prize = wheelResults[selectedIndex];
+
+    let playerWinning = 0;
+    let nextSpinType: SpinType = SpinType.BASE_GAME_SPIN;
+    let triggeredBonus: BonusTrigger | undefined;
+
+    if (prize.type === PrizeType.MULTIPLIER) {
+      playerWinning = NumberHelper.safeMultiply(betStake, prize.value, 2);
+    } else if (prize.type === PrizeType.BONUS) {
+      triggeredBonus = {
+        bonusId: UuidHelper.generateUuid(),
+        bonusType: prize.bonusType,
+        betAmount: NumberHelper.toFixedNumber(params.betAmount, 2),
+      };
+      nextSpinType = getSpinTypeForBonus(prize.bonusType);
+    }
+
+    const results = [
+      {
+        result: {
+          spinType: SpinType.BONUS_GAME_3_SPIN,
+          playerWinning,
+          nextSpinType,
+          prizeType: prize.type,
+          prizeValue:
+            prize.type === PrizeType.MULTIPLIER ? prize.value : prize.bonusType,
+          totalMultiplier:
+            prize.type === PrizeType.MULTIPLIER ? prize.value : 0,
+          triggeredBonus,
+        },
+        publicState,
+        privateState: {
+          ...privateState,
+          nextSpinType,
+          pendingBonuses: triggeredBonus ? [triggeredBonus] : [],
+          activeBonus: undefined,
+        },
+      },
+    ];
+
+    return {
+      results,
+      publicState,
+      privateState,
+    };
+  }
+
+  private async weightedDraw(
+    weights: number[],
+    commandId: string,
+    actionId: string,
+  ): Promise<number> {
+    const sum = weights.reduce((acc, w) => NumberHelper.safeSum(acc, w, 2), 0);
+
+    const result = await this.rngService.getSingleNumber(
+      0,
+      sum - 1,
+      commandId,
+      actionId,
+    );
+    const draw = result.value;
+
+    let cumulative = 0;
+    for (let i = 0; i < weights.length; i++) {
+      cumulative = NumberHelper.safeSum(cumulative, weights[i], 2);
+      if (draw < cumulative) return i;
+    }
+    return weights.length - 1;
+  }
+
+  private getBetStake(
+    params: GameSpinInputDto,
+    config: BonnysFortuneGameLogicConfigInterface,
+  ): number {
+    const baseBet = config.baseGame.baseGameConfig.baseBet;
+    return NumberHelper.safeDivide(
+      params.betAmount,
+      params.creditsPerLine === baseBet ? params.creditsPerLine : baseBet,
+      3,
+    );
+  }
+}

package/src/logic/handlers/treasure-hunt-bonus.handler.ts

@@ -0,0 +1,232 @@
+import {
+  BonnysFortunePrivateState,
+  BonnysFortunePublicState,
+  BonusRoundResult,
+  SpinType,
+  TreasureHuntSpinResult,
+} from '../bonnys-fortune.types';
+
+import { BonnysFortuneGameLogicConfigInterface } from '../game-logic-config.interface';
+import { GameSpinInputDto } from '../../domain/types/game-spin-input.dto';
+import { NumberHelper } from '../../helpers/number-helper';
+import { RngService } from '../../rng/rng-service';
+
+export class TreasureHuntBonusHandler {
+  constructor(private rngService: RngService) {}
+
+  public async generateFullBonusRound(
+    params: GameSpinInputDto,
+    publicState: BonnysFortunePublicState,
+    privateState: BonnysFortunePrivateState,
+    config: BonnysFortuneGameLogicConfigInterface,
+    commandId: string,
+  ): Promise<BonusRoundResult<TreasureHuntSpinResult>> {
+    const betStake = this.getBetStake(params, config);
+    const {
+      stepsCount,
+      jackpotScreenCounts,
+      jackpotMultipliers,
+      winningWeights,
+    } = this.extractBonusConfig(config);
+
+    const jackpotKeys = Object.keys(jackpotMultipliers);
+    const jackpotsNo = Object.values(jackpotScreenCounts);
+    const weightsArray = Object.values(winningWeights);
+
+    const winSymbolIndex = await this.drawWinningSymbol(
+      weightsArray,
+      commandId,
+    );
+
+    const selectionsVector = Array<number>(stepsCount).fill(-1);
+
+    if (winSymbolIndex >= 0) {
+      const positions = await this.randomPositions(stepsCount, 3, commandId);
+      positions.forEach((pos) => (selectionsVector[pos] = winSymbolIndex));
+      jackpotsNo[winSymbolIndex] = NumberHelper.safeSum(
+        jackpotsNo[winSymbolIndex],
+        -3,
+        0,
+      );
+    }
+
+    await this.fillRemainingSteps(
+      selectionsVector,
+      stepsCount,
+      jackpotsNo,
+      winSymbolIndex,
+      commandId,
+    );
+
+    const selections = selectionsVector.map((idx) => jackpotKeys[idx]);
+    const multipliers = selections.map((name) => jackpotMultipliers[name]);
+
+    const results = selections.map((symbol, index) => {
+      const isFinalStep = index === stepsCount - 1;
+
+      const winningMultiplier =
+        isFinalStep && winSymbolIndex >= 0
+          ? jackpotMultipliers[jackpotKeys[winSymbolIndex]]
+          : 0;
+      const playerWinning =
+        isFinalStep && winSymbolIndex >= 0
+          ? NumberHelper.safeMultiply(betStake, winningMultiplier, 2)
+          : 0;
+
+      return {
+        result: {
+          spinType: SpinType.BONUS_GAME_1_SPIN,
+          playerWinning,
+          nextSpinType: isFinalStep
+            ? SpinType.BASE_GAME_SPIN
+            : SpinType.BONUS_GAME_1_SPIN,
+          selection: symbol,
+          multiplier: multipliers[index],
+          multiplierCounts: selections.slice(0, index + 1).reduce(
+            (acc, key) => {
+              acc[key] = (acc[key] || 0) + 1;
+              return acc;
+            },
+            {} as Record<string, number>,
+          ),
+          winningMultiplier,
+          winningCount: isFinalStep && winSymbolIndex >= 0 ? 3 : 0,
+          totalMultiplier: winningMultiplier,
+        },
+        publicState,
+        privateState: {
+          ...privateState,
+          nextSpinType: isFinalStep
+            ? SpinType.BASE_GAME_SPIN
+            : SpinType.BONUS_GAME_1_SPIN,
+          activeBonus: isFinalStep ? undefined : privateState.activeBonus,
+        },
+      };
+    });
+
+    return {
+      results,
+      publicState,
+      privateState,
+    };
+  }
+
+  private getBetStake(
+    params: GameSpinInputDto,
+    config: BonnysFortuneGameLogicConfigInterface,
+  ): number {
+    const baseBet = config.baseGame.baseGameConfig.baseBet;
+    return NumberHelper.safeDivide(
+      params.betAmount,
+      params.creditsPerLine === baseBet ? params.creditsPerLine : baseBet,
+      3,
+    );
+  }
+
+  private async drawWinningSymbol(
+    weights: number[],
+    commandId: string,
+  ): Promise<number> {
+    const total = weights.reduce(
+      (acc, w) => NumberHelper.safeSum(acc, w, 2),
+      0,
+    );
+    if (total === 0) return -1;
+
+    const result = await this.rngService.getSingleNumber(
+      0,
+      total - 1,
+      commandId,
+      'treasure_hunt_winning_symbol',
+    );
+    const draw = result.value;
+
+    let cumulative = 0;
+    for (let i = 0; i < weights.length; i++) {
+      cumulative = NumberHelper.safeSum(cumulative, weights[i], 2);
+      if (draw < cumulative) return i;
+    }
+    return -1;
+  }
+
+  private async fillRemainingSteps(
+    vector: number[],
+    stepsCount: number,
+    jackpotsNo: number[],
+    excludeSymbol: number | undefined,
+    commandId: string,
+  ) {
+    const weights: number[] = jackpotsNo.map((_, idx) =>
+      idx === excludeSymbol ? 0 : 4,
+    );
+
+    for (let i = 0; i < stepsCount; i++) {
+      if (vector[i] < 0) {
+        const symbol = await this.weightedDraw(
+          weights,
+          commandId,
+          `fill_step_${i}`,
+        );
+        vector[i] = symbol;
+        jackpotsNo[symbol] = NumberHelper.safeSum(jackpotsNo[symbol], -1, 0);
+        weights[symbol] = Math.max(0, weights[symbol] - 2);
+      }
+    }
+  }
+
+  private async weightedDraw(
+    weights: number[],
+    commandId: string,
+    actionId: string,
+  ): Promise<number> {
+    const sum = weights.reduce((acc, w) => NumberHelper.safeSum(acc, w, 2), 0);
+    if (sum === 0) return 0;
+
+    const result = await this.rngService.getSingleNumber(
+      0,
+      sum - 1,
+      commandId,
+      actionId,
+    );
+    const draw = result.value;
+
+    let cumulative = 0;
+    for (let i = 0; i < weights.length; i++) {
+      cumulative = NumberHelper.safeSum(cumulative, weights[i], 2);
+      if (draw < cumulative) return i;
+    }
+    return weights.length - 1;
+  }
+
+  private async randomPositions(
+    limit: number,
+    count: number,
+    commandId: string,
+  ): Promise<number[]> {
+    const positions = Array.from({ length: limit }, (_, i) => i);
+    const selected: number[] = [];
+    while (selected.length < count) {
+      const actionId = `random_position_${selected.length}`;
+      const result = await this.rngService.getSingleNumber(
+        0,
+        positions.length - 1,
+        commandId,
+        actionId,
+      );
+      const idx = result.value;
+      selected.push(positions.splice(idx, 1)[0]);
+    }
+    return selected;
+  }
+
+  private extractBonusConfig(config: BonnysFortuneGameLogicConfigInterface) {
+    return {
+      stepsCount: config.bonusGames.bonusGame1.config.stepsCount,
+      jackpotMultipliers:
+        config.bonusGames.bonusGame1.config.jackpotMultipliers,
+      winningWeights: config.bonusGames.bonusGame1.config.winningWeights,
+      jackpotScreenCounts:
+        config.bonusGames.bonusGame1.config.jackpotScreenCounts,
+    };
+  }
+}

package/src/rng/DummyRngClient.ts

@@ -0,0 +1,108 @@
+import {
+  RngBatchResponse,
+  RngSingleResponse,
+} from '@omnitronix/rng-client-core/dist/http/http-client.types';
+
+import { IRngClient } from './rng-client.interface';
+
+export class DummyRngClient implements IRngClient {
+  constructor() {}
+
+  getSingleNumber(
+    min: number,
+    max: number,
+    _seed?: number,
+  ): Promise<{ value: number; seed: number }> {
+    const randomValue = Math.random();
+    const result = Math.floor(randomValue * (max - min + 1)) + min;
+    return Promise.resolve({ value: result, seed: 0 });
+  }
+
+  getBatchNumbers(
+    min: number,
+    max: number,
+    count: number,
+    _seed?: number,
+  ): Promise<number[]> {
+    const results: number[] = [];
+    for (let i = 0; i < count; i++) {
+      const randomValue = Math.random();
+      const result = Math.floor(randomValue * (max - min + 1)) + min;
+      results.push(result);
+    }
+    return Promise.resolve(results);
+  }
+
+  getBatchNumbersWithSeeds(
+    min: number,
+    max: number,
+    count: number,
+    _seed?: number,
+  ): Promise<{ value: number; seed: number }[]> {
+    const results: number[] = [];
+    for (let i = 0; i < count; i++) {
+      const randomValue = Math.random();
+      const result = Math.floor(randomValue * (max - min + 1)) + min;
+      results.push(result);
+    }
+    return Promise.resolve(
+      results.map((result) => ({ value: result, seed: 0 })),
+    );
+  }
+
+  getSingleFloat(_seed?: number): Promise<RngSingleResponse> {
+    const result = Math.random();
+    return Promise.resolve({
+      id: '0',
+      seed: 0,
+      result,
+      min: 0,
+      max: 1,
+      createdAt: new Date().toISOString(),
+    });
+  }
+
+  getBatchFloats(count: number, _seed?: number): Promise<RngBatchResponse> {
+    const result: number[] = [];
+    for (let i = 0; i < count; i++) {
+      result.push(Math.random());
+    }
+    return Promise.resolve({
+      id: '0',
+      seed: 0,
+      result,
+      min: 0,
+      max: 1,
+      createdAt: new Date().toISOString(),
+    });
+  }
+
+  getRandomNumber(
+    min: number,
+    max: number,
+    _seed?: number,
+  ): Promise<RngSingleResponse> {
+    const randomValue = Math.random();
+    const result = Math.floor(randomValue * (max - min + 1)) + min;
+    return Promise.resolve({
+      id: '0',
+      seed: 0,
+      result,
+      min,
+      max,
+      createdAt: new Date().toISOString(),
+    });
+  }
+
+  getRandomFloat(_seed?: number): Promise<RngSingleResponse> {
+    const result = Math.random();
+    return Promise.resolve({
+      id: '0',
+      seed: 0,
+      result,
+      min: 0,
+      max: 1,
+      createdAt: new Date().toISOString(),
+    });
+  }
+}

package/src/rng/rng-client.factory.ts

@@ -0,0 +1,27 @@
+import { RngClient, RngClientConfig } from '@omnitronix/rng-client-core';
+
+import { DummyRngClient } from './DummyRngClient';
+import { IRngClient } from './rng-client.interface';
+
+export class RngClientFactory {
+  static create(
+    config: { metrics?: RngClientConfig['metrics'] } = {},
+  ): IRngClient {
+    const mode = process.env.RNG_CLIENT_MODE || 'external';
+    console.log('RNG_CLIENT_MODE', mode);
+
+    if (mode === 'local') {
+      return new DummyRngClient();
+    }
+
+    const rngClientConfig: RngClientConfig = {
+      serverUrl: process.env.RNG_CLIENT_URL,
+      grpcUrl: process.env.RNG_CLIENT_GRPC_URL,
+      clientMethod: process.env.RNG_CLIENT_METHOD as 'grpc' | 'rest',
+      poolingSize: parseInt(process.env.RNG_CLIENT_POOL_SIZE || '2000'),
+      metrics: config.metrics,
+    };
+
+    return new RngClient(rngClientConfig);
+  }
+}

package/src/rng/rng-client.interface.ts

@@ -0,0 +1,38 @@
+import {
+  RngBatchResponse,
+  RngSingleResponse,
+} from '@omnitronix/rng-client-core/dist/http/http-client.types';
+
+export interface IRngClient {
+  getSingleNumber(
+    min: number,
+    max: number,
+    seed?: number,
+  ): Promise<{ value: number; seed: number }>;
+
+  getBatchNumbers(
+    min: number,
+    max: number,
+    count: number,
+    seed?: number,
+  ): Promise<number[]>;
+
+  getBatchNumbersWithSeeds(
+    min: number,
+    max: number,
+    count: number,
+    seed?: number,
+  ): Promise<{ value: number; seed: number }[]>;
+
+  getSingleFloat(seed?: number): Promise<RngSingleResponse>;
+
+  getBatchFloats(count: number, seed?: number): Promise<RngBatchResponse>;
+
+  getRandomNumber(
+    min: number,
+    max: number,
+    seed?: number,
+  ): Promise<RngSingleResponse>;
+
+  getRandomFloat(seed?: number): Promise<RngSingleResponse>;
+}