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

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

@@ -1,285 +0,0 @@
-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 result = await this.gameLogic.initSessionState(
-          this.config,
-          baseReels,
-          command.payload,
-          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,
-        };
-      }
-    }
-  }
-}

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

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

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

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

@@ -1,380 +0,0 @@
-import { BonnysFortuneGameLogicConfigInterface } from '../../logic/game-logic-config.interface';
-
-export const gameLogicConfig: BonnysFortuneGameLogicConfigInterface = {
-  baseGame: {
-    symbolMultipliers: [
-      {
-        symbolId: 0,
-        name: 'H1',
-        isWild: false,
-        isScatter: false,
-        multipliers: {
-          x3: 50,
-          x4: 150,
-          x5: 500,
-        },
-      },
-      {
-        symbolId: 1,
-        name: 'H2',
-        isWild: false,
-        isScatter: false,
-        multipliers: {
-          x3: 30,
-          x4: 100,
-          x5: 300,
-        },
-      },
-      {
-        symbolId: 2,
-        name: 'H3',
-        isWild: false,
-        isScatter: false,
-        multipliers: {
-          x3: 20,
-          x4: 50,
-          x5: 150,
-        },
-      },
-      {
-        symbolId: 3,
-        name: 'M1',
-        isWild: false,
-        isScatter: false,
-        multipliers: {
-          x3: 10,
-          x4: 25,
-          x5: 75,
-        },
-      },
-      {
-        symbolId: 4,
-        name: 'M2',
-        isWild: false,
-        isScatter: false,
-        multipliers: {
-          x3: 7,
-          x4: 15,
-          x5: 50,
-        },
-      },
-      {
-        symbolId: 5,
-        name: 'M3',
-        isWild: false,
-        isScatter: false,
-        multipliers: {
-          x3: 5,
-          x4: 10,
-          x5: 25,
-        },
-      },
-      {
-        symbolId: 6,
-        name: 'L1',
-        isWild: false,
-        isScatter: false,
-        multipliers: {
-          x3: 3,
-          x4: 6,
-          x5: 15,
-        },
-      },
-      {
-        symbolId: 7,
-        name: 'L2',
-        isWild: false,
-        isScatter: false,
-        multipliers: {
-          x3: 3,
-          x4: 6,
-          x5: 15,
-        },
-      },
-      {
-        symbolId: 8,
-        name: 'L3',
-        isWild: false,
-        isScatter: false,
-        multipliers: {
-          x3: 2,
-          x4: 4,
-          x5: 10,
-        },
-      },
-      {
-        symbolId: 9,
-        name: 'L4',
-        isWild: false,
-        isScatter: false,
-        multipliers: {
-          x3: 2,
-          x4: 4,
-          x5: 10,
-        },
-      },
-      {
-        symbolId: 10,
-        name: 'WILD',
-        isWild: true,
-        isScatter: false,
-        multipliers: {
-          x3: 1,
-          x4: 1,
-          x5: 1,
-        },
-      },
-      {
-        symbolId: 11,
-        name: 'SCATTER',
-        isWild: false,
-        isScatter: true,
-        multipliers: {
-          x3: 1,
-          x4: 1,
-          x5: 1,
-        },
-      },
-    ],
-    symbolDefinitions: {
-      baseSymbols: {
-        minIndex: 0,
-        maxIndex: 9,
-      },
-      specialSymbols: {
-        WILD: 10,
-        SCATTER: 11,
-      },
-      collectFeatureSymbols: {
-        multipliers: {
-          CM1: 12,
-          CM2: 13,
-          CM3: 14,
-        },
-        values: {
-          CV1: 15,
-          CV2: 16,
-          CV3: 17,
-        },
-      },
-    },
-    baseGameConfig: {
-      layout: {
-        rows: 3,
-        reels: 5,
-      },
-      winConfig: {
-        minLength: 3,
-        maxLength: 5,
-      },
-      baseBet: 10,
-      reelsOptions: {
-        numberOfOptions: 4,
-        optionWeights: [4, 4, 5, 5],
-      },
-    },
-    paidHSymbolWeights: {
-      None: 298,
-      H1: 22,
-      H2: 12,
-      H3: 50,
-    },
-    paidHSymbolReelWeights: {
-      H1: [5, 15],
-      H2: [5, 15],
-      H3: [5, 15],
-    },
-    paidScatterReelWeights: {
-      reel1: [3, 15],
-      reel2: [0, 5],
-      reel3: [3, 15],
-      reel4: [0, 5],
-      reel5: [3, 15],
-    },
-    bonusGameMeters: {
-      bonusGame1: {
-        symbol: 'H1',
-        min: 25,
-        max: 100,
-        percentageLevels: {
-          level1: { min: 0, max: 0.25, value: 1 },
-          level2: { min: 0.25, max: 0.65, value: 2 },
-          level3: { min: 0.65, max: 0.8, value: 3 },
-          level4: { min: 0.8, max: 1.0, value: 4 },
-          level5: { min: 1.0, max: 1.0, value: 5 },
-        },
-      },
-      bonusGame2: {
-        symbol: 'H2',
-        min: 25,
-        max: 70,
-        percentageLevels: {
-          level1: { min: 0, max: 0.25, value: 1 },
-          level2: { min: 0.25, max: 0.65, value: 2 },
-          level3: { min: 0.65, max: 0.8, value: 3 },
-          level4: { min: 0.8, max: 1.0, value: 4 },
-          level5: { min: 1.0, max: 1.0, value: 5 },
-        },
-      },
-      bonusGame3: {
-        symbol: 'H3',
-        min: 25,
-        max: 80,
-        percentageLevels: {
-          level1: { min: 0, max: 0.25, value: 1 },
-          level2: { min: 0.25, max: 0.65, value: 2 },
-          level3: { min: 0.65, max: 0.8, value: 3 },
-          level4: { min: 0.8, max: 1.0, value: 4 },
-          level5: { min: 1.0, max: 1.0, value: 5 },
-        },
-      },
-    },
-  },
-  bonusGames: {
-    bonusGame1: {
-      type: 'treasure_hunt',
-      potMeter: 'bonusGame1',
-      config: {
-        symbolsCount: 25,
-        stepsCount: 6,
-        jackpotMultipliers: {
-          mini: 20,
-          minor: 50,
-          major: 200,
-          grand: 2000,
-        },
-        jackpotStartCounts: {
-          mini: 0,
-          minor: 0,
-          major: 0,
-          grand: 0,
-        },
-        jackpotScreenCounts: {
-          mini: 10,
-          minor: 7,
-          major: 5,
-          grand: 3,
-        },
-        winningWeights: {
-          none: 30,
-          mini: 90,
-          minor: 25,
-          major: 5,
-          grand: 1,
-        },
-      },
-    },
-    bonusGame2: {
-      type: 'free_spins',
-      potMeter: 'bonusGame2',
-      config: {
-        spinTypes: [
-          {
-            layout: { reels: 5, rows: 3 },
-            spins: 8,
-            multiplier: 10,
-            weight: 5,
-            reelsOptionsWeights: [1, 1, 4, 4],
-          },
-          {
-            layout: { reels: 5, rows: 3 },
-            spins: 4,
-            multiplier: 20,
-            weight: 5,
-            reelsOptionsWeights: [1, 1, 4, 4],
-          },
-          {
-            layout: { reels: 5, rows: 4 },
-            spins: 8,
-            multiplier: 3,
-            weight: 5,
-            reelsOptionsWeights: [1, 1, 4, 4],
-          },
-          {
-            layout: { reels: 5, rows: 4 },
-            spins: 4,
-            multiplier: 6,
-            weight: 5,
-            reelsOptionsWeights: [1, 1, 4, 4],
-          },
-          {
-            layout: { reels: 5, rows: 5 },
-            spins: 8,
-            multiplier: 1,
-            weight: 5,
-            reelsOptionsWeights: [1, 1, 4, 4],
-          },
-          {
-            layout: { reels: 5, rows: 5 },
-            spins: 4,
-            multiplier: 2,
-            weight: 5,
-            reelsOptionsWeights: [1, 1, 4, 4],
-          },
-        ],
-      },
-    },
-    bonusGame3: {
-      type: 'steering_to_the_fortune',
-      potMeter: 'bonusGame3',
-      config: {
-        wheelResults: [
-          { type: 'MULTIPLIER', value: 5, weight: 2 },
-          { type: 'MULTIPLIER', value: 8, weight: 3 },
-          { type: 'MULTIPLIER', value: 10, weight: 5 },
-          { type: 'MULTIPLIER', value: 15, weight: 5 },
-          { type: 'MULTIPLIER', value: 25, weight: 5 },
-          { type: 'MULTIPLIER', value: 40, weight: 3 },
-          { type: 'MULTIPLIER', value: 80, weight: 2 },
-          { type: 'BONUS', bonusType: 'collectFeature', weight: 2 },
-          { type: 'BONUS', bonusType: 'bonusGame1', weight: 2 },
-          { type: 'BONUS', bonusType: 'bonusGame2', weight: 2 },
-        ],
-      },
-    },
-  },
-  scatterGame: {
-    config: {
-      scatterMinNumber: 3,
-      scatterSpins: 6,
-      scatterCheckpoints: [
-        { spin: 3, multiMinValue: 0, valueMinValue: 1 },
-        { spin: 2, multiMinValue: 1, valueMinValue: 2 },
-      ],
-      scatterSymbols: [
-        {
-          symbolId: 'CM1',
-          value: 1,
-          weight: 20,
-        },
-        {
-          symbolId: 'CM2',
-          value: 2,
-          weight: 10,
-        },
-        {
-          symbolId: 'CM3',
-          value: 3,
-          weight: 2,
-        },
-        {
-          symbolId: 'CV1',
-          value: 1,
-          weight: 50,
-        },
-        {
-          symbolId: 'CV2',
-          value: 2,
-          weight: 15,
-        },
-        {
-          symbolId: 'CV3',
-          value: 5,
-          weight: 5,
-        },
-      ],
-      scatterSymbolSpins: [{ weight: 10 }, { weight: 4 }, { weight: 2 }],
-      scatterSymbolSlash: [{ weight: 10 }, { weight: 6 }, { weight: 0 }],
-    },
-  },
-};