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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnitronix/bonnys-fortune-game-engine",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "Bonnys Fortune Game Engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,7 +19,7 @@
   "author": "Omnitronix",
   "license": "UNLICENSED",
   "dependencies": {
-    "@omnitronix/rng-client-core": "^1.0.10",
+    "@omnitronix/rng-client-core": "^1.1.1",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
     "reflect-metadata": "^0.1.13",
@@ -42,7 +42,8 @@
     "typescript": "^5.0.0"
   },
   "files": [
-    "dist/**/*",
+    "dist",
+    "src",
     "README.md"
   ],
   "publishConfig": {

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

@@ -0,0 +1,80 @@
+import { BonnysFortuneV1GameEngine } from '../bonnys-fortune-v1.game-engine';
+import { GameSpinCommand } from '../domain/types/game-spin-command';
+import { SpinType } from '../domain/types/game-spin-output.dto';
+
+describe('BonnysFortuneV1GameEngine', () => {
+  let gameEngine: BonnysFortuneV1GameEngine;
+
+  beforeEach(() => {
+    gameEngine = new BonnysFortuneV1GameEngine();
+  });
+
+  it('should initialize the game engine and return info', async () => {
+    const info = gameEngine.getGameEngineInfo();
+    expect(info.gameCode).toBe('bonnys-fortune');
+    expect(info.version).toBe('1.0.0');
+    expect(info.rtp).toBe(96);
+    expect(info.gameType).toBe('slot');
+  });
+
+  it('should process a spin command successfully', async () => {
+    const initialPublicState = {
+      currentBetAmount: 1,
+      bonusMeters: {},
+    };
+    const initialPrivateState = {
+      nextSpinType: SpinType.BASE_GAME_SPIN,
+      pendingBonuses: [],
+      bonusMetersByAmount: {
+        1: {
+          bonusGame1: {
+            symbolName: 'H1',
+            symbolId: 0,
+            threshold: 25,
+            progress: 0,
+            level: 1,
+          },
+          bonusGame2: {
+            symbolName: 'H2',
+            symbolId: 1,
+            threshold: 25,
+            progress: 0,
+            level: 1,
+          },
+          bonusGame3: {
+            symbolName: 'H3',
+            symbolId: 2,
+            threshold: 25,
+            progress: 0,
+            level: 1,
+          },
+        },
+      },
+    };
+
+    const spinCommand = {
+      id: 'test-command-123',
+      type: 'SPIN',
+      payload: {
+        sessionId: 'test-session-123',
+        betAmount: 1,
+        gameCode: 'bonnys-fortune',
+        gameVersion: '1.0.0',
+        lines: 10,
+        creditsPerLine: 1,
+      } as GameSpinCommand,
+    };
+
+    const result = await gameEngine.processCommand(
+      initialPublicState,
+      initialPrivateState,
+      spinCommand,
+    );
+
+    expect(result).toBeDefined();
+    expect(result.success).toBe(true);
+    expect(result.outcome).toBeDefined();
+    expect(result.publicState).toBeDefined();
+    expect(result.privateState).toBeDefined();
+  });
+});

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

@@ -0,0 +1,314 @@
+import {
+  BonnysFortunePrivateState,
+  BonnysFortunePublicState,
+} from './logic/bonnys-fortune.types';
+import {
+  CommandProcessingResult,
+  GameActionCommand,
+  GameEngine,
+  GameEngineConfig,
+  GameEngineInfo,
+} from './game-engine.interface';
+
+import { BonnysFortuneGameLogic } from './logic/bonnys-fortune.game-logic';
+import { BonnysFortuneGameLogicConfigInterface } from './logic/game-logic-config.interface';
+import { BonnysFortuneGameLogicConfigValidator } from './validation/bonnys-fortune/bonnys-fortune-config.validator';
+import { CheatTriggerBonusCommand } from './domain/types/cheat-trigger-bonus-command';
+import { CheatUpdateBonusMeterProgressCommand } from './domain/types/cheat-update-bonus-meter-progress-command';
+import { FileSystemGameLogicConfigLoader } from './config/game-logic-config/file-system.game-logic-config-loader';
+import { FileSystemReelStripsConfigLoader } from './config/reel-strips-config/file-system.reel-strips-config-loader';
+import { GameLogicConfigLoader } from './config/game-logic-config/game-logic-config-loader';
+import { GameLogicConfigValidationService } from './validation/game-logic-config-validation.service';
+import { GameRoundType } from './domain/game-round.types';
+import { GameSpinCommand } from './domain/types/game-spin-command';
+import { Logger } from './logger/logger';
+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 { RngClientFactory } from './rng/rng-client.factory';
+import { RngService } from './rng/rng-service';
+import { StartBonusRoundCommand } from './domain/types/start-bonus-round-command';
+
+export class BonnysFortuneV1GameEngine implements GameEngine<
+  BonnysFortunePublicState,
+  BonnysFortunePrivateState,
+  any
+> {
+  private readonly gameCode = 'bonnys-fortune';
+  private readonly version = '1.0.0';
+  private readonly rtp = 96;
+  private readonly gameType = 'slot';
+  private readonly gameName = "Bonny's Fortune";
+  private readonly provider = 'Omnitronix';
+  private config!: BonnysFortuneGameLogicConfigInterface;
+  private reels!: Map<GameRoundType, ReelStripsConfig>;
+
+  readonly configOutPort: GameLogicConfigLoader;
+  readonly reelsOutPort: ReelStripsConfigLoader;
+  readonly configValidator: GameLogicConfigValidationService;
+  readonly reelsValidator: ReelStripsConfigValidationService;
+  readonly reelMapper: ReelStripsConfigMapper;
+  readonly gameLogic: BonnysFortuneGameLogic;
+  readonly rngService: RngService;
+  readonly logger: Logger;
+
+  constructor(config: GameEngineConfig = {}) {
+    this.logger = new Logger('BonnysFortuneV1Engine');
+    this.configOutPort = new FileSystemGameLogicConfigLoader();
+    this.reelsOutPort = new FileSystemReelStripsConfigLoader();
+
+    const rngClient = RngClientFactory.create({ metrics: config.metrics });
+    this.rngService = new RngService(rngClient);
+
+    this.configValidator = new GameLogicConfigValidationService();
+    this.reelsValidator = new ReelStripsConfigValidationService();
+    this.reelMapper = new ReelStripsConfigMapper();
+    this.gameLogic = new BonnysFortuneGameLogic(this.rngService);
+    this.preload();
+  }
+
+  public getGameEngineInfo(): GameEngineInfo {
+    return {
+      gameCode: this.gameCode,
+      version: this.version,
+      rtp: this.rtp,
+      gameType: this.gameType,
+      gameName: this.gameName,
+      provider: this.provider,
+    };
+  }
+
+  private async preload(): Promise<void> {
+    this.logger.log('Preloading Bonnys Fortune engine');
+    this.configValidator.register(
+      this.gameCode,
+      new BonnysFortuneGameLogicConfigValidator(),
+    );
+    const rawConfig =
+      await this.configOutPort.loadConfig<BonnysFortuneGameLogicConfigInterface>(
+        this.gameCode,
+        this.version,
+      );
+    if (!rawConfig) {
+      throw new Error('Bonnys Fortune game logic config not found');
+    }
+    await this.configValidator.validate(this.gameCode, rawConfig);
+
+    const reelsCount = rawConfig.baseGame.baseGameConfig.layout.reels;
+    const optionsCount =
+      rawConfig.baseGame.baseGameConfig.reelsOptions.numberOfOptions;
+
+    const rawBaseGameReels = await this.reelsOutPort.loadConfig(
+      this.gameCode,
+      this.version,
+      GameRoundType.BASE,
+      reelsCount,
+      optionsCount,
+    );
+    await this.reelsValidator.validate(rawBaseGameReels);
+
+    const rawBonusGame2Reels = await this.reelsOutPort.loadConfig(
+      this.gameCode,
+      this.version,
+      GameRoundType.BONUS,
+      reelsCount,
+      optionsCount,
+    );
+    await this.reelsValidator.validate(rawBonusGame2Reels);
+
+    this.config = rawConfig;
+    this.reels = new Map([
+      [GameRoundType.BASE, this.reelMapper.mapRawToDomain(rawBaseGameReels)],
+      [GameRoundType.BONUS, this.reelMapper.mapRawToDomain(rawBonusGame2Reels)],
+    ]);
+  }
+
+  public async processCommand(
+    publicState: BonnysFortunePublicState,
+    privateState: BonnysFortunePrivateState,
+    command: GameActionCommand,
+  ): Promise<
+    CommandProcessingResult<
+      BonnysFortunePublicState,
+      BonnysFortunePrivateState,
+      any
+    >
+  > {
+    this.logger.log(`Processing command ${command.type}`);
+    this.rngService.registerCommand(command.id);
+    switch (command.type) {
+      case 'INIT_SESSION_STATE': {
+        const baseReels = this.reels.get(GameRoundType.BASE);
+        if (!baseReels) {
+          throw new Error('Base game reels not found');
+        }
+        const gameConfig = this.resolveInitGameConfig(command.payload ?? {});
+        const result = await this.gameLogic.initSessionState(
+          this.config,
+          baseReels,
+          gameConfig,
+          command.id,
+        );
+        const rngOutcome = this.rngService.getRngOutcomeForCommand(command.id);
+        this.rngService.removeCommand(command.id);
+        return {
+          success: true,
+          publicState: result.publicState,
+          privateState: result.privateState,
+          outcome: result,
+          message: 'Session state initialized',
+          rngOutcome,
+        };
+      }
+
+      case 'SPIN': {
+        const params = command.payload as GameSpinCommand;
+        const baseReels = this.reels.get(GameRoundType.BASE);
+        if (!baseReels) {
+          throw new Error('Base game reels not found');
+        }
+        const outcome = await this.gameLogic.spin(
+          params,
+          publicState,
+          privateState,
+          this.config,
+          baseReels,
+          command.id,
+        );
+        const rngOutcome = this.rngService.getRngOutcomeForCommand(command.id);
+        this.rngService.removeCommand(command.id);
+        return {
+          success: true,
+          publicState: outcome.publicState,
+          privateState: outcome.privateState,
+          outcome,
+          message: 'Spin completed',
+          rngOutcome,
+        };
+      }
+
+      case 'START_BONUS_ROUND': {
+        const params = command.payload as StartBonusRoundCommand;
+        const bonusReels = this.reels.get(GameRoundType.BONUS);
+        if (!bonusReels) {
+          throw new Error('Bonus game reels not found');
+        }
+        const outcome = await this.gameLogic.startBonusRound(
+          params,
+          publicState,
+          privateState,
+          this.config,
+          bonusReels,
+          command.id,
+        );
+
+        if (!outcome) {
+          throw new Error('Bonus round outcome not found');
+        }
+
+        const rngOutcome = this.rngService.getRngOutcomeForCommand(command.id);
+        this.rngService.removeCommand(command.id);
+        return {
+          success: true,
+          publicState: outcome.publicState,
+          privateState: outcome.privateState,
+          outcome,
+          message: 'Bonus round started',
+          rngOutcome,
+        };
+      }
+
+      case 'CHEAT_TRIGGER_BONUS': {
+        const params = command.payload as CheatTriggerBonusCommand;
+        const result = await this.gameLogic.cheatTriggerBonus(
+          publicState,
+          privateState,
+          params,
+        );
+
+        const rngOutcome = this.rngService.getRngOutcomeForCommand(command.id);
+        this.rngService.removeCommand(command.id);
+        return {
+          success: true,
+          publicState: result.publicState,
+          privateState: result.privateState,
+          outcome: result.outcome,
+          message: 'Bonus triggered',
+          rngOutcome,
+        };
+      }
+
+      case 'CHEAT_UPDATE_BONUS_METER_PROGRESS': {
+        const params = command.payload as CheatUpdateBonusMeterProgressCommand;
+        const result = this.gameLogic.cheatUpdateBonusMeterProgress(
+          publicState,
+          privateState,
+          params,
+          this.config,
+        );
+
+        const rngOutcome = this.rngService.getRngOutcomeForCommand(command.id);
+        this.rngService.removeCommand(command.id);
+        return {
+          success: true,
+          publicState: result.publicState,
+          privateState: result.privateState,
+          outcome: result.outcome,
+          message: 'Bonus meter progress updated',
+          rngOutcome,
+        };
+      }
+
+      case 'GET_SYMBOLS': {
+        this.rngService.removeCommand(command.id);
+        return {
+          success: true,
+          publicState,
+          privateState,
+          outcome: this.gameLogic.getSymbols(this.config),
+          message: 'Symbols retrieved',
+          rngOutcome: undefined,
+        };
+      }
+
+      default: {
+        return {
+          success: false,
+          publicState: publicState,
+          privateState: privateState,
+          outcome: null,
+          message: 'Command not found',
+          rngOutcome: undefined,
+        };
+      }
+    }
+  }
+
+  /**
+   * Resolves init session params from payload, falling back to game logic config when values are missing or invalid.
+   */
+  private resolveInitGameConfig(payload: Record<string, unknown>): {
+    betAmountThresholds: number[];
+    defaultBetAmount: number;
+  } {
+    const rawThresholds = payload.betAmountThresholds;
+    const validThresholds =
+      Array.isArray(rawThresholds) &&
+      rawThresholds.length > 0 &&
+      rawThresholds.every(
+        (n): n is number => typeof n === 'number' && Number.isFinite(n),
+      );
+    const betAmountThresholds = validThresholds
+      ? rawThresholds
+      : this.config.defaultBetAmountThresholds;
+
+    const rawDefault = payload.defaultBetAmount ?? this.config.defaultBetAmount;
+    const defaultBetAmount =
+      typeof rawDefault === 'number' && Number.isFinite(rawDefault)
+        ? rawDefault
+        : this.config.defaultBetAmount;
+
+    return { betAmountThresholds, defaultBetAmount };
+  }
+}

package/src/config/game-logic-config/file-system.game-logic-config-loader.ts

@@ -0,0 +1,27 @@
+import * as path from 'path';
+
+import { GameLogicConfigLoader } from './game-logic-config-loader';
+export class FileSystemGameLogicConfigLoader implements GameLogicConfigLoader {
+  public async loadConfig<T>(
+    gameId: string,
+    variantId: string,
+  ): Promise<T | null> {
+    try {
+      const configPath = path.resolve(__dirname, `./game-logic-config.js`);
+
+      const configModule = await import(configPath);
+
+      const config = <T>configModule.gameLogicConfig;
+
+      if (!config) {
+        console.warn(`Config object 'gameConfig' missing in ${configPath}`);
+        return null;
+      }
+
+      return config;
+    } catch (error) {
+      console.warn(`Failed to load config for ${gameId}/${variantId}:`, error);
+      return null;
+    }
+  }
+}

package/src/config/game-logic-config/game-logic-config-loader.ts

@@ -0,0 +1,3 @@
+export interface GameLogicConfigLoader {
+  loadConfig<T>(gameId: string, variantId: string): Promise<T | null>;
+}