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

package/src/helpers/uuid-helper.ts

@@ -1,7 +0,0 @@
-import { v4 } from 'uuid';
-
-export class UuidHelper {
-  public static generateUuid(): string {
-    return v4();
-  }
-}

package/src/helpers/validation-helper.ts

@@ -1,27 +0,0 @@
-import { validate, ValidationError } from 'class-validator';
-
-export class ValidationHelper {
-  public static readonly validationOptions = {
-    whitelist: true,
-    forbidNonWhitelisted: true,
-  };
-
-  public static readonly validationOptionsWithoutForbidden = {
-    whitelist: true,
-    forbidNonWhitelisted: false,
-  };
-
-  public static validate<T extends object>(dto: T): Promise<ValidationError[]> {
-    return validate(dto, ValidationHelper.validationOptions);
-  }
-
-  public static validateWithoutForbidden<T extends object>(
-    dto: T,
-  ): Promise<ValidationError[]> {
-    return validate(dto, ValidationHelper.validationOptionsWithoutForbidden);
-  }
-
-  public static isPlainObject(value: unknown): value is Record<string, any> {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-  }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-import 'reflect-metadata';
-
-export { BonnysFortuneV1GameEngine } from './bonnys-fortune-v1.game-engine';

package/src/logger/logger.ts

@@ -1,178 +0,0 @@
-import {
-  Logger as WinstonLogger,
-  createLogger,
-  format,
-  transports,
-} from 'winston';
-
-type LogFormat = 'json' | 'pretty';
-
-export class Logger {
-  private readonly logger: WinstonLogger;
-  private context: string;
-
-  constructor(context: string, logFormat?: LogFormat) {
-    this.context = context;
-    const format = logFormat ?? this.detectLogFormat();
-    this.logger = this.createWinstonLogger(format);
-  }
-
-  private detectLogFormat(): LogFormat {
-    const envFormat = process.env.LOG_FORMAT?.toLowerCase();
-
-    switch (envFormat) {
-      case 'pretty':
-        return 'pretty';
-      case 'json':
-        return 'json';
-      default:
-        return 'json';
-    }
-  }
-
-  private createWinstonLogger(logFormat: LogFormat): WinstonLogger {
-    const winstonFormat = this.getLogFormat(logFormat);
-
-    return createLogger({
-      level: 'info',
-      format: winstonFormat,
-      transports: this.getTransports(),
-    });
-  }
-
-  private getLogFormat(logFormat: LogFormat) {
-    return format.combine(format.timestamp(), this.selectFormat(logFormat));
-  }
-
-  private selectFormat(logFormat: LogFormat) {
-    switch (logFormat) {
-      case 'pretty':
-        return this.getPrettyFormat();
-      case 'json':
-        return this.getJsonFormat();
-      default:
-        return this.getJsonFormat();
-    }
-  }
-
-  private getJsonFormat() {
-    return format.combine(
-      format((info) => {
-        if (this.context) {
-          info.message = `[${this.context}] ${info.message}`;
-        }
-        return info;
-      })(),
-      format.json(),
-    );
-  }
-
-  private getPrettyFormat() {
-    return format.combine(
-      format.colorize(),
-      format.printf(({ timestamp, level, message, error, ...meta }) => {
-        const contextStr = this.context ? `[${this.context}] ` : '';
-        let output = `${timestamp} ${level}: ${contextStr}${message}`;
-
-        if (
-          error &&
-          typeof error === 'object' &&
-          'name' in error &&
-          'message' in error
-        ) {
-          output += `\n  Error: ${error.name}: ${error.message}`;
-
-          if (error.name === 'DomainException' && 'errorCode' in error) {
-            output += `\n  Internal Code: ${error.errorCode}`;
-          }
-
-          if ('stack' in error && error.stack) {
-            output += `\n  Stack: ${error.stack}`;
-          }
-        }
-
-        const metaKeys = Object.keys(meta).filter(
-          (key) => key !== 'timestamp' && key !== 'level' && key !== 'message',
-        );
-        if (metaKeys.length > 0) {
-          output += `\n  Meta: ${JSON.stringify(meta, null, 2)}`;
-        }
-
-        return output;
-      }),
-    );
-  }
-
-  private safeStringify(obj: any): string {
-    try {
-      return JSON.stringify(obj, (key, value) => {
-        if (typeof value === 'bigint') {
-          return value.toString();
-        }
-        return value;
-      });
-    } catch (error) {
-      return '[Object cannot be serialized]';
-    }
-  }
-
-  private getTransports() {
-    return [
-      new transports.Console(),
-      new transports.File({ filename: 'logs/app.log' }),
-    ];
-  }
-
-  log(
-    message: any,
-    { level = 'info', ...rest }: { level?: string } & Record<string, any> = {},
-  ) {
-    switch (level) {
-      case 'error':
-        this.logger.error(message, rest);
-        break;
-      case 'warn':
-        this.logger.warn(message, rest);
-        break;
-      case 'debug':
-        this.logger.debug(message, rest);
-        break;
-      case 'verbose':
-        this.logger.verbose(message, rest);
-        break;
-      default:
-        this.logger.info(message, rest);
-        break;
-    }
-  }
-
-  error(message: any, ...optionalParams: any[]) {
-    if (optionalParams.length > 0 && optionalParams[0] instanceof Error) {
-      const error = optionalParams[0];
-      const errorData: any = {
-        name: error.name,
-        message: error.message,
-        stack: error.stack,
-      };
-
-      this.logger.error(message, {
-        error: errorData,
-        ...optionalParams.slice(1),
-      });
-    } else {
-      this.logger.error(message, ...optionalParams);
-    }
-  }
-
-  warn(message: any, ...optionalParams: any[]) {
-    this.logger.warn(message, ...optionalParams);
-  }
-
-  debug(message: any, ...optionalParams: any[]) {
-    this.logger.debug(message, ...optionalParams);
-  }
-
-  verbose(message: any, ...optionalParams: any[]) {
-    this.logger.verbose(message, ...optionalParams);
-  }
-}

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

@@ -1,480 +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 bonusMeters = { ...privateState.bonusMetersByAmount[betAmount] };
-
-        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,
-          );
-
-          bonusMeters[key] = {
-            ...bonusMeters[key],
-            threshold,
-            progress,
-            level,
-          };
-        }
-
-        privateState.bonusMetersByAmount[betAmount] = bonusMeters;
-
-        return {
-          publicState: {
-            ...publicState,
-            bonusMeters,
-          },
-          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 currentPrivateMeter =
-      privateState.bonusMetersByAmount[betAmount][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] = {
-      ...privateState.bonusMetersByAmount[betAmount],
-      [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);
-  }
-}