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

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

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