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

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

@@ -1,490 +0,0 @@
-import {
-  BonnysFortuneBaseGameSpinResult,
-  BonnysFortunePrivateState,
-  BonnysFortunePublicState,
-  BonusTrigger,
-  CheatTriggerBonusResult,
-  CheatUpdateBonusMeterProgressResult,
-  GetSymbolsResult,
-  MeterState,
-  MetersState,
-  SpinResultResponse,
-  StartBonusRoundResult,
-  SpinType,
-} from './bonnys-fortune.types';
-
-import { BaseGameHandler } from './handlers/base-game.handler';
-import {
-  BonnysFortuneGameLogicConfigInterface,
-  BonnysFortuneSessionStateInterface,
-} from './game-logic-config.interface';
-import { BonnysFortuneSpinGenerator } from './bonnys-fortune.spin-generator';
-import { CheatTriggerBonusRequestDto } from '../domain/types/cheat-trigger-bonus-request.dto';
-import { CheatUpdateBonusMeterProgressRequestDto } from '../domain/types/cheat-update-bonus-meter-progress-request.dto';
-import { CollectFeatureBonusHandler } from './handlers/collect-feature-bonus.handler';
-import { FreeSpinsBonusHandler } from './handlers/free-spins-bonus.handler';
-import { GameActionCommand } from '../game-engine.interface';
-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';
-import { StartBonusRoundInputDto } from '../domain/types/start-bonus-round-input.dto';
-import { SteeringToTheFortuneBonusHandler } from './handlers/steering-to-the-fortune-bonus.handler';
-import { TreasureHuntBonusHandler } from './handlers/treasure-hunt-bonus.handler';
-import { UuidHelper } from '../helpers/uuid-helper';
-
-export class BonnysFortuneGameLogic {
-  constructor(private readonly rngService: RngService) {}
-
-  public async initSessionState(
-    gameLogicConfig: BonnysFortuneGameLogicConfigInterface,
-    reelStripsConfig: ReelStripsConfig,
-    gameConfig: { betAmountThresholds: number[]; defaultBetAmount: number },
-    commandId: string,
-  ): Promise<BonnysFortuneSessionStateInterface> {
-    const bonusMetersByAmount: Record<number, MetersState> = {};
-
-    for (const betAmount of gameConfig.betAmountThresholds) {
-      bonusMetersByAmount[betAmount] = await this.drawBonusMeters(
-        gameLogicConfig,
-        commandId,
-        betAmount,
-      );
-    }
-
-    const initialBetAmount =
-      gameConfig.defaultBetAmount ?? gameConfig.betAmountThresholds[0];
-
-    return {
-      publicState: {
-        currentBetAmount: initialBetAmount,
-        bonusMeters: bonusMetersByAmount[initialBetAmount],
-      },
-      privateState: {
-        bonusMetersByAmount,
-        screen: await new BonnysFortuneSpinGenerator(
-          this.rngService,
-        ).generateBaseScreen(
-          gameLogicConfig,
-          reelStripsConfig,
-          commandId,
-          'init_screen',
-        ),
-        nextSpinType: SpinType.BASE_GAME_SPIN,
-        pendingBonuses: [],
-      },
-    };
-  }
-
-  public async spin(
-    params: GameSpinInputDto,
-    publicState: BonnysFortunePublicState,
-    privateState: BonnysFortunePrivateState,
-    gameLogicConfig: BonnysFortuneGameLogicConfigInterface,
-    reelStripsConfig: ReelStripsConfig,
-    commandId: string,
-  ): Promise<SpinResultResponse<BonnysFortuneBaseGameSpinResult>> {
-    return new BaseGameHandler(this.rngService).handleSpin(
-      params,
-      publicState,
-      privateState,
-      gameLogicConfig,
-      reelStripsConfig,
-      commandId,
-    );
-  }
-
-  public async startBonusRound(
-    params: StartBonusRoundInputDto,
-    publicState: BonnysFortunePublicState,
-    privateState: BonnysFortunePrivateState,
-    gameLogicConfig: BonnysFortuneGameLogicConfigInterface,
-    reelStripsConfig: ReelStripsConfig,
-    commandId: string,
-  ): Promise<StartBonusRoundResult> {
-    if (!privateState.pendingBonuses?.length) {
-      throw new Error('No pending bonuses to start.');
-    }
-
-    const [activeBonus] = privateState.pendingBonuses;
-
-    if (
-      activeBonus.bonusId !== params.bonusId ||
-      activeBonus.bonusType !== params.bonusType
-    ) {
-      throw new Error(`Invalid bonus start request: ${params.bonusType}`);
-    }
-
-    if (this.shouldRedrawMeter(activeBonus.bonusType, gameLogicConfig)) {
-      const updatedStates = await this.updateSessionState(
-        publicState,
-        privateState,
-        gameLogicConfig,
-        {
-          id: commandId,
-          type: 'START_BONUS_ROUND',
-          payload: {
-            bonusMeters: {
-              redraw: [activeBonus.bonusType],
-            },
-          },
-        },
-      );
-      publicState = updatedStates.publicState;
-      privateState = updatedStates.privateState;
-    }
-
-    const updatedPrivateState: BonnysFortunePrivateState = {
-      ...privateState,
-      pendingBonuses: privateState.pendingBonuses.filter(
-        (b) => b.bonusId !== activeBonus.bonusId,
-      ),
-      activeBonus,
-    };
-
-    switch (params.bonusType) {
-      case 'bonusGame1': {
-        const bonusHandlerResult = await new TreasureHuntBonusHandler(
-          this.rngService,
-        ).generateFullBonusRound(
-          { ...params, betAmount: activeBonus.betAmount },
-          publicState,
-          {
-            ...updatedPrivateState,
-            nextSpinType: SpinType.BONUS_GAME_1_SPIN,
-          },
-          gameLogicConfig,
-          commandId,
-        );
-
-        return {
-          ...bonusHandlerResult,
-          activeBonus,
-        };
-      }
-
-      case 'bonusGame2': {
-        const bonusHandlerResult = await new FreeSpinsBonusHandler(
-          this.rngService,
-        ).generateFullBonusRound(
-          { ...params, betAmount: activeBonus.betAmount },
-          publicState,
-          {
-            ...updatedPrivateState,
-            nextSpinType: SpinType.BONUS_GAME_2_SPIN,
-          },
-          gameLogicConfig,
-          reelStripsConfig,
-          commandId,
-        );
-
-        return {
-          ...bonusHandlerResult,
-          activeBonus,
-        };
-      }
-      case 'bonusGame3': {
-        const bonusHandlerResult = await new SteeringToTheFortuneBonusHandler(
-          this.rngService,
-        ).generateFullBonusRound(
-          { ...params, betAmount: activeBonus.betAmount },
-          publicState,
-          {
-            ...updatedPrivateState,
-            nextSpinType: SpinType.BONUS_GAME_3_SPIN,
-          },
-          gameLogicConfig,
-          commandId,
-        );
-
-        return {
-          ...bonusHandlerResult,
-          activeBonus,
-        };
-      }
-      case 'collectFeature': {
-        const bonusHandlerResult = await new CollectFeatureBonusHandler(
-          this.rngService,
-        ).generateFullBonusRound(
-          { ...params, betAmount: activeBonus.betAmount },
-          publicState,
-          {
-            ...updatedPrivateState,
-            nextSpinType: SpinType.COLLECT_FEATURE_SPIN,
-          },
-          gameLogicConfig,
-          commandId,
-        );
-
-        return {
-          ...bonusHandlerResult,
-          activeBonus,
-        };
-      }
-    }
-  }
-
-  private async drawBonusMeters(
-    gameLogicConfig: BonnysFortuneGameLogicConfigInterface,
-    commandId: string,
-    betAmount: number,
-  ): Promise<MetersState> {
-    const bonusMeters: MetersState = {};
-
-    for (const [key, cfg] of Object.entries(
-      gameLogicConfig.baseGame.bonusGameMeters,
-    )) {
-      const { value: threshold } = await this.randomThreshold(
-        cfg.min,
-        cfg.max,
-        commandId,
-        `bonus_meter_${betAmount}_${key}`,
-      );
-      const progress = 0;
-      const level = this.getMeterLevel(
-        progress,
-        threshold,
-        cfg.percentageLevels,
-      );
-
-      bonusMeters[key] = {
-        symbolName: cfg.symbol,
-        symbolId:
-          gameLogicConfig.baseGame.symbolMultipliers.find(
-            (s) => s.name === cfg.symbol,
-          )?.symbolId ?? 0,
-        threshold,
-        progress,
-        level,
-      };
-    }
-
-    return bonusMeters;
-  }
-
-  public async updateSessionState(
-    publicState: BonnysFortunePublicState,
-    privateState: BonnysFortunePrivateState,
-    gameLogicConfig: BonnysFortuneGameLogicConfigInterface,
-    command: GameActionCommand<{ bonusMeters: { redraw: string[] } }>,
-  ): Promise<BonnysFortuneSessionStateInterface> {
-    switch (command.type) {
-      case 'START_BONUS_ROUND': {
-        if (
-          !this.requiresMeterUpdate(
-            command.payload?.bonusMeters.redraw ?? [],
-            gameLogicConfig,
-          )
-        ) {
-          return { publicState, privateState };
-        }
-
-        const betAmount = publicState.currentBetAmount;
-        const bonusMetersForBetAmount = privateState.bonusMetersByAmount[betAmount];
-        
-        if (!bonusMetersForBetAmount) {
-          throw new Error(
-            `Bet amount ${betAmount} is not in allowed thresholds`,
-          );
-        }
-
-        for (const key of command.payload?.bonusMeters.redraw ?? []) {
-          const cfg =
-            gameLogicConfig.baseGame.bonusGameMeters[
-              key as keyof typeof gameLogicConfig.baseGame.bonusGameMeters
-            ];
-          const { value: threshold } = await this.randomThreshold(
-            cfg.min,
-            cfg.max,
-            command.id,
-            `bonus_meter_redraw_${key}`,
-          );
-          const progress = 0;
-          const level = this.getMeterLevel(
-            progress,
-            threshold,
-            cfg.percentageLevels,
-          );
-
-          bonusMetersForBetAmount[key] = {
-            ...bonusMetersForBetAmount[key],
-            threshold,
-            progress,
-            level,
-          };
-        }
-
-        return {
-          publicState: {
-            ...publicState,
-            bonusMeters: bonusMetersForBetAmount,
-          },
-          privateState,
-        };
-      }
-
-      default: {
-        return {
-          publicState,
-          privateState,
-        };
-      }
-    }
-  }
-
-  public cheatTriggerBonus(
-    publicState: BonnysFortunePublicState,
-    privateState: BonnysFortunePrivateState,
-    params: CheatTriggerBonusRequestDto,
-  ): CheatTriggerBonusResult {
-    const bonusTrigger: BonusTrigger = {
-      bonusId: UuidHelper.generateUuid(),
-      bonusType: params.bonusType,
-      betAmount: params.betAmount,
-    };
-
-    privateState.pendingBonuses.push(bonusTrigger);
-
-    return {
-      publicState,
-      privateState,
-      outcome: {
-        triggeredBonus: bonusTrigger,
-      },
-    };
-  }
-
-  public cheatUpdateBonusMeterProgress(
-    publicState: BonnysFortunePublicState,
-    privateState: BonnysFortunePrivateState,
-    params: CheatUpdateBonusMeterProgressRequestDto,
-    gameLogicConfig: BonnysFortuneGameLogicConfigInterface,
-  ): CheatUpdateBonusMeterProgressResult {
-    const betAmount = publicState.currentBetAmount;
-
-    const bonusMetersForBetAmount = privateState.bonusMetersByAmount[betAmount];
-    if (!bonusMetersForBetAmount) {
-      throw new Error(
-        `Bet amount ${betAmount} is not in allowed thresholds`,
-      );
-    }
-
-    const currentPrivateMeter = bonusMetersForBetAmount[params.bonusType];
-
-    if (!currentPrivateMeter) {
-      throw new Error(
-        `Bonus meter ${params.bonusType} not found for bet amount ${betAmount}`,
-      );
-    }
-
-    const meterConfig =
-      gameLogicConfig.baseGame.bonusGameMeters[
-        params.bonusType as keyof typeof gameLogicConfig.baseGame.bonusGameMeters
-      ];
-    if (!meterConfig) {
-      throw new Error(`Config for bonus meter ${params.bonusType} not found`);
-    }
-
-    const newLevel = this.getMeterLevel(
-      params.progress,
-      currentPrivateMeter.threshold,
-      meterConfig.percentageLevels,
-    );
-
-    const updatedMeter: MeterState = {
-      ...currentPrivateMeter,
-      progress: params.progress,
-      level: newLevel,
-    };
-
-    privateState.bonusMetersByAmount[betAmount] = {
-      ...bonusMetersForBetAmount,
-      [params.bonusType]: updatedMeter,
-    };
-
-    publicState = {
-      ...publicState,
-      bonusMeters: {
-        ...publicState.bonusMeters,
-        [params.bonusType]: {
-          ...publicState.bonusMeters[params.bonusType],
-          progress: params.progress,
-          level: newLevel,
-        },
-      },
-    };
-
-    return {
-      publicState,
-      privateState,
-      outcome: {
-        updatedMeter,
-      },
-    };
-  }
-
-  public getSymbols(
-    gameLogicConfig: BonnysFortuneGameLogicConfigInterface,
-  ): GetSymbolsResult {
-    const symbols = gameLogicConfig.baseGame.symbolMultipliers.map(
-      (symbol) => ({
-        symbolId: symbol.symbolId,
-        name: symbol.name,
-        multipliers: symbol.multipliers,
-        isWild: symbol.isWild,
-        isScatter: symbol.isScatter,
-      }),
-    );
-
-    return { symbols };
-  }
-
-  private shouldRedrawMeter(
-    bonusType: string,
-    gameLogicConfig: BonnysFortuneGameLogicConfigInterface,
-  ): boolean {
-    if (bonusType === 'collectFeature') {
-      return false;
-    }
-
-    return bonusType in gameLogicConfig.baseGame.bonusGameMeters;
-  }
-
-  private requiresMeterUpdate(
-    redrawKeys: string[],
-    gameLogicConfig: BonnysFortuneGameLogicConfigInterface,
-  ): boolean {
-    return redrawKeys.some(
-      (key) => key in gameLogicConfig.baseGame.bonusGameMeters,
-    );
-  }
-
-  private getMeterLevel(
-    progress: number,
-    threshold: number,
-    percentageLevels: Record<
-      string,
-      { min: number; max: number; value?: number }
-    >,
-  ): number {
-    for (const [, range] of Object.entries(percentageLevels)) {
-      const minValue = NumberHelper.safeMultiply(range.min, threshold, 4);
-      const maxValue = NumberHelper.safeMultiply(range.max, threshold, 4);
-
-      if (progress >= minValue && progress < maxValue) {
-        return range.value ?? 0;
-      }
-    }
-
-    return 5;
-  }
-
-  private async randomThreshold(
-    min: number,
-    max: number,
-    commandId: string,
-    actionId: string,
-  ): Promise<{ value: number; seed: number }> {
-    return this.rngService.getSingleNumber(min, max, commandId, actionId);
-  }
-}