shufflecom-calculations 4.2.0 → 4.2.2

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

@@ -1,502 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { calculateEdgeMultiplier } from '../utils/edge';
-import { FixedSequenceRng } from './fixed-rng';
-import {
-  BOARD_SIZE,
-  DIFFICULTY_DROP_MAP,
-  DROPPABLE_TILES,
-  FloorIsLava,
-  FloorIsLavaActionPhase,
-  FloorIsLavaAutoBetRoundOutcome,
-  FloorIsLavaDifficulty,
-  FloorIsLavaRules,
-  FloorIsLavaStartAction,
-  FloorIsLavaSuccessfulPickAction,
-} from './floor-is-lava';
-import { TrueRandomRng } from './true-random-rng';
-
-const ALL_DIFFICULTIES = [FloorIsLavaDifficulty.EASY, FloorIsLavaDifficulty.MEDIUM, FloorIsLavaDifficulty.HARD, FloorIsLavaDifficulty.TOXIC];
-
-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),
-});
-
-// A full 49-tile drop order whose leading entries are `prefix` and whose final (last-surviving) tile is `champion`.
-const fullDraw = (prefix: number[], champion: number): number[] => {
-  const middle = Array.from({ length: BOARD_SIZE }, (_, i) => i).filter(tile => tile !== champion && !prefix.includes(tile));
-  return [...prefix, ...middle, champion];
-};
-
-const fullBoardRng = () => new FixedSequenceRng(Array.from({ length: BOARD_SIZE }, (_, i) => i));
-
-const gameWithRounds = (difficulty: FloorIsLavaDifficulty, roundsSurvived: number) =>
-  FloorIsLava.fromActions([startAction(difficulty), ...Array.from({ length: roundsSurvived }, () => pickAction())]);
-
-const expectOk = <T extends { ok: boolean }>(result: T): Extract<T, { ok: true }> => {
-  if (!result.ok) {
-    throw new Error(`Expected an ok result but got: ${JSON.stringify(result)}`);
-  }
-  return result as Extract<T, { ok: true }>;
-};
-
-const expectedMultiplier = (roundsSurvived: number, dropsPerRound: number, edgeBps: number = EDGE_BPS) =>
-  calculateEdgeMultiplier(edgeBps)
-    .multipliedBy(BOARD_SIZE)
-    .dividedBy(BOARD_SIZE - roundsSurvived * dropsPerRound);
-
-describe('FloorIsLava.createAction', () => {
-  it('returns a START action carrying the difficulty', () => {
-    expect(FloorIsLava.createAction(FloorIsLavaDifficulty.MEDIUM)).toEqual({ phase: 'START', difficulty: FloorIsLavaDifficulty.MEDIUM });
-  });
-});
-
-describe('FloorIsLava.fromActions', () => {
-  describe('valid histories', () => {
-    it('a start-only history cannot be cashed out', () => {
-      expect(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 0).canCashout()).toBe(false);
-    });
-
-    it('accumulates surviving rounds into cashout eligibility', () => {
-      expect(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 3).canCashout()).toBe(true);
-    });
-
-    it('accepts a history at exactly the max round count', () => {
-      expect(gameWithRounds(FloorIsLavaDifficulty.EASY, FloorIsLavaRules.maxRounds(FloorIsLavaDifficulty.EASY)).canCashout()).toBe(true);
-    });
-  });
-
-  describe('validation errors', () => {
-    it('throws on an empty history', () => {
-      expect(() => FloorIsLava.fromActions([])).toThrow('First action must be START');
-    });
-
-    it('throws when the first action is not START', () => {
-      expect(() => FloorIsLava.fromActions([pickAction()])).toThrow('First action must be START');
-    });
-
-    it('throws when a START action appears after the first position', () => {
-      expect(() =>
-        FloorIsLava.fromActions([startAction(FloorIsLavaDifficulty.MEDIUM), pickAction(), startAction(FloorIsLavaDifficulty.MEDIUM)]),
-      ).toThrow('START action can only appear as the first action');
-    });
-
-    it('throws when the history contains a CASHOUT action', () => {
-      expect(() =>
-        FloorIsLava.fromActions([
-          startAction(FloorIsLavaDifficulty.MEDIUM),
-          pickAction(),
-          { phase: FloorIsLavaActionPhase.CASHOUT, multiplier: new BigNumber(1), lastSurvivingTile: 0 },
-        ]),
-      ).toThrow('An active game cannot have a CASHOUT action');
-    });
-
-    it('throws when survived rounds exceed the difficulty max', () => {
-      // TOXIC drops all 48 in one round, so max rounds is 1
-      expect(() => FloorIsLava.fromActions([startAction(FloorIsLavaDifficulty.TOXIC), pickAction(), pickAction()])).toThrow(
-        'Reconstructed rounds (2) exceeds max rounds (1)',
-      );
-    });
-  });
-});
-
-describe('FloorIsLava.next', () => {
-  it.each([-1, 49, 1.5, NaN])('rejects an out-of-range selectedTile (%s)', tile => {
-    const rng = new FixedSequenceRng([10, 11, 12, 13]);
-    expect(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 0).next(tile, rng, EDGE_BPS)).toEqual({ ok: false, error: 'invalid-tile' });
-  });
-
-  it('a surviving first pick keeps the game open and pays the 1-round multiplier', () => {
-    const rng = new FixedSequenceRng([10, 11, 12, 13, 14, 15]);
-    const result = expectOk(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 0).next(5, rng, EDGE_BPS));
-
-    expect(result).toMatchObject({
-      isLoss: false,
-      isLastTile: false,
-      gameAction: { phase: 'SUCCESSFUL_PICK', selectedTile: 5, droppedTiles: [10, 11, 12, 13, 14, 15] },
-    });
-    expect(result.multiplier.isEqualTo(expectedMultiplier(1, 6))).toBe(true);
-  });
-
-  it('a pick that lands on a dropped tile zeroes the multiplier and reveals the surviving tile', () => {
-    const rng = new FixedSequenceRng(fullDraw([10, 11, 12, 13, 14, 15], 32));
-    const result = expectOk(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 0).next(12, rng, EDGE_BPS));
-
-    expect(result).toMatchObject({
-      isLoss: true,
-      isLastTile: false,
-      multiplier: new BigNumber(0),
-      gameAction: { phase: 'BUST_PICK', selectedTile: 12, droppedTiles: [10, 11, 12, 13, 14, 15], lastSurvivingTile: 32 },
-    });
-  });
-
-  it('drops this round from the growing suffix and excludes prior-round drops', () => {
-    // rounds 1 & 2 already survived (12 tiles gone), this is round 3
-    const rng = new FixedSequenceRng([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 20, 21, 22, 23, 24, 25]);
-    const result = expectOk(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 2).next(30, rng, EDGE_BPS));
-
-    expect(result).toMatchObject({ isLoss: false, gameAction: { droppedTiles: [20, 21, 22, 23, 24, 25] } });
-    expect(result.multiplier.isEqualTo(expectedMultiplier(3, 6))).toBe(true);
-  });
-
-  it('a pick on a tile dropped in an earlier round is rejected', () => {
-    const rng = new FixedSequenceRng([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 20, 21, 22, 23, 24, 25]);
-    expect(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 2).next(2, rng, EDGE_BPS)).toEqual({ ok: false, error: 'tile-already-dropped' });
-  });
-
-  it('a loss deep into a streak still pays zero', () => {
-    const rng = new FixedSequenceRng(fullDraw([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 20, 21, 22, 23, 24, 25], 32));
-    const result = expectOk(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 2).next(22, rng, EDGE_BPS));
-
-    expect(result).toMatchObject({
-      isLoss: true,
-      isLastTile: false,
-      multiplier: new BigNumber(0),
-      gameAction: { phase: 'BUST_PICK', lastSurvivingTile: 32 },
-    });
-  });
-
-  it('a full clear completes the game at the top multiplier', () => {
-    const rng = new FixedSequenceRng(Array.from({ length: DROPPABLE_TILES }, (_, i) => i));
-    const result = expectOk(gameWithRounds(FloorIsLavaDifficulty.TOXIC, 0).next(DROPPABLE_TILES, rng, EDGE_BPS));
-
-    expect(result).toMatchObject({ isLoss: false, isLastTile: true, multiplier: new BigNumber('48.02') });
-  });
-
-  it('completes the game when a win reduces the board to a single tile', () => {
-    // EASY drops 4 per round across 12 rounds; surviving to the last round leaves exactly one standing tile
-    const rng = new FixedSequenceRng(Array.from({ length: DROPPABLE_TILES }, (_, i) => i));
-    const maxRounds = FloorIsLavaRules.maxRounds(FloorIsLavaDifficulty.EASY);
-    const result = expectOk(gameWithRounds(FloorIsLavaDifficulty.EASY, maxRounds - 1).next(DROPPABLE_TILES, rng, EDGE_BPS));
-
-    expect(result).toMatchObject({ isLoss: false, isLastTile: true, multiplier: new BigNumber('48.02') });
-  });
-
-  it('returns no-tiles-remaining when there are no tiles left to pick', () => {
-    const rng = new FixedSequenceRng([]);
-    const maxRounds = FloorIsLavaRules.maxRounds(FloorIsLavaDifficulty.EASY);
-    expect(gameWithRounds(FloorIsLavaDifficulty.EASY, maxRounds).next(0, rng, EDGE_BPS)).toEqual({
-      ok: false,
-      error: 'no-tiles-remaining',
-    });
-  });
-
-  it('reveals fresh tiles each round via the growing cumulative draw', () => {
-    const rng = new FixedSequenceRng([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25]);
-
-    const round1 = expectOk(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 0).next(30, rng, EDGE_BPS));
-    const round2 = expectOk(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 1).next(31, rng, EDGE_BPS));
-
-    expect(round1.gameAction.droppedTiles).toEqual([10, 11, 12, 13, 14, 15]);
-    expect(round2.gameAction.droppedTiles).toEqual([20, 21, 22, 23, 24, 25]);
-    expect(round1.gameAction.droppedTiles).not.toEqual(round2.gameAction.droppedTiles);
-  });
-});
-
-describe('FloorIsLava — chained real sessions (fromActions replay of actual next() output)', () => {
-  it('threads real next() output through fromActions across multiple rounds', () => {
-    const rng = new FixedSequenceRng(fullDraw([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25], 32));
-
-    const game0 = FloorIsLava.fromActions([startAction(FloorIsLavaDifficulty.MEDIUM)]);
-    const round1 = expectOk(game0.next(30, rng, EDGE_BPS));
-    expect(round1.isLoss).toBe(false);
-
-    const game1 = FloorIsLava.fromActions([startAction(FloorIsLavaDifficulty.MEDIUM), round1.gameAction]);
-    const round2 = expectOk(game1.next(31, rng, EDGE_BPS));
-    expect(round2).toMatchObject({ isLoss: false, gameAction: { droppedTiles: [20, 21, 22, 23, 24, 25] } });
-    expect(round2.gameAction.droppedTiles).not.toEqual(round1.gameAction.droppedTiles);
-
-    const game2 = FloorIsLava.fromActions([startAction(FloorIsLavaDifficulty.MEDIUM), round1.gameAction, round2.gameAction]);
-    expect(game2.canCashout()).toBe(true);
-
-    const cashoutResult = expectOk(game2.cashout(rng, EDGE_BPS));
-    expect(cashoutResult.multiplier).toEqual(round2.multiplier);
-    expect(cashoutResult.gameAction.lastSurvivingTile).toBe(32);
-  });
-
-  it('threads a real survived pick into a second round that busts', () => {
-    const rng = new FixedSequenceRng(fullDraw([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25], 32));
-
-    const game0 = FloorIsLava.fromActions([startAction(FloorIsLavaDifficulty.MEDIUM)]);
-    const round1 = expectOk(game0.next(30, rng, EDGE_BPS));
-
-    const game1 = FloorIsLava.fromActions([startAction(FloorIsLavaDifficulty.MEDIUM), round1.gameAction]);
-    const round2 = expectOk(game1.next(20, rng, EDGE_BPS));
-
-    expect(round2).toMatchObject({
-      isLoss: true,
-      isLastTile: false,
-      multiplier: new BigNumber(0),
-      gameAction: { phase: 'BUST_PICK', lastSurvivingTile: 32 },
-    });
-  });
-});
-
-describe('FloorIsLava.cashout', () => {
-  it.each([
-    [FloorIsLavaDifficulty.MEDIUM, 1],
-    [FloorIsLavaDifficulty.MEDIUM, 3],
-    [FloorIsLavaDifficulty.HARD, 2],
-  ])('cashing out %s after %i rounds pays the telescoped multiplier', (difficulty, rounds) => {
-    const dropsPerRound = difficulty === FloorIsLavaDifficulty.HARD ? 8 : 6;
-    const result = expectOk(gameWithRounds(difficulty, rounds).cashout(fullBoardRng(), EDGE_BPS));
-
-    expect(result.multiplier.isEqualTo(expectedMultiplier(rounds, dropsPerRound))).toBe(true);
-    expect(result.gameAction.phase).toBe('CASHOUT');
-    expect(result.gameAction.multiplier.isEqualTo(expectedMultiplier(rounds, dropsPerRound))).toBe(true);
-  });
-
-  it('returns no-tiles-selected with zero rounds survived', () => {
-    expect(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 0).cashout(fullBoardRng(), EDGE_BPS)).toEqual({ ok: false, error: 'no-tiles-selected' });
-  });
-});
-
-describe('FloorIsLava.autobet', () => {
-  it('surviving every selected round pays the N-round multiplier', () => {
-    const rng = new FixedSequenceRng(fullDraw([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25, 40, 41, 42, 43, 44, 45], 0));
-    const result = expectOk(FloorIsLava.autobet(FloorIsLavaDifficulty.MEDIUM, [30, 31, 32], rng, EDGE_BPS));
-
-    expect(result).toMatchObject({
-      survivedRounds: 3,
-      lastSurvivingTile: 0,
-      results: [
-        { droppedTiles: [10, 11, 12, 13, 14, 15], outcome: FloorIsLavaAutoBetRoundOutcome.SURVIVED },
-        { droppedTiles: [20, 21, 22, 23, 24, 25], outcome: FloorIsLavaAutoBetRoundOutcome.SURVIVED },
-        { droppedTiles: [40, 41, 42, 43, 44, 45], outcome: FloorIsLavaAutoBetRoundOutcome.SURVIVED },
-      ],
-    });
-    expect(result.multiplier.isEqualTo(expectedMultiplier(3, 6))).toBe(true);
-  });
-
-  it('busts and pays zero when a selected tile drops in its own round', () => {
-    const rng = new FixedSequenceRng(fullDraw([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25], 0));
-    const result = expectOk(FloorIsLava.autobet(FloorIsLavaDifficulty.MEDIUM, [30, 21], rng, EDGE_BPS));
-
-    expect(result).toMatchObject({
-      multiplier: new BigNumber(0),
-      survivedRounds: 1,
-      lastSurvivingTile: 0,
-      results: [
-        { selectedTile: 30, outcome: FloorIsLavaAutoBetRoundOutcome.SURVIVED },
-        { selectedTile: 21, droppedTiles: [20, 21, 22, 23, 24, 25], outcome: FloorIsLavaAutoBetRoundOutcome.LOST },
-      ],
-    });
-  });
-
-  it('forces a cashout (not a bust) when a selected tile had already dropped in an earlier round', () => {
-    const rng = new FixedSequenceRng(fullDraw([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25, 40, 41, 42, 43, 44, 45], 0));
-    // round 3 blindly stands on tile 10, which was already lava since round 1 - the player never actually risked this round's own draw, so they're paid out at what they'd already survived
-    const result = expectOk(FloorIsLava.autobet(FloorIsLavaDifficulty.MEDIUM, [30, 31, 10], rng, EDGE_BPS));
-
-    expect(result).toMatchObject({
-      survivedRounds: 2,
-      lastSurvivingTile: 0,
-      results: [
-        { selectedTile: 30, outcome: FloorIsLavaAutoBetRoundOutcome.SURVIVED },
-        { selectedTile: 31, outcome: FloorIsLavaAutoBetRoundOutcome.SURVIVED },
-        { selectedTile: 10, droppedTiles: [40, 41, 42, 43, 44, 45], outcome: FloorIsLavaAutoBetRoundOutcome.CASHED_OUT },
-      ],
-    });
-    expect(result.multiplier.isEqualTo(expectedMultiplier(2, 6))).toBe(true);
-  });
-
-  it('forces a cashout on the very next round after the pick was already dead', () => {
-    const rng = new FixedSequenceRng(fullDraw([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25], 0));
-    const result = expectOk(FloorIsLava.autobet(FloorIsLavaDifficulty.MEDIUM, [30, 10], rng, EDGE_BPS));
-
-    expect(result).toMatchObject({
-      survivedRounds: 1,
-      lastSurvivingTile: 0,
-      results: [
-        { selectedTile: 30, outcome: FloorIsLavaAutoBetRoundOutcome.SURVIVED },
-        { selectedTile: 10, droppedTiles: [20, 21, 22, 23, 24, 25], outcome: FloorIsLavaAutoBetRoundOutcome.CASHED_OUT },
-      ],
-    });
-    expect(result.multiplier.isEqualTo(expectedMultiplier(1, 6))).toBe(true);
-  });
-
-  it('allows revisiting a still-standing tile across rounds', () => {
-    const rng = new FixedSequenceRng(fullDraw([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25], 0));
-    const result = expectOk(FloorIsLava.autobet(FloorIsLavaDifficulty.MEDIUM, [5, 5], rng, EDGE_BPS));
-
-    expect(result).toMatchObject({ survivedRounds: 2, lastSurvivingTile: 0 });
-    expect(result.multiplier.isEqualTo(expectedMultiplier(2, 6))).toBe(true);
-  });
-
-  it('a full-length sequence full-clears at the top multiplier', () => {
-    const rng = new FixedSequenceRng(Array.from({ length: BOARD_SIZE }, (_, i) => i));
-    const result = expectOk(FloorIsLava.autobet(FloorIsLavaDifficulty.TOXIC, [DROPPABLE_TILES], rng, EDGE_BPS));
-
-    expect(result).toMatchObject({ survivedRounds: 1, multiplier: new BigNumber('48.02'), lastSurvivingTile: DROPPABLE_TILES });
-  });
-
-  it('returns invalid-selected-tiles-count when the sequence exceeds the difficulty max rounds', () => {
-    const rng = new FixedSequenceRng([0, 1]);
-    expect(FloorIsLava.autobet(FloorIsLavaDifficulty.TOXIC, [10, 20], rng, EDGE_BPS)).toEqual({
-      ok: false,
-      error: 'invalid-selected-tiles-count',
-    });
-  });
-
-  it('returns invalid-selected-tiles-count on an empty sequence', () => {
-    const rng = new FixedSequenceRng([]);
-    expect(FloorIsLava.autobet(FloorIsLavaDifficulty.MEDIUM, [], rng, EDGE_BPS)).toEqual({
-      ok: false,
-      error: 'invalid-selected-tiles-count',
-    });
-  });
-
-  it.each([-1, 49, 1.5, NaN])('returns invalid-tile when any selected tile (%s) is out of range', tile => {
-    const rng = new FixedSequenceRng([10, 11, 12, 13]);
-    expect(FloorIsLava.autobet(FloorIsLavaDifficulty.MEDIUM, [5, tile], rng, EDGE_BPS)).toEqual({ ok: false, error: 'invalid-tile' });
-  });
-});
-
-describe('FloorIsLava — edge parameter', () => {
-  it.each([100, 500, 1000])('cashout applies the given edge (%i bps), not a hardcoded value', edgeBps => {
-    const result = expectOk(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 3).cashout(fullBoardRng(), edgeBps));
-    expect(result.multiplier.isEqualTo(expectedMultiplier(3, 6, edgeBps))).toBe(true);
-  });
-
-  it.each([100, 500, 1000])('next applies the given edge (%i bps) to a surviving pick', edgeBps => {
-    const rng = new FixedSequenceRng([10, 11, 12, 13, 14, 15]);
-    const result = expectOk(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 0).next(5, rng, edgeBps));
-    expect(result.multiplier.isEqualTo(expectedMultiplier(1, 6, edgeBps))).toBe(true);
-  });
-
-  it.each([100, 500, 1000])('autobet applies the given edge (%i bps) on a full survive', edgeBps => {
-    const rng = new FixedSequenceRng(fullDraw([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25], 0));
-    const result = expectOk(FloorIsLava.autobet(FloorIsLavaDifficulty.MEDIUM, [30, 31], rng, edgeBps));
-    expect(result.multiplier.isEqualTo(expectedMultiplier(2, 6, edgeBps))).toBe(true);
-  });
-
-  it('rejects an edge below the platform minimum (100 bps) on cashout', () => {
-    expect(() => gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 3).cashout(fullBoardRng(), 99)).toThrow('Exceeded Minimum edge allowed on platform');
-  });
-
-  it('rejects an edge below the platform minimum (100 bps) on a surviving next()', () => {
-    const rng = new FixedSequenceRng([10, 11, 12, 13, 14, 15]);
-    expect(() => gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 0).next(5, rng, 99)).toThrow('Exceeded Minimum edge allowed on platform');
-  });
-
-  it('rejects an edge below the platform minimum (100 bps) on a surviving autobet', () => {
-    const rng = new FixedSequenceRng(fullDraw([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25], 0));
-    expect(() => FloorIsLava.autobet(FloorIsLavaDifficulty.MEDIUM, [30, 31], rng, 99)).toThrow('Exceeded Minimum edge allowed on platform');
-  });
-});
-
-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.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('DIFFICULTY_DROP_MAP', () => {
-  it.each(Object.entries(DIFFICULTY_DROP_MAP))('%s drops per round is a factor of DROPPABLE_TILES', (_difficulty, dropsPerRound) => {
-    expect(DROPPABLE_TILES % dropsPerRound).toBe(0);
-  });
-});
-
-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],
-    ]);
-  });
-
-  it('is prefix-stable — asking for more rounds keeps earlier rounds identical', () => {
-    const rng = new FixedSequenceRng([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
-    const twoRounds = FloorIsLavaRules.getRoundResults(rng, 4, 2);
-    const threeRounds = FloorIsLavaRules.getRoundResults(rng, 4, 3);
-    expect(threeRounds.slice(0, 2)).toEqual(twoRounds);
-  });
-});
-
-describe('FloorIsLava — exhaustive multiplier & RTP across every endpoint', () => {
-  const houseEdge = calculateEdgeMultiplier(EDGE_BPS); // 0.98 == 98% RTP
-
-  // Win chance derived independently, round by round, as the product of each round's survival
-  // probability (standingBefore - X) / standingBefore. Makes no assumption about telescoping.
-  const winChance = (rounds: number, dropsPerRound: number): BigNumber => {
-    let chance = new BigNumber(1);
-    for (let r = 1; r <= rounds; r++) {
-      const standingBefore = BOARD_SIZE - (r - 1) * dropsPerRound;
-      chance = chance.multipliedBy(standingBefore - dropsPerRound).dividedBy(standingBefore);
-    }
-    return chance;
-  };
-
-  it.each(ALL_DIFFICULTIES)('%s: every reachable endpoint pays fair odds and returns 98% RTP', difficulty => {
-    const dropsPerRound = DIFFICULTY_DROP_MAP[difficulty];
-    const maxRounds = FloorIsLavaRules.maxRounds(difficulty);
-
-    for (let k = 1; k <= maxRounds; k++) {
-      const chance = winChance(k, dropsPerRound);
-      const multiplier = FloorIsLavaRules.multiplier(k, dropsPerRound, EDGE_BPS);
-
-      // fair payout inverts the win chance and applies the edge once: houseEdge / winChance
-      expect(multiplier.toNumber()).toBeCloseTo(houseEdge.dividedBy(chance).toNumber(), 9);
-
-      // the game surface (fromActions + cashout) returns the same endpoint multiplier
-      expect(expectOk(gameWithRounds(difficulty, k).cashout(fullBoardRng(), EDGE_BPS)).multiplier.isEqualTo(multiplier)).toBe(true);
-
-      // RTP == winChance * payout is the house edge at EVERY endpoint, not just on average
-      expect(chance.multipliedBy(multiplier).toNumber()).toBeCloseTo(houseEdge.toNumber(), 9);
-    }
-  });
-
-  it('every difficulty full-clears to the same 48.02x ceiling', () => {
-    for (const difficulty of ALL_DIFFICULTIES) {
-      const dropsPerRound = DIFFICULTY_DROP_MAP[difficulty];
-      const maxRounds = FloorIsLavaRules.maxRounds(difficulty);
-      expect(FloorIsLavaRules.multiplier(maxRounds, dropsPerRound, EDGE_BPS)).toEqual(new BigNumber('48.02'));
-    }
-  });
-});
-
-describe('FloorIsLava.autobet — empirical RTP regression guard', () => {
-  const TRIALS = 80_000;
-  const RTP_TOLERANCE = 0.05;
-
-  it.each([2, 3, 5])('MEDIUM autobet with %i distinct tile picks averages ~98%% RTP over real randomness', rounds => {
-    const selectedTiles = Array.from({ length: rounds }, (_, i) => i);
-
-    let totalPayout = new BigNumber(0);
-    for (let trial = 0; trial < TRIALS; trial++) {
-      const result = FloorIsLava.autobet(FloorIsLavaDifficulty.MEDIUM, selectedTiles, new TrueRandomRng(), EDGE_BPS);
-      if (result.ok) {
-        totalPayout = totalPayout.plus(result.multiplier);
-      }
-    }
-
-    const empiricalRTP = totalPayout.dividedBy(TRIALS).toNumber();
-    const intendedRTP = calculateEdgeMultiplier(EDGE_BPS).toNumber();
-
-    expect(empiricalRTP).toBeGreaterThan(intendedRTP - RTP_TOLERANCE);
-    expect(empiricalRTP).toBeLessThan(intendedRTP + RTP_TOLERANCE);
-  });
-});

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

@@ -1,184 +0,0 @@
-import BigNumber from 'bignumber.js';
-import {
-  DIFFICULTY_DROP_MAP,
-  FloorIsLavaActionPhase,
-  FloorIsLavaBustPickAction,
-  FloorIsLavaCashoutAction,
-  FloorIsLavaDifficulty,
-  FloorIsLavaGameAction,
-  FloorIsLavaRules,
-  FloorIsLavaStartAction,
-  FloorIsLavaSuccessfulPickAction,
-} from './floor-is-lava-rules';
-import { RandomNumberGenerator } from './random-number-generator.interface';
-
-export * from './floor-is-lava-rules';
-
-export type FloorIsLavaNextError = 'tile-already-dropped' | 'no-tiles-remaining' | 'invalid-tile';
-
-export type FloorIsLavaNextResult =
-  | {
-      ok: true;
-      multiplier: BigNumber;
-      gameAction: FloorIsLavaSuccessfulPickAction | FloorIsLavaBustPickAction;
-      isLoss: boolean;
-      isLastTile: boolean;
-    }
-  | { ok: false; error: FloorIsLavaNextError };
-
-export type FloorIsLavaCashoutError = 'no-tiles-selected';
-
-export type FloorIsLavaCashoutResult =
-  | { ok: true; multiplier: BigNumber; gameAction: FloorIsLavaCashoutAction }
-  | { ok: false; error: FloorIsLavaCashoutError };
-
-export enum FloorIsLavaAutoBetRoundOutcome {
-  SURVIVED = 'SURVIVED',
-  LOST = 'LOST',
-  CASHED_OUT = 'CASHED_OUT',
-}
-
-export interface FloorIsLavaAutoBetRoundResult {
-  selectedTile: number;
-  droppedTiles: number[];
-  outcome: FloorIsLavaAutoBetRoundOutcome;
-}
-
-export type FloorIsLavaAutoBetError = 'invalid-selected-tiles-count' | 'invalid-tile';
-
-export type FloorIsLavaAutoBetResult =
-  | { ok: true; multiplier: BigNumber; results: FloorIsLavaAutoBetRoundResult[]; survivedRounds: number; lastSurvivingTile: number }
-  | { ok: false; error: FloorIsLavaAutoBetError };
-
-export class FloorIsLava {
-  private constructor(
-    private readonly roundsSurvived: number,
-    private readonly dropsPerRound: number,
-  ) {}
-
-  public static createAction(difficulty: FloorIsLavaDifficulty): FloorIsLavaStartAction {
-    return { phase: FloorIsLavaActionPhase.START, difficulty };
-  }
-
-  public static fromActions(gameActions: FloorIsLavaGameAction[]): FloorIsLava {
-    const { roundsSurvived, dropsPerRound } = FloorIsLavaRules.reconstructRounds(gameActions);
-    return new FloorIsLava(roundsSurvived, dropsPerRound);
-  }
-
-  public canCashout(): boolean {
-    return this.roundsSurvived > 0;
-  }
-
-  public next(selectedTile: number, generator: RandomNumberGenerator, edge: number): FloorIsLavaNextResult {
-    if (!FloorIsLavaRules.isValidTile(selectedTile)) {
-      return { ok: false, error: 'invalid-tile' };
-    }
-
-    if (FloorIsLavaRules.tilesRemaining(this.roundsSurvived, this.dropsPerRound) <= 1) {
-      return { ok: false, error: 'no-tiles-remaining' };
-    }
-
-    const rounds = FloorIsLavaRules.getRoundResults(generator, this.dropsPerRound, this.roundsSurvived + 1);
-    const priorDrops = rounds.slice(0, this.roundsSurvived).flat();
-    if (priorDrops.includes(selectedTile)) {
-      return { ok: false, error: 'tile-already-dropped' };
-    }
-
-    const thisRoundDrops = rounds[this.roundsSurvived];
-    const isLoss = thisRoundDrops.includes(selectedTile);
-
-    const roundsSurvivedAfter = isLoss ? this.roundsSurvived : this.roundsSurvived + 1;
-    const isLastTile = FloorIsLavaRules.tilesRemaining(roundsSurvivedAfter, this.dropsPerRound) <= 1;
-    const multiplier = isLoss ? BigNumber(0) : FloorIsLavaRules.multiplier(roundsSurvivedAfter, this.dropsPerRound, edge);
-
-    const gameAction: FloorIsLavaSuccessfulPickAction | FloorIsLavaBustPickAction = isLoss
-      ? {
-          phase: FloorIsLavaActionPhase.BUST_PICK,
-          selectedTile,
-          droppedTiles: thisRoundDrops,
-          lastSurvivingTile: FloorIsLavaRules.lastSurvivingTile(generator),
-        }
-      : { phase: FloorIsLavaActionPhase.SUCCESSFUL_PICK, selectedTile, droppedTiles: thisRoundDrops, multiplier };
-
-    return {
-      ok: true,
-      multiplier,
-      gameAction,
-      isLoss,
-      isLastTile,
-    };
-  }
-
-  public cashout(generator: RandomNumberGenerator, edge: number): FloorIsLavaCashoutResult {
-    if (!this.canCashout()) {
-      return { ok: false, error: 'no-tiles-selected' };
-    }
-
-    const multiplier = FloorIsLavaRules.multiplier(this.roundsSurvived, this.dropsPerRound, edge);
-
-    return {
-      ok: true,
-      multiplier,
-      gameAction: { phase: FloorIsLavaActionPhase.CASHOUT, multiplier, lastSurvivingTile: FloorIsLavaRules.lastSurvivingTile(generator) },
-    };
-  }
-
-  public static autobet(
-    difficulty: FloorIsLavaDifficulty,
-    selectedTiles: number[],
-    generator: RandomNumberGenerator,
-    edge: number,
-  ): FloorIsLavaAutoBetResult {
-    if (selectedTiles.some(tile => !FloorIsLavaRules.isValidTile(tile))) {
-      return { ok: false, error: 'invalid-tile' };
-    }
-
-    const dropsPerRound = DIFFICULTY_DROP_MAP[difficulty];
-    const maxRounds = FloorIsLavaRules.maxRounds(difficulty);
-
-    if (selectedTiles.length < 1 || selectedTiles.length > maxRounds) {
-      return { ok: false, error: 'invalid-selected-tiles-count' };
-    }
-
-    const rounds = FloorIsLavaRules.getRoundResults(generator, dropsPerRound, selectedTiles.length);
-
-    const results: FloorIsLavaAutoBetRoundResult[] = [];
-    let survivedRounds = 0;
-    const lastSurvivingTile = FloorIsLavaRules.lastSurvivingTile(generator);
-
-    for (let round = 0; round < selectedTiles.length; round++) {
-      const selectedTile = selectedTiles[round];
-
-      const droppedTiles = rounds[round];
-
-      const priorDrops = results.flatMap(result => result.droppedTiles);
-      const isUnselectableDropTile = priorDrops.includes(selectedTile);
-      if (isUnselectableDropTile) {
-        results.push({ selectedTile, droppedTiles, outcome: FloorIsLavaAutoBetRoundOutcome.CASHED_OUT });
-        return {
-          ok: true,
-          multiplier: FloorIsLavaRules.multiplier(survivedRounds, dropsPerRound, edge),
-          results,
-          survivedRounds,
-          lastSurvivingTile,
-        };
-      }
-
-      const isLoss = droppedTiles.includes(selectedTile);
-      results.push({ selectedTile, droppedTiles, outcome: isLoss ? FloorIsLavaAutoBetRoundOutcome.LOST : FloorIsLavaAutoBetRoundOutcome.SURVIVED });
-
-      if (isLoss) {
-        return { ok: true, multiplier: BigNumber(0), results, survivedRounds, lastSurvivingTile };
-      }
-      survivedRounds++;
-    }
-
-    return {
-      ok: true,
-      multiplier: FloorIsLavaRules.multiplier(survivedRounds, dropsPerRound, edge),
-      results,
-      survivedRounds,
-      lastSurvivingTile,
-    };
-  }
-}