shufflecom-calculations 4.2.0 → 4.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shufflecom-calculations",
-  "version": "4.2.0",
+  "version": "4.2.2",
   "description": "",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
@@ -14,5 +14,5 @@
   },
   "author": "",
   "license": "ISC",
-  "gitHead": "2ea5541d42a97bbf62f7e8852af00179a4c17407"
+  "gitHead": "d4eb397581b49cd9c79a080502425f5d8e2fbe41"
 }

package/src/games/coinflip/coinflip-classic-progressive.spec.ts

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { FixedSequenceRng } from '../fixed-rng';
+import { FixedSequenceRng } from '../rng/fixed-rng';
 import {
   CoinflipClassicProgressive,
   CoinflipProgressiveCashoutAction,
@@ -130,7 +130,14 @@ describe('CoinflipClassicProgressive.next', () => {
   });
 
   it('a loss deep into a streak still pays zero', () => {
-    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.TAILS)]);
+    const rng = new FixedSequenceRng([
+      getCoinRngValue(CoinSide.HEADS),
+      getCoinRngValue(CoinSide.HEADS),
+      getCoinRngValue(CoinSide.HEADS),
+      getCoinRngValue(CoinSide.HEADS),
+      getCoinRngValue(CoinSide.HEADS),
+      getCoinRngValue(CoinSide.TAILS),
+    ]);
     expect(gameWithWins(5).next(CoinSide.HEADS, rng, EDGE_BPS)).toMatchObject({
       multiplier: new BigNumber(0),
       isWin: false,
@@ -178,7 +185,11 @@ describe('CoinflipClassicProgressive.next', () => {
   });
 
   it('throws when MAX_FLIPS are already revealed', () => {
-    const rng = new FixedSequenceRng(Array(MAX_FLIPS + 1).fill(CoinSide.HEADS).map(getCoinRngValue));
+    const rng = new FixedSequenceRng(
+      Array(MAX_FLIPS + 1)
+        .fill(CoinSide.HEADS)
+        .map(getCoinRngValue),
+    );
     expect(() => gameWithWins(MAX_FLIPS).next(CoinSide.HEADS, rng, EDGE_BPS)).toThrow();
   });
 });

package/src/games/coinflip/coinflip-classic-progressive.ts

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { RandomNumberGenerator } from '../random-number-generator.interface';
+import { RandomNumberGenerator } from '../rng/random-number-generator.interface';
 import { CoinflipRules } from './coinflip-rules';
 import { CoinSide, MAX_FLIPS } from './constants';
 

package/src/games/coinflip/coinflip-classic.spec.ts

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { FixedSequenceRng } from '../fixed-rng';
+import { FixedSequenceRng } from '../rng/fixed-rng';
 import { CoinflipClassic } from './coinflip-classic';
 import { CoinSide } from './constants';
 

package/src/games/coinflip/coinflip-classic.ts

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { RandomNumberGenerator } from '../random-number-generator.interface';
+import { RandomNumberGenerator } from '../rng/random-number-generator.interface';
 import { CoinflipRules } from './coinflip-rules';
 import { CoinSide } from './constants';
 

package/src/games/coinflip/coinflip-rules.spec.ts

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { FixedSequenceRng } from '../fixed-rng';
+import { FixedSequenceRng } from '../rng/fixed-rng';
 import {
   CoinflipProgressiveCashoutAction,
   CoinflipProgressiveCoinSelectionAction,

package/src/games/coinflip/coinflip-rules.ts

@@ -1,7 +1,7 @@
 import BigNumber from 'bignumber.js';
 import { calculateEdgeMultiplier } from '../../utils/edge';
 import { nCr } from '../../utils/ncr';
-import { RandomNumberGenerator } from '../random-number-generator.interface';
+import { RandomNumberGenerator } from '../rng/random-number-generator.interface';
 import type { CoinflipClassicProgressiveGameAction } from './coinflip-classic-progressive';
 import { CoinSide, MAX_FLIPS } from './constants';
 

package/src/games/coinflip/coinflip-target.spec.ts

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { FixedSequenceRng } from '../fixed-rng';
+import { FixedSequenceRng } from '../rng/fixed-rng';
 import { CoinflipTarget } from './coinflip-target';
 import { CoinSide, MAX_FLIPS } from './constants';
 

package/src/games/coinflip/coinflip-target.ts

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { RandomNumberGenerator } from '../random-number-generator.interface';
+import { RandomNumberGenerator } from '../rng/random-number-generator.interface';
 import { CoinflipRules } from './coinflip-rules';
 import { CoinSide } from './constants';
 

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

@@ -0,0 +1,61 @@
+import { FixedSequenceRng } from '../rng/fixed-rng';
+import { FloorIsLavaBoard } from './floor-is-lava-board';
+import { BOARD_SIZE } from './floor-is-lava-rules';
+
+const ASCENDING_BOARD = Array.from({ length: BOARD_SIZE }, (_, i) => i);
+
+// Builds the 147-value raw draw for a FixedSequenceRng from 3 explicit per-level boards (each a
+// permutation of 0..48), so a given level's contents can be controlled precisely in tests.
+const boardFromLevelBoards = (level0: number[], level1: number[], level2: number[]): FloorIsLavaBoard =>
+  FloorIsLavaBoard.draw(new FixedSequenceRng([...level0, ...level1.map(t => t + BOARD_SIZE), ...level2.map(t => t + BOARD_SIZE * 2)]));
+
+describe('FloorIsLavaBoard.draw', () => {
+  it('splits one 147-value shuffle by VALUE into 3 independent, order-preserving per-level boards', () => {
+    const raw: number[] = [];
+    for (let i = 0; i < BOARD_SIZE; i++) {
+      raw.push(i); // level 0: ascending
+      raw.push(BOARD_SIZE + (BOARD_SIZE - 1 - i)); // level 1: descending
+      raw.push(BOARD_SIZE * 2 + i); // level 2: ascending
+    }
+
+    const board = FloorIsLavaBoard.draw(new FixedSequenceRng(raw));
+
+    expect(board.remainingTilesInLevel(0, 0)).toEqual(ASCENDING_BOARD);
+    expect(board.remainingTilesInLevel(1, 0)).toEqual([...ASCENDING_BOARD].reverse());
+    expect(board.remainingTilesInLevel(2, 0)).toEqual(ASCENDING_BOARD);
+  });
+
+  it('draws independently per level - no leakage across levels', () => {
+    const board = boardFromLevelBoards(ASCENDING_BOARD, [...ASCENDING_BOARD].reverse(), ASCENDING_BOARD);
+
+    expect(board.remainingTilesInLevel(0, 0)).not.toEqual(board.remainingTilesInLevel(1, 0));
+  });
+});
+
+describe('FloorIsLavaBoard.tilesDroppedInRound', () => {
+  const board = boardFromLevelBoards(ASCENDING_BOARD, [...ASCENDING_BOARD].reverse(), ASCENDING_BOARD);
+
+  it('slices the requested round out of the level board', () => {
+    expect(board.tilesDroppedInRound(0, 7, 0)).toEqual([0, 1, 2, 3, 4, 5, 6]);
+  });
+
+  it('offsets by the round index within the level', () => {
+    expect(board.tilesDroppedInRound(0, 7, 1)).toEqual([7, 8, 9, 10, 11, 12, 13]);
+  });
+
+  it('pulls from the requested level, not always level 0', () => {
+    expect(board.tilesDroppedInRound(1, 7, 0)).toEqual([48, 47, 46, 45, 44, 43, 42]);
+  });
+});
+
+describe('FloorIsLavaBoard.remainingTilesInLevel', () => {
+  const board = boardFromLevelBoards(ASCENDING_BOARD, ASCENDING_BOARD, ASCENDING_BOARD);
+
+  it('returns everything in the level board after the consumed prefix', () => {
+    expect(board.remainingTilesInLevel(0, 42)).toEqual([42, 43, 44, 45, 46, 47, 48]);
+  });
+
+  it('reads from the requested level band', () => {
+    expect(board.remainingTilesInLevel(2, 45)).toEqual([45, 46, 47, 48]);
+  });
+});

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

@@ -0,0 +1,41 @@
+import { RandomNumberGenerator } from '../rng/random-number-generator.interface';
+import { BOARD_SIZE, LEVELS_PER_DIFFICULTY } from './floor-is-lava-rules';
+
+const assertValidLevel = (level: number): void => {
+  const validLevels = Array.from({ length: LEVELS_PER_DIFFICULTY }, (_, i) => i);
+  if (!validLevels.includes(level)) {
+    throw new Error(`FloorIsLava - invalid level ${level}; must be in [0, ${LEVELS_PER_DIFFICULTY})`);
+  }
+};
+
+export class FloorIsLavaBoard {
+  private readonly levelBoards: [number[], number[], number[]];
+
+  private constructor(generator: RandomNumberGenerator) {
+    const raw = generator.getRandomIntsWithoutReplacement({
+      min: 0,
+      max: BOARD_SIZE * LEVELS_PER_DIFFICULTY - 1,
+      count: BOARD_SIZE * LEVELS_PER_DIFFICULTY,
+    });
+
+    const boards: [number[], number[], number[]] = [[], [], []];
+    for (const value of raw) {
+      boards[Math.floor(value / BOARD_SIZE)].push(value % BOARD_SIZE);
+    }
+    this.levelBoards = boards;
+  }
+
+  public static draw(generator: RandomNumberGenerator): FloorIsLavaBoard {
+    return new FloorIsLavaBoard(generator);
+  }
+
+  public tilesDroppedInRound(level: number, dropsPerRound: number, roundIndex: number): number[] {
+    assertValidLevel(level);
+    return this.levelBoards[level].slice(roundIndex * dropsPerRound, (roundIndex + 1) * dropsPerRound);
+  }
+
+  public remainingTilesInLevel(level: number, tilesDroppedInCurrentLevel: number): number[] {
+    assertValidLevel(level);
+    return this.levelBoards[level].slice(tilesDroppedInCurrentLevel);
+  }
+}

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

@@ -0,0 +1,316 @@
+import BigNumber from 'bignumber.js';
+import { calculateEdgeMultiplier } from '../../utils/edge';
+import {
+  BOARD_SIZE,
+  DIFFICULTY_LEVEL_MAP,
+  FloorIsLavaActionPhase,
+  FloorIsLavaCashoutAction,
+  FloorIsLavaDifficulty,
+  FloorIsLavaGameStatus,
+  FloorIsLavaInProgressState,
+  FloorIsLavaPickAction,
+  FloorIsLavaRules,
+  FloorIsLavaStartAction,
+  SURVIVING_TILES_MAP,
+} from './floor-is-lava-rules';
+
+const EDGE_BPS = 200;
+
+const ALL_DIFFICULTIES = [FloorIsLavaDifficulty.EASY, FloorIsLavaDifficulty.MEDIUM, FloorIsLavaDifficulty.HARD, FloorIsLavaDifficulty.TOXIC];
+
+const stateAt = (difficulty: FloorIsLavaDifficulty, currentLevel: number, roundsSurvivedInCurrentLevel: number): FloorIsLavaInProgressState => ({
+  status: 'in-progress',
+  difficulty,
+  currentLevel,
+  roundsSurvivedInCurrentLevel,
+  droppedTilesByLevel: [[], [], []],
+});
+
+const startAction = (difficulty: FloorIsLavaDifficulty): FloorIsLavaStartAction => ({ phase: FloorIsLavaActionPhase.START, difficulty });
+
+const pickAction = (overrides: Partial<FloorIsLavaPickAction> = {}): FloorIsLavaPickAction => ({
+  phase: FloorIsLavaActionPhase.PICK,
+  level: 0,
+  selectedTile: 0,
+  droppedTiles: [],
+  gameStatus: FloorIsLavaGameStatus.IN_PROGRESS,
+  multiplier: new BigNumber(0),
+  ...overrides,
+});
+
+const cashoutAction = (overrides: Partial<FloorIsLavaCashoutAction> = {}): FloorIsLavaCashoutAction => ({
+  phase: FloorIsLavaActionPhase.CASHOUT,
+  level: 0,
+  multiplier: new BigNumber(1),
+  ...overrides,
+});
+
+describe('DIFFICULTY_LEVEL_MAP / SURVIVING_TILES_MAP', () => {
+  it.each(Object.values(FloorIsLavaDifficulty))('%s: dropsPerRound * roundsPerLevel + survivingTiles equals the board size', difficulty => {
+    const { dropsPerRound, roundsPerLevel } = DIFFICULTY_LEVEL_MAP[difficulty];
+    expect(dropsPerRound * roundsPerLevel + SURVIVING_TILES_MAP[difficulty]).toBe(BOARD_SIZE);
+  });
+});
+
+describe('FloorIsLavaRules.tilesRemaining', () => {
+  it('returns the full board when no rounds have been survived in the level', () => {
+    expect(FloorIsLavaRules.tilesRemaining(0, 7)).toBe(BOARD_SIZE);
+  });
+
+  it('subtracts dropped tiles for the rounds survived so far in the level', () => {
+    expect(FloorIsLavaRules.tilesRemaining(2, 7)).toBe(BOARD_SIZE - 14);
+  });
+});
+
+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, compounding survived levels', () => {
+    const expected = calculateEdgeMultiplier(EDGE_BPS)
+      .multipliedBy(new BigNumber(BOARD_SIZE).pow(2))
+      .dividedBy(new BigNumber(28).multipliedBy(new BigNumber(SURVIVING_TILES_MAP[FloorIsLavaDifficulty.EASY]).pow(1)));
+    expect(FloorIsLavaRules.multiplier(FloorIsLavaDifficulty.EASY, 1, 28, EDGE_BPS).isEqualTo(expected)).toBe(true);
+  });
+
+  it('is continuous at a level boundary: clearing a level equals the fresh multiplier one level deeper', () => {
+    const difficulty = FloorIsLavaDifficulty.EASY;
+    const survivingTiles = SURVIVING_TILES_MAP[difficulty];
+    const clearing = FloorIsLavaRules.multiplier(difficulty, 0, survivingTiles, EDGE_BPS); // just cleared level 0 (y = s)
+    const freshNextLevel = FloorIsLavaRules.multiplier(difficulty, 1, BOARD_SIZE, EDGE_BPS); // level 1, 0 rounds played (y = 49)
+    expect(clearing.isEqualTo(freshNextLevel)).toBe(true);
+  });
+});
+
+describe('FloorIsLavaRules.multipliers', () => {
+  it('returns the current-round and next-round multipliers derived from the state', () => {
+    const difficulty = FloorIsLavaDifficulty.EASY;
+    const { dropsPerRound } = DIFFICULTY_LEVEL_MAP[difficulty];
+    const state = stateAt(difficulty, 1, 2);
+
+    const result = FloorIsLavaRules.multipliers(state, EDGE_BPS);
+
+    expect(
+      result.currentMultiplier.isEqualTo(FloorIsLavaRules.multiplier(difficulty, 1, FloorIsLavaRules.tilesRemaining(2, dropsPerRound), EDGE_BPS)),
+    ).toBe(true);
+    expect(
+      result.nextMultiplier.isEqualTo(FloorIsLavaRules.multiplier(difficulty, 1, FloorIsLavaRules.tilesRemaining(3, dropsPerRound), EDGE_BPS)),
+    ).toBe(true);
+  });
+
+  it('reads dropsPerRound from the state difficulty, not a fixed value', () => {
+    const difficulty = FloorIsLavaDifficulty.HARD; // dropsPerRound 23
+    const { dropsPerRound } = DIFFICULTY_LEVEL_MAP[difficulty];
+    const state = stateAt(difficulty, 0, 0);
+
+    const result = FloorIsLavaRules.multipliers(state, EDGE_BPS);
+
+    expect(
+      result.nextMultiplier.isEqualTo(FloorIsLavaRules.multiplier(difficulty, 0, FloorIsLavaRules.tilesRemaining(1, dropsPerRound), EDGE_BPS)),
+    ).toBe(true);
+  });
+
+  it('applies the given edge, not a hardcoded value', () => {
+    const difficulty = FloorIsLavaDifficulty.MEDIUM;
+    const { dropsPerRound } = DIFFICULTY_LEVEL_MAP[difficulty];
+    const state = stateAt(difficulty, 0, 1);
+
+    const result = FloorIsLavaRules.multipliers(state, 500);
+
+    expect(
+      result.currentMultiplier.isEqualTo(FloorIsLavaRules.multiplier(difficulty, 0, FloorIsLavaRules.tilesRemaining(1, dropsPerRound), 500)),
+    ).toBe(true);
+  });
+
+  it('is continuous across a level boundary: nextMultiplier at the last round equals currentMultiplier fresh one level deeper', () => {
+    const difficulty = FloorIsLavaDifficulty.EASY;
+    const { roundsPerLevel } = DIFFICULTY_LEVEL_MAP[difficulty];
+
+    const { nextMultiplier } = FloorIsLavaRules.multipliers(stateAt(difficulty, 0, roundsPerLevel - 1), EDGE_BPS);
+    const { currentMultiplier } = FloorIsLavaRules.multipliers(stateAt(difficulty, 1, 0), EDGE_BPS);
+
+    expect(nextMultiplier.isEqualTo(currentMultiplier)).toBe(true);
+  });
+});
+
+describe('FloorIsLavaRules.reconstructState', () => {
+  describe('in-progress histories', () => {
+    it('counts IN_PROGRESS PICK actions within the current level and accumulates their drops', () => {
+      const actions = [
+        startAction(FloorIsLavaDifficulty.MEDIUM),
+        pickAction({ selectedTile: 20, droppedTiles: [0, 1, 2, 3] }),
+        pickAction({ selectedTile: 21, droppedTiles: [4, 5, 6, 7] }),
+      ];
+      expect(FloorIsLavaRules.reconstructState(actions)).toEqual({
+        status: 'in-progress',
+        difficulty: FloorIsLavaDifficulty.MEDIUM,
+        currentLevel: 0,
+        roundsSurvivedInCurrentLevel: 2,
+        droppedTilesByLevel: [[0, 1, 2, 3, 4, 5, 6, 7], [], []],
+      });
+    });
+
+    it('advances to the next level and resets rounds on LEVEL_COMPLETE, bucketing drops per level', () => {
+      const actions = [
+        startAction(FloorIsLavaDifficulty.MEDIUM),
+        pickAction({ selectedTile: 20, droppedTiles: [0, 1, 2, 3] }),
+        pickAction({ selectedTile: 21, droppedTiles: [4, 5, 6, 7], gameStatus: FloorIsLavaGameStatus.LEVEL_COMPLETE }),
+        pickAction({ level: 1, selectedTile: 30, droppedTiles: [10, 11, 12, 13] }),
+      ];
+      expect(FloorIsLavaRules.reconstructState(actions)).toEqual({
+        status: 'in-progress',
+        difficulty: FloorIsLavaDifficulty.MEDIUM,
+        currentLevel: 1,
+        roundsSurvivedInCurrentLevel: 1,
+        droppedTilesByLevel: [[0, 1, 2, 3, 4, 5, 6, 7], [10, 11, 12, 13], []],
+      });
+    });
+  });
+
+  describe('completed histories', () => {
+    it('does not throw on a CASHOUT action as the last action, returning a completed state', () => {
+      const actions = [
+        startAction(FloorIsLavaDifficulty.MEDIUM),
+        pickAction({ selectedTile: 20, droppedTiles: [0, 1, 2, 3] }),
+        cashoutAction({ level: 0, multiplier: new BigNumber(2) }),
+      ];
+      expect(FloorIsLavaRules.reconstructState(actions)).toEqual({
+        status: 'completed',
+        difficulty: FloorIsLavaDifficulty.MEDIUM,
+        currentLevel: 0,
+        roundsSurvivedInCurrentLevel: 1,
+        droppedTilesByLevel: [[0, 1, 2, 3], [], []],
+      });
+    });
+
+    it('does not throw on a LOST PICK action as the last action, and does not count it as a survived round', () => {
+      const actions = [
+        startAction(FloorIsLavaDifficulty.MEDIUM),
+        pickAction({ selectedTile: 20, droppedTiles: [0, 1, 2, 3] }),
+        pickAction({ selectedTile: 25, droppedTiles: [4, 5, 6, 7], gameStatus: FloorIsLavaGameStatus.LOST }),
+      ];
+      expect(FloorIsLavaRules.reconstructState(actions)).toEqual({
+        status: 'completed',
+        difficulty: FloorIsLavaDifficulty.MEDIUM,
+        currentLevel: 0,
+        roundsSurvivedInCurrentLevel: 1,
+        droppedTilesByLevel: [[0, 1, 2, 3, 4, 5, 6, 7], [], []],
+      });
+    });
+
+    it('does not throw on a COMPLETED PICK action as the last action, and counts it as a survived round', () => {
+      const actions = [
+        startAction(FloorIsLavaDifficulty.MEDIUM),
+        pickAction({ selectedTile: 20, droppedTiles: [0, 1, 2, 3] }),
+        pickAction({ selectedTile: 25, droppedTiles: [4, 5, 6, 7], gameStatus: FloorIsLavaGameStatus.COMPLETED }),
+      ];
+      expect(FloorIsLavaRules.reconstructState(actions)).toEqual({
+        status: 'completed',
+        difficulty: FloorIsLavaDifficulty.MEDIUM,
+        currentLevel: 0,
+        roundsSurvivedInCurrentLevel: 2,
+        droppedTilesByLevel: [[0, 1, 2, 3, 4, 5, 6, 7], [], []],
+      });
+    });
+  });
+
+  describe('validation errors', () => {
+    it('throws on an empty history', () => {
+      expect(() => FloorIsLavaRules.reconstructState([])).toThrow('First action must be START');
+    });
+
+    it('throws when the first action is not START', () => {
+      expect(() => FloorIsLavaRules.reconstructState([pickAction()])).toThrow('First action must be START');
+    });
+
+    it('throws when a START action appears after the first position', () => {
+      expect(() => FloorIsLavaRules.reconstructState([startAction(FloorIsLavaDifficulty.MEDIUM), startAction(FloorIsLavaDifficulty.MEDIUM)])).toThrow(
+        'START action can only appear as the first action',
+      );
+    });
+
+    it('throws when a CASHOUT action appears before the end of the history', () => {
+      expect(() => FloorIsLavaRules.reconstructState([startAction(FloorIsLavaDifficulty.MEDIUM), cashoutAction(), pickAction()])).toThrow(
+        'A CASHOUT action can only appear as the last action',
+      );
+    });
+
+    it('throws when a LOST PICK action appears before the end of the history', () => {
+      expect(() =>
+        FloorIsLavaRules.reconstructState([
+          startAction(FloorIsLavaDifficulty.MEDIUM),
+          pickAction({ gameStatus: FloorIsLavaGameStatus.LOST }),
+          pickAction(),
+        ]),
+      ).toThrow('A PICK action with gameStatus LOST can only appear as the last action');
+    });
+
+    it('throws when a COMPLETED PICK action appears before the end of the history', () => {
+      expect(() =>
+        FloorIsLavaRules.reconstructState([
+          startAction(FloorIsLavaDifficulty.MEDIUM),
+          pickAction({ gameStatus: FloorIsLavaGameStatus.COMPLETED }),
+          pickAction(),
+        ]),
+      ).toThrow('A PICK action with gameStatus COMPLETED can only appear as the last action');
+    });
+
+    it('throws when survived rounds exceed the level max', () => {
+      // TOXIC drops all 48 in one round, so its level max is 1 round
+      expect(() => FloorIsLavaRules.reconstructState([startAction(FloorIsLavaDifficulty.TOXIC), pickAction(), pickAction()])).toThrow(
+        'Reconstructed rounds (2) exceeds level max rounds (1)',
+      );
+    });
+
+    it('throws when more LEVEL_COMPLETE transitions occur than there are levels', () => {
+      const clear = () => pickAction({ gameStatus: FloorIsLavaGameStatus.LEVEL_COMPLETE });
+      expect(() => FloorIsLavaRules.reconstructState([startAction(FloorIsLavaDifficulty.MEDIUM), clear(), clear(), clear()])).toThrow(
+        'Reconstructed level (3) exceeds max level index (2)',
+      );
+    });
+  });
+});
+
+describe('FloorIsLava — hardcoded multiplier table (published EASY/MEDIUM/HARD/TOXIC reference values)', () => {
+  // [round, tilesRemainingAfterRound, level1Mult, level2Mult, level3Mult], transcribed from the published tables.
+  // levelN is the multiplier at levelsCleared (N-1) for the tilesRemaining reached after `round` picks in the current level.
+  const TABLES: Record<FloorIsLavaDifficulty, Array<[number, number, number, number, number]>> = {
+    [FloorIsLavaDifficulty.EASY]: [
+      [1, 42, 1.1433, 8.0033, 56.0233],
+      [2, 35, 1.372, 9.604, 67.228],
+      [3, 28, 1.715, 12.005, 84.035],
+      [4, 21, 2.2867, 16.0067, 112.0467],
+      [5, 14, 3.43, 24.01, 168.07],
+      [6, 7, 6.86, 48.02, 336.14],
+    ],
+    [FloorIsLavaDifficulty.MEDIUM]: [
+      [1, 38, 1.2637, 12.3841, 121.3642],
+      [2, 27, 1.7785, 17.4295, 170.8089],
+      [3, 16, 3.0012, 29.4123, 288.24],
+      [4, 5, 9.604, 94.1192, 922.3682],
+    ],
+    [FloorIsLavaDifficulty.HARD]: [
+      [1, 26, 1.8469, 30.1664, 492.718],
+      [2, 3, 16.0067, 261.4422, 4270.223],
+    ],
+    [FloorIsLavaDifficulty.TOXIC]: [[1, 1, 48.02, 2352.98, 115296.02]],
+  };
+
+  const cases = ALL_DIFFICULTIES.flatMap(difficulty =>
+    TABLES[difficulty].flatMap(([round, tilesRemaining, level1, level2, level3]) =>
+      [level1, level2, level3].map((expected, levelsCleared) => [difficulty, round, tilesRemaining, levelsCleared, expected] as const),
+    ),
+  );
+
+  it.each(cases)('%s round %i (tilesRemaining %i) at levelsCleared %i pays %f×', (difficulty, round, tilesRemaining, levelsCleared, expected) => {
+    expect(FloorIsLavaRules.tilesRemaining(round, DIFFICULTY_LEVEL_MAP[difficulty].dropsPerRound)).toBe(tilesRemaining);
+    expect(FloorIsLavaRules.multiplier(difficulty, levelsCleared, tilesRemaining, EDGE_BPS).toNumber()).toBeCloseTo(expected, 3);
+  });
+});