@omnitronix/bonnys-fortune-game-engine 1.2.0 → 1.2.2

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

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

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

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

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

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

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