shufflecom-calculations 4.2.0 → 4.2.1

package/src/games/floor-is-lava-rules.spec.ts

@@ -1,126 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { calculateEdgeMultiplier } from '../utils/edge';
-import { FixedSequenceRng } from './fixed-rng';
-import {
-  BOARD_SIZE,
-  DIFFICULTY_DROP_MAP,
-  FloorIsLavaActionPhase,
-  FloorIsLavaDifficulty,
-  FloorIsLavaRules,
-  FloorIsLavaStartAction,
-  FloorIsLavaSuccessfulPickAction,
-} from './floor-is-lava-rules';
-
-const EDGE_BPS = 200;
-
-const startAction = (difficulty: FloorIsLavaDifficulty): FloorIsLavaStartAction => ({ phase: FloorIsLavaActionPhase.START, difficulty });
-
-const pickAction = (): FloorIsLavaSuccessfulPickAction => ({
-  phase: FloorIsLavaActionPhase.SUCCESSFUL_PICK,
-  selectedTile: 0,
-  droppedTiles: [],
-  multiplier: new BigNumber(0),
-});
-
-describe('FloorIsLavaRules.maxRounds', () => {
-  it.each([
-    [FloorIsLavaDifficulty.EASY, 12],
-    [FloorIsLavaDifficulty.MEDIUM, 8],
-    [FloorIsLavaDifficulty.HARD, 6],
-    [FloorIsLavaDifficulty.TOXIC, 1],
-  ])('%s allows %i rounds', (difficulty, expected) => {
-    expect(FloorIsLavaRules.maxRounds(difficulty)).toBe(expected);
-  });
-});
-
-describe('FloorIsLavaRules.tilesRemaining', () => {
-  it('returns the full board when no rounds have been survived', () => {
-    expect(FloorIsLavaRules.tilesRemaining(0, 6)).toBe(BOARD_SIZE);
-  });
-
-  it('subtracts dropped tiles for the rounds survived so far', () => {
-    expect(FloorIsLavaRules.tilesRemaining(2, 6)).toBe(BOARD_SIZE - 12);
-  });
-});
-
-describe('FloorIsLavaRules.isValidTile', () => {
-  it.each([0, 1, BOARD_SIZE - 1])('accepts an in-range integer tile (%s)', tile => {
-    expect(FloorIsLavaRules.isValidTile(tile)).toBe(true);
-  });
-
-  it.each([-1, BOARD_SIZE, 1.5, NaN, Infinity])('rejects an out-of-range or non-integer tile (%s)', tile => {
-    expect(FloorIsLavaRules.isValidTile(tile)).toBe(false);
-  });
-});
-
-describe('FloorIsLavaRules.multiplier', () => {
-  it('scales the edge multiplier by board size over standing tiles', () => {
-    const expected = calculateEdgeMultiplier(EDGE_BPS)
-      .multipliedBy(BOARD_SIZE)
-      .dividedBy(BOARD_SIZE - 6);
-    expect(FloorIsLavaRules.multiplier(1, 6, EDGE_BPS).isEqualTo(expected)).toBe(true);
-  });
-});
-
-describe('FloorIsLavaRules.getRoundResults', () => {
-  it('chunks the drawn sequence into per-round groups of dropsPerRound', () => {
-    const rng = new FixedSequenceRng([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
-    expect(FloorIsLavaRules.getRoundResults(rng, 4, 3)).toEqual([
-      [0, 1, 2, 3],
-      [4, 5, 6, 7],
-      [8, 9, 10, 11],
-    ]);
-  });
-});
-
-describe('FloorIsLavaRules.lastSurvivingTile', () => {
-  it('returns the final tile of the full-board drop order — the last to fall', () => {
-    const champion = 7;
-    const dropOrder = [...Array.from({ length: BOARD_SIZE }, (_, i) => i).filter(tile => tile !== champion), champion];
-    expect(FloorIsLavaRules.lastSurvivingTile(new FixedSequenceRng(dropOrder))).toBe(champion);
-  });
-});
-
-describe('FloorIsLavaRules.reconstructRounds', () => {
-  it('counts the PICK actions following START as survived rounds', () => {
-    const actions = [startAction(FloorIsLavaDifficulty.MEDIUM), pickAction(), pickAction()];
-    expect(FloorIsLavaRules.reconstructRounds(actions)).toEqual({
-      roundsSurvived: 2,
-      dropsPerRound: DIFFICULTY_DROP_MAP[FloorIsLavaDifficulty.MEDIUM],
-    });
-  });
-
-  it('throws when the first action is not START', () => {
-    expect(() => FloorIsLavaRules.reconstructRounds([pickAction()])).toThrow('First action must be START');
-  });
-
-  it('throws when a START action appears after the first position', () => {
-    expect(() => FloorIsLavaRules.reconstructRounds([startAction(FloorIsLavaDifficulty.MEDIUM), startAction(FloorIsLavaDifficulty.MEDIUM)])).toThrow(
-      'START action can only appear as the first action',
-    );
-  });
-
-  it('throws when a CASHOUT action appears in the history', () => {
-    expect(() =>
-      FloorIsLavaRules.reconstructRounds([
-        startAction(FloorIsLavaDifficulty.MEDIUM),
-        { phase: FloorIsLavaActionPhase.CASHOUT, multiplier: new BigNumber(1), lastSurvivingTile: 0 },
-      ]),
-    ).toThrow('An active game cannot have a CASHOUT action');
-  });
-
-  it('throws when a BUST_PICK action appears in the history', () => {
-    expect(() =>
-      FloorIsLavaRules.reconstructRounds([
-        startAction(FloorIsLavaDifficulty.MEDIUM),
-        { phase: FloorIsLavaActionPhase.BUST_PICK, selectedTile: 0, droppedTiles: [], lastSurvivingTile: 1 },
-      ]),
-    ).toThrow('An active game cannot have a BUST_PICK action');
-  });
-
-  it('throws when survived rounds exceed the difficulty max', () => {
-    expect(() => FloorIsLavaRules.reconstructRounds([startAction(FloorIsLavaDifficulty.TOXIC), pickAction(), pickAction()])).toThrow(
-      'Reconstructed rounds (2) exceeds max rounds (1)',
-    );
-  });
-});

package/src/games/floor-is-lava-rules.ts

@@ -1,125 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { calculateEdgeMultiplier } from '../utils/edge';
-import { RandomNumberGenerator } from './random-number-generator.interface';
-
-export const BOARD_SIZE = 49;
-export const DROPPABLE_TILES = BOARD_SIZE - 1;
-
-export enum FloorIsLavaDifficulty {
-  EASY = 'EASY',
-  MEDIUM = 'MEDIUM',
-  HARD = 'HARD',
-  TOXIC = 'TOXIC',
-}
-
-export const DIFFICULTY_DROP_MAP: Readonly<Record<FloorIsLavaDifficulty, number>> = {
-  [FloorIsLavaDifficulty.EASY]: 4,
-  [FloorIsLavaDifficulty.MEDIUM]: 6,
-  [FloorIsLavaDifficulty.HARD]: 8,
-  [FloorIsLavaDifficulty.TOXIC]: 48,
-};
-
-export const MAX_ROUNDS = DROPPABLE_TILES / Math.min(...Object.values(DIFFICULTY_DROP_MAP));
-
-export enum FloorIsLavaActionPhase {
-  START = 'START',
-  SUCCESSFUL_PICK = 'SUCCESSFUL_PICK',
-  BUST_PICK = 'BUST_PICK',
-  CASHOUT = 'CASHOUT',
-}
-
-export interface FloorIsLavaStartAction {
-  phase: FloorIsLavaActionPhase.START;
-  difficulty: FloorIsLavaDifficulty;
-}
-
-export interface FloorIsLavaSuccessfulPickAction {
-  phase: FloorIsLavaActionPhase.SUCCESSFUL_PICK;
-  selectedTile: number;
-  droppedTiles: number[];
-  multiplier: BigNumber;
-}
-
-export interface FloorIsLavaBustPickAction {
-  phase: FloorIsLavaActionPhase.BUST_PICK;
-  selectedTile: number;
-  droppedTiles: number[];
-  lastSurvivingTile: number;
-}
-
-export interface FloorIsLavaCashoutAction {
-  phase: FloorIsLavaActionPhase.CASHOUT;
-  multiplier: BigNumber;
-  lastSurvivingTile: number;
-}
-
-export type FloorIsLavaGameAction =
-  | FloorIsLavaStartAction
-  | FloorIsLavaSuccessfulPickAction
-  | FloorIsLavaBustPickAction
-  | FloorIsLavaCashoutAction;
-
-export class FloorIsLavaRules {
-  public static maxRounds(difficulty: FloorIsLavaDifficulty): number {
-    return DROPPABLE_TILES / DIFFICULTY_DROP_MAP[difficulty];
-  }
-
-  public static tilesRemaining(roundsSurvived: number, dropsPerRound: number): number {
-    return BOARD_SIZE - roundsSurvived * dropsPerRound;
-  }
-
-  public static isValidTile(tile: number): boolean {
-    return Number.isInteger(tile) && tile >= 0 && tile <= BOARD_SIZE - 1;
-  }
-
-  // RTP * 49 / surviving tiles = edge multiplier
-  public static multiplier(roundsSurvived: number, dropsPerRound: number, edge: number): BigNumber {
-    return calculateEdgeMultiplier(edge).multipliedBy(BOARD_SIZE).dividedBy(FloorIsLavaRules.tilesRemaining(roundsSurvived, dropsPerRound));
-  }
-
-  public static lastSurvivingTile(generator: RandomNumberGenerator): number {
-    const dropOrder = generator.getRandomIntsWithoutReplacement({ min: 0, max: BOARD_SIZE - 1, count: BOARD_SIZE });
-    return dropOrder[dropOrder.length - 1];
-  }
-
-  public static getRoundResults(generator: RandomNumberGenerator, dropsPerRound: number, numRounds: number): number[][] {
-    const dropSequence = generator.getRandomIntsWithoutReplacement({ min: 0, max: BOARD_SIZE - 1, count: numRounds * dropsPerRound });
-
-    const rounds: number[][] = [];
-    for (let round = 0; round < numRounds; round++) {
-      rounds.push(dropSequence.slice(round * dropsPerRound, (round + 1) * dropsPerRound));
-    }
-    return rounds;
-  }
-
-  public static reconstructRounds(gameActions: FloorIsLavaGameAction[]): { roundsSurvived: number; dropsPerRound: number } {
-    const first = gameActions[0];
-    if (!first || first.phase !== FloorIsLavaActionPhase.START) {
-      throw new Error('First action must be START');
-    }
-
-    const dropsPerRound = DIFFICULTY_DROP_MAP[first.difficulty];
-    const maxRounds = FloorIsLavaRules.maxRounds(first.difficulty);
-    let roundsSurvived = 0;
-
-    for (let i = 1; i < gameActions.length; i++) {
-      const action = gameActions[i];
-      switch (action.phase) {
-        case FloorIsLavaActionPhase.START:
-          throw new Error('START action can only appear as the first action');
-        case FloorIsLavaActionPhase.SUCCESSFUL_PICK:
-          roundsSurvived++;
-          if (roundsSurvived > maxRounds) {
-            throw new Error(`Reconstructed rounds (${roundsSurvived}) exceeds max rounds (${maxRounds})`);
-          }
-          break;
-        case FloorIsLavaActionPhase.BUST_PICK:
-          throw new Error('An active game cannot have a BUST_PICK action');
-        case FloorIsLavaActionPhase.CASHOUT:
-          throw new Error('An active game cannot have a CASHOUT action');
-      }
-    }
-
-    return { roundsSurvived, dropsPerRound };
-  }
-}