@omnitronix/bonnys-fortune-game-engine 1.7.2 → 1.8.0

package/src/__tests__/win-calculator.test.ts

@@ -20,6 +20,7 @@ import {
   executeSpin,
   resetCommandIdCounter,
   MockRngClient,
+  getOutcome,
 } from './helpers/test-engine-factory';
 
 describe('Win Calculator - Bonnys Fortune', () => {
@@ -766,11 +767,12 @@ describe('Win Calculator - Bonnys Fortune', () => {
 
       expect(result.success).toBe(true);
 
+      const outcomeW = getOutcome(result);
       const winResult =
-        result.outcome?.result?.winResult ?? result.outcome?.winResult;
+        outcomeW.result?.winResult ?? outcomeW.winResult;
       if (winResult) {
-        expect(winResult.totalWin).toBeGreaterThanOrEqual(0);
-        expect(Array.isArray(winResult.winningLines)).toBe(true);
+        expect((winResult as { totalWin: number }).totalWin).toBeGreaterThanOrEqual(0);
+        expect(Array.isArray((winResult as { winningLines: unknown[] }).winningLines)).toBe(true);
       }
     });
 
@@ -789,14 +791,16 @@ describe('Win Calculator - Bonnys Fortune', () => {
 
       expect(result.success).toBe(true);
 
+      const outcomeM = getOutcome(result);
       const screen =
-        result.outcome?.result?.screen ??
-        result.outcome?.screen ??
+        outcomeM.result?.screen ??
+        outcomeM.screen ??
         result.privateState.screen;
-      const winResult =
-        result.outcome?.result?.winResult ?? result.outcome?.winResult;
+      const winResult2 =
+        outcomeM.result?.winResult ?? outcomeM.winResult;
 
-      if (screen && winResult) {
+      if (screen && winResult2) {
+        const wr = winResult2 as { totalWin: number; winningLines: unknown[] };
         // Recalculate using the win calculator directly
         const directResult = BonnysFortuneWinCalculator.calculateWins(
           screen,
@@ -806,9 +810,9 @@ describe('Win Calculator - Bonnys Fortune', () => {
           SpinType.BASE_GAME_SPIN,
         );
 
-        expect(directResult.totalWin).toBe(winResult.totalWin);
+        expect(directResult.totalWin).toBe(wr.totalWin);
         expect(directResult.winningLines.length).toBe(
-          winResult.winningLines.length,
+          wr.winningLines.length,
         );
       }
     });

package/src/bonnys-fortune-v1.game-engine.ts

@@ -1,6 +1,8 @@
 import {
   BonnysFortunePrivateState,
   BonnysFortunePublicState,
+  BonnysFortuneOutcome,
+  StartBonusRoundResult,
   SpinResult as LocalSpinResult,
 } from './logic/bonnys-fortune.types';
 import {
@@ -50,6 +52,7 @@ import { ReelStripsConfig } from './domain/reel-strips-config';
 import { ReelStripsConfigLoader } from './config/reel-strips-config/reel-strips-config-loader';
 import { ReelStripsConfigMapper } from './domain/mappers/reel-strips-config.mapper';
 import { ReelStripsConfigValidationService } from './validation/reel-strips-config-validation.service';
+import { RngClientConfig } from '@omnitronix/rng-client-core';
 import { RngClientFactory } from './rng/rng-client.factory';
 import { RngService } from './rng/rng-service';
 import { StartBonusRoundCommand } from './domain/types/start-bonus-round-command';
@@ -65,7 +68,7 @@ export interface BonnysFortuneV1GameEngineConfig {
 export class BonnysFortuneV1GameEngine
   extends SlotGameHandler
   implements
-    GameEngine<BonnysFortunePublicState, BonnysFortunePrivateState, any>,
+    GameEngine<BonnysFortunePublicState, BonnysFortunePrivateState, BonnysFortuneOutcome>,
     DebugIntrospectable
 {
   /**
@@ -111,7 +114,7 @@ export class BonnysFortuneV1GameEngine
     this.configOutPort = new FileSystemGameLogicConfigLoader();
     this.reelsOutPort = new FileSystemReelStripsConfigLoader();
 
-    const rngClient = RngClientFactory.create({ metrics: config.metrics });
+    const rngClient = RngClientFactory.create({ metrics: config.metrics as RngClientConfig['metrics'] });
     this.rngService = new RngService(rngClient);
 
     this.configValidator = new GameLogicConfigValidationService();
@@ -334,7 +337,7 @@ export class BonnysFortuneV1GameEngine
     CommandProcessingResult<
       BonnysFortunePublicState,
       BonnysFortunePrivateState,
-      any
+      BonnysFortuneOutcome
     >
   > {
     this.logger.log(`Processing command ${command.type}`);
@@ -424,15 +427,22 @@ export class BonnysFortuneV1GameEngine
           getResultsArray: () => outcome.results ?? [],
         };
 
+        // The SDK platform expects deliveryStrategy and nextSpinType on the outcome
+        // These are SDK-level extensions not part of the game engine's BonnysFortuneOutcome type
+        const bonusOutcome: StartBonusRoundResult & {
+          nextSpinType: typeof nextSpinType;
+          deliveryStrategy: BonusResultDeliveryStrategy;
+        } = {
+          ...outcome,
+          nextSpinType, // Required by platform-connect SDK to set CurrentSpinType
+          deliveryStrategy,
+        };
+
         return {
           success: true,
           publicState: outcome.publicState,
           privateState: outcome.privateState,
-          outcome: {
-            ...outcome,
-            nextSpinType, // Required by platform-connect SDK to set CurrentSpinType
-            deliveryStrategy,
-          },
+          outcome: bonusOutcome as BonnysFortuneOutcome,
           message: 'Bonus round started',
           rngOutcome,
         };

package/src/domain/types/game-symbols.response.dto.ts

@@ -7,5 +7,5 @@ export interface GameSymbol {
 }
 
 export class GameSymbolsResponseDto {
-  public symbols: GameSymbol[];
+  public symbols!: GameSymbol[];
 }

package/src/game-engine.interface.ts

@@ -11,7 +11,7 @@ export {
 } from '@omnitronix/game-engine-contract';
 
 // Local types specific to this game engine
-export type GameEngineMetricsHandlers = RngClientConfig['metrics']['handlers'];
+export type GameEngineMetricsHandlers = NonNullable<RngClientConfig['metrics']>['handlers'];
 export interface GameEngineConfig {
   metrics?: {
     handlers: GameEngineMetricsHandlers;

package/src/helpers/validation-helper.ts

@@ -21,7 +21,7 @@ export class ValidationHelper {
     return validate(dto, ValidationHelper.validationOptionsWithoutForbidden);
   }
 
-  public static isPlainObject(value: unknown): value is Record<string, any> {
+  public static isPlainObject(value: unknown): value is Record<string, unknown> {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
   }
 }

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

@@ -228,6 +228,9 @@ export class BonnysFortuneGameLogic {
           activeBonus,
         };
       }
+
+      default:
+        throw new Error(`Unknown bonus type: ${normalizedBonusType}`);
     }
   }
 

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

@@ -218,11 +218,20 @@ export interface GetSymbolsResult {
   symbols: GetSymbolsOutcome[];
 }
 
+/** Outcome returned by the INIT_SESSION_STATE command. */
+export interface InitSessionOutcome {
+  publicState: BonnysFortunePublicState;
+  privateState: BonnysFortunePrivateState;
+}
+
+/** Union of all possible outcome types returned by processCommand. */
 export type BonnysFortuneOutcome =
   | BonnysFortuneGameLogicSpinResult
   | BonnysFortuneBonusGameLogicSpinResult
+  | StartBonusRoundResult
+  | InitSessionOutcome
   | SymbolsCountMatrix
   | DebugTriggerBonusOutcome
   | DebugUpdateBonusMeterProgressOutcome
-  | GetSymbolsOutcome
+  | GetSymbolsResult
   | null;

package/src/logic/handlers/collect-feature-bonus.handler.ts

@@ -6,7 +6,10 @@ import {
   SpinType,
 } from '../bonnys-fortune.types';
 
-import { BonnysFortuneGameLogicConfigInterface } from '../game-logic-config.interface';
+import {
+  BonnysFortuneGameLogicConfigInterface,
+  ScatterGameConfig,
+} 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';
@@ -102,7 +105,7 @@ export class CollectFeatureBonusHandler {
     totalMultipliers: number,
     totalWin: number,
     betGame: number,
-    scatterConfig: any,
+    scatterConfig: ScatterGameConfig,
     checkpoints: number[],
     publicState: BonnysFortunePublicState,
     privateState: BonnysFortunePrivateState,

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

@@ -41,17 +41,18 @@ export class SteeringToTheFortuneBonusHandler {
     let triggeredBonus: BonusTrigger | undefined;
 
     if (prize.type === PrizeType.MULTIPLIER) {
-      playerWinning = NumberHelper.safeMultiply(betStake, prize.value, 2);
+      playerWinning = NumberHelper.safeMultiply(betStake, prize.value ?? 0, 2);
     } else if (prize.type === PrizeType.BONUS) {
+      const bonusType = prize.bonusType ?? 'bonusGame1';
       triggeredBonus = {
         bonusId: UuidHelper.generateUuid(),
-        bonusType: prize.bonusType,
+        bonusType,
         betAmount: NumberHelper.toFixedNumber(params.betAmount, 2),
       };
-      nextSpinType = getSpinTypeForBonus(prize.bonusType);
+      nextSpinType = getSpinTypeForBonus(bonusType);
     }
 
-    const results = [
+    const results: SpinResultResponse<SteeringToTheFortuneResult>[] = [
       {
         result: {
           spinType: SpinType.BONUS_GAME_3_SPIN,
@@ -59,9 +60,9 @@ export class SteeringToTheFortuneBonusHandler {
           nextSpinType,
           prizeType: prize.type,
           prizeValue:
-            prize.type === PrizeType.MULTIPLIER ? prize.value : prize.bonusType,
+            prize.type === PrizeType.MULTIPLIER ? (prize.value ?? 0) : (prize.bonusType ?? ''),
           totalMultiplier:
-            prize.type === PrizeType.MULTIPLIER ? prize.value : 0,
+            prize.type === PrizeType.MULTIPLIER ? (prize.value ?? 0) : 0,
           triggeredBonus,
           // BaseOutcome standardized fields
           actionType: SpinType.BONUS_GAME_3_SPIN,

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

@@ -64,14 +64,14 @@ export class TreasureHuntBonusHandler {
     // Player only sees the first stepsCount (6) positions
     const playerSelections = selectionsVector.slice(0, stepsCount);
     const selections = playerSelections.map((idx) => jackpotKeys[idx]);
-    const multipliers = selections.map((name) => jackpotMultipliers[name]);
+    const multipliers = selections.map((name) => (jackpotMultipliers as Record<string, number>)[name]);
 
     const results = selections.map((symbol, index) => {
       const isFinalStep = index === stepsCount - 1;
 
       const winningMultiplier =
         isFinalStep && winSymbolIndex >= 0
-          ? jackpotMultipliers[jackpotKeys[winSymbolIndex]]
+          ? (jackpotMultipliers as Record<string, number>)[jackpotKeys[winSymbolIndex]]
           : 0;
       const playerWinning =
         isFinalStep && winSymbolIndex >= 0

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

@@ -15,9 +15,9 @@ export class RngClientFactory {
     }
 
     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',
+      serverUrl: process.env.RNG_CLIENT_URL ?? '',
+      grpcUrl: process.env.RNG_CLIENT_GRPC_URL ?? '',
+      clientMethod: (process.env.RNG_CLIENT_METHOD as 'grpc' | 'rest') ?? 'rest',
       poolingSize: parseInt(process.env.RNG_CLIENT_POOL_SIZE || '2000'),
       metrics: config.metrics,
     };

package/src/validation/bonnys-fortune/bonnys-fortune-config.dto.ts

@@ -15,109 +15,109 @@ import {
 
 export class SymbolMultipliersDto {
   @IsInt()
-  public symbolId: number;
+  public symbolId!: number;
 
   @IsString()
-  public name: string;
+  public name!: string;
 
   @IsObject()
-  public multipliers: Record<'x3' | 'x4' | 'x5', number>;
+  public multipliers!: Record<'x3' | 'x4' | 'x5', number>;
 
   @IsBoolean()
-  public isWild: boolean;
+  public isWild!: boolean;
 
   @IsBoolean()
-  public isScatter: boolean;
+  public isScatter!: boolean;
 }
 
 // --- SymbolDefinitions ---
 
 export class CollectFeatureSymbolsDto {
   @IsObject()
-  public multipliers: Record<string, number>;
+  public multipliers!: Record<string, number>;
 
   @IsObject()
-  public values: Record<string, number>;
+  public values!: Record<string, number>;
 }
 
 export class SymbolRangeDto {
   @IsInt()
-  public minIndex: number;
+  public minIndex!: number;
 
   @IsInt()
-  public maxIndex: number;
+  public maxIndex!: number;
 }
 
 export class SymbolDefinitionsDto {
   @ValidateNested()
   @Type(() => SymbolRangeDto)
-  public baseSymbols: SymbolRangeDto;
+  public baseSymbols!: SymbolRangeDto;
 
   @IsObject()
-  public specialSymbols: Record<string, number>;
+  public specialSymbols!: Record<string, number>;
 
   @ValidateNested()
   @Type(() => CollectFeatureSymbolsDto)
-  public collectFeatureSymbols: CollectFeatureSymbolsDto;
+  public collectFeatureSymbols!: CollectFeatureSymbolsDto;
 }
 
 // --- BaseGameConfig ---
 
 export class LayoutDto {
   @IsInt()
-  public rows: number;
+  public rows!: number;
 
   @IsInt()
-  public reels: number;
+  public reels!: number;
 }
 
 export class WinConfigDto {
   @IsInt()
-  public minLength: number;
+  public minLength!: number;
 
   @IsInt()
-  public maxLength: number;
+  public maxLength!: number;
 }
 
 // --- ReelsOptions ---
 
 export class ReelsOptionsDto {
   @IsInt()
-  public numberOfOptions: number;
+  public numberOfOptions!: number;
 
   @IsArray()
   @IsInt({ each: true })
-  public optionWeights: number[];
+  public optionWeights!: number[];
 }
 
 export class BaseGameConfigDto {
   @ValidateNested()
   @Type(() => LayoutDto)
-  public layout: LayoutDto;
+  public layout!: LayoutDto;
 
   @ValidateNested()
   @Type(() => WinConfigDto)
-  public winConfig: WinConfigDto;
+  public winConfig!: WinConfigDto;
 
   @IsInt()
-  public baseBet: number;
+  public baseBet!: number;
 
   @ValidateNested()
   @Type(() => ReelsOptionsDto)
-  public reelsOptions: ReelsOptionsDto;
+  public reelsOptions!: ReelsOptionsDto;
 }
 
 // --- BonusGameMeter ---
 
 export class BonusGameMeterDto {
   @IsString()
-  public symbol: string;
+  public symbol!: string;
 
   @IsInt()
-  public min: number;
+  public min!: number;
 
   @IsInt()
-  public max: number;
+  public max!: number;
 }
 
 // --- BaseGame ---
@@ -126,58 +126,58 @@ export class BaseGameDto {
   @IsArray()
   @ValidateNested({ each: true })
   @Type(() => SymbolMultipliersDto)
-  public symbolMultipliers: SymbolMultipliersDto[];
+  public symbolMultipliers!: SymbolMultipliersDto[];
 
   @ValidateNested()
   @Type(() => SymbolDefinitionsDto)
-  public symbolDefinitions: SymbolDefinitionsDto;
+  public symbolDefinitions!: SymbolDefinitionsDto;
 
   @ValidateNested()
   @Type(() => BaseGameConfigDto)
-  public baseGameConfig: BaseGameConfigDto;
+  public baseGameConfig!: BaseGameConfigDto;
 
   @IsObject()
-  public paidHSymbolWeights: Record<string, number>;
+  public paidHSymbolWeights!: Record<string, number>;
 
   @IsObject()
-  public paidHSymbolReelWeights: Record<string, [number, number]>;
+  public paidHSymbolReelWeights!: Record<string, [number, number]>;
 
   @IsObject()
-  public paidScatterReelWeights: Record<string, [number, number]>;
+  public paidScatterReelWeights!: Record<string, [number, number]>;
 
   @IsObject()
-  public bonusGameMeters: Record<string, BonusGameMeterDto>;
+  public bonusGameMeters!: Record<string, BonusGameMeterDto>;
 }
 
 // --- BonusGame Specific Config DTOs ---
 
 export class TreasureHuntBonusConfigDto {
   @IsInt()
-  public symbolsCount: number;
+  public symbolsCount!: number;
 
   @IsInt()
-  public stepsCount: number;
+  public stepsCount!: number;
 
   @IsObject()
-  public jackpotMultipliers: Record<
+  public jackpotMultipliers!: Record<
     'mini' | 'minor' | 'major' | 'grand',
     number
   >;
 
   @IsObject()
-  public jackpotStartCounts: Record<
+  public jackpotStartCounts!: Record<
     'mini' | 'minor' | 'major' | 'grand',
     number
   >;
 
   @IsObject()
-  public jackpotScreenCounts: Record<
+  public jackpotScreenCounts!: Record<
     'mini' | 'minor' | 'major' | 'grand',
     number
   >;
 
   @IsObject()
-  public winningWeights: Record<
+  public winningWeights!: Record<
     'none' | 'mini' | 'minor' | 'major' | 'grand',
     number
   >;
@@ -187,7 +187,7 @@ export class TreasureHuntBonusConfigDto {
 
 export class BonusGameEvaluationConfigDto {
   @IsString()
-  public defaultConfig: string;
+  public defaultConfig!: string;
 
   @IsArray()
   @IsString({ each: true })
@@ -203,57 +203,57 @@ export class BonusGameEvaluationConfigDto {
 
 export class BaseBonusGameDto {
   @IsString()
-  public type: string;
+  public type!: string;
 
   @IsString()
-  public potMeter: string;
+  public potMeter!: string;
 
   @ValidateNested()
   @Type(() => BonusGameEvaluationConfigDto)
-  public evaluationConfig: BonusGameEvaluationConfigDto;
+  public evaluationConfig!: BonusGameEvaluationConfigDto;
 }
 
 export class TreasureHuntBonusGameDto extends BaseBonusGameDto {
   @ValidateNested()
   @Type(() => TreasureHuntBonusConfigDto)
-  public config: TreasureHuntBonusConfigDto;
+  public config!: TreasureHuntBonusConfigDto;
 }
 
 export class FreeSpinTypeDto {
   @ValidateNested()
   @Type(() => LayoutDto)
-  public layout: LayoutDto;
+  public layout!: LayoutDto;
 
   @IsInt()
-  public spins: number;
+  public spins!: number;
 
   @IsInt()
-  public multiplier: number;
+  public multiplier!: number;
 
   @IsInt()
-  public weight: number;
+  public weight!: number;
 
   @IsArray()
   @IsInt({ each: true })
-  public reelsOptionsWeights: number[];
+  public reelsOptionsWeights!: number[];
 }
 
 export class FreeSpinBonusConfigDto {
   @IsArray()
   @ValidateNested({ each: true })
   @Type(() => FreeSpinTypeDto)
-  public spinTypes: FreeSpinTypeDto[];
+  public spinTypes!: FreeSpinTypeDto[];
 }
 
 export class FreeSpinBonusGameDto extends BaseBonusGameDto {
   @ValidateNested()
   @Type(() => FreeSpinBonusConfigDto)
-  public config: FreeSpinBonusConfigDto;
+  public config!: FreeSpinBonusConfigDto;
 }
 
 export class SteeringToTheFortuneWheelResultDto {
   @IsString()
-  public type: 'MULTIPLIER' | 'BONUS';
+  public type!: 'MULTIPLIER' | 'BONUS';
 
   @IsOptional()
   @IsInt()
@@ -264,20 +264,20 @@ export class SteeringToTheFortuneWheelResultDto {
   public bonusType?: string;
 
   @IsInt()
-  public weight: number;
+  public weight!: number;
 }
 
 export class SteeringToTheFortuneBonusConfigDto {
   @IsArray()
   @ValidateNested({ each: true })
   @Type(() => SteeringToTheFortuneWheelResultDto)
-  public wheelResults: SteeringToTheFortuneWheelResultDto[];
+  public wheelResults!: SteeringToTheFortuneWheelResultDto[];
 }
 
 export class SteeringToTheFortuneBonusGameDto extends BaseBonusGameDto {
   @ValidateNested()
   @Type(() => SteeringToTheFortuneBonusConfigDto)
-  public config: SteeringToTheFortuneBonusConfigDto;
+  public config!: SteeringToTheFortuneBonusConfigDto;
 }
 
 export class BonusGamesDto {
@@ -301,58 +301,58 @@ export class BonusGamesDto {
 
 export class ScatterSymbolDto {
   @IsString()
-  public symbolId: string;
+  public symbolId!: string;
 
   @IsInt()
-  public value: number;
+  public value!: number;
 
   @IsInt()
-  public weight: number;
+  public weight!: number;
 }
 
 // --- ScatterGameConfigDto ---
 
 export class ScatterCheckpointDto {
   @IsInt()
-  public spin: number;
+  public spin!: number;
 
   @IsInt()
-  public multiMinValue: number;
+  public multiMinValue!: number;
 
   @IsInt()
-  public valueMinValue: number;
+  public valueMinValue!: number;
 }
 
 export class ScatterGameConfigDto {
   @IsInt()
-  public scatterMinNumber: number;
+  public scatterMinNumber!: number;
 
   @IsInt()
-  public scatterSpins: number;
+  public scatterSpins!: number;
 
   @IsArray()
   @ValidateNested({ each: true })
   @Type(() => ScatterCheckpointDto)
-  public scatterCheckpoints: ScatterCheckpointDto[];
+  public scatterCheckpoints!: ScatterCheckpointDto[];
 
   @IsArray()
   @ValidateNested({ each: true })
   @Type(() => ScatterSymbolDto)
-  public scatterSymbols: ScatterSymbolDto[];
+  public scatterSymbols!: ScatterSymbolDto[];
 
   @IsArray()
   @IsObject({ each: true })
-  public scatterSymbolSpins: Record<string, number>[];
+  public scatterSymbolSpins!: Record<string, number>[];
 
   @IsArray()
   @IsObject({ each: true })
-  public scatterSymbolSlash: Record<string, number>[];
+  public scatterSymbolSlash!: Record<string, number>[];
 }
 
 export class ScatterGameConfigWrapperDto {
   @ValidateNested()
   @Type(() => ScatterGameConfigDto)
-  public config: ScatterGameConfigDto;
+  public config!: ScatterGameConfigDto;
 }
 
 // --- Root Config DTO ---
@@ -360,20 +360,20 @@ export class ScatterGameConfigWrapperDto {
 export class BonnysFortuneGameLogicConfigDto {
   @ValidateNested()
   @Type(() => BaseGameDto)
-  public baseGame: BaseGameDto;
+  public baseGame!: BaseGameDto;
 
   @ValidateNested()
   @Type(() => BonusGamesDto)
-  public bonusGames: BonusGamesDto;
+  public bonusGames!: BonusGamesDto;
 
   @ValidateNested()
   @Type(() => ScatterGameConfigWrapperDto)
-  public scatterGame: ScatterGameConfigWrapperDto;
+  public scatterGame!: ScatterGameConfigWrapperDto;
 
   @IsArray()
   @IsNumber({}, { each: true })
-  public defaultBetAmountThresholds: number[];
+  public defaultBetAmountThresholds!: number[];
 
   @IsNumber()
-  public defaultBetAmount: number;
+  public defaultBetAmount!: number;
 }