shufflecom-calculations 6.2.0 → 6.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shufflecom-calculations",
-  "version": "6.2.0",
+  "version": "6.3.0",
   "description": "",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
@@ -16,5 +16,5 @@
   },
   "author": "",
   "license": "ISC",
-  "gitHead": "fdea251fdf77e057a786892dc8697e8b8f288eb2"
+  "gitHead": "8a31556eca9eda402e9084c4da7836e411ea027e"
 }

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

@@ -0,0 +1,341 @@
+import BigNumber from 'bignumber.js';
+import { calculateEdgeMultiplier } from '../../utils/edge';
+import { FixedSequenceRng } from '../rng/fixed-rng';
+import { FloorIsLava } from './floor-is-lava';
+import { FloorIsLavaAutobet } from './floor-is-lava-autobet';
+import { FloorIsLavaBoard } from './floor-is-lava-board';
+import {
+  BOARD_SIZE,
+  DIFFICULTY_LEVEL_MAP,
+  FloorIsLavaActionPhase,
+  FloorIsLavaAutoBetStopReason,
+  FloorIsLavaDifficulty,
+  FloorIsLavaGameAction,
+  FloorIsLavaRules,
+  FloorIsLavaStartAction,
+  FloorIsLavaTilesByLevel,
+  LEVELS_PER_DIFFICULTY,
+  SURVIVING_TILES_MAP,
+} from './floor-is-lava-rules';
+
+const ALL_DIFFICULTIES = [FloorIsLavaDifficulty.EASY, FloorIsLavaDifficulty.MEDIUM, FloorIsLavaDifficulty.HARD, FloorIsLavaDifficulty.TOXIC];
+
+const EDGE_BPS = 200;
+
+const ASCENDING_BOARD = Array.from({ length: BOARD_SIZE }, (_, i) => i);
+
+const tilesByLevel = (forLevel: (level: number) => number[]): FloorIsLavaTilesByLevel => [forLevel(0), forLevel(1), forLevel(2)];
+
+const startAction = (difficulty: FloorIsLavaDifficulty): FloorIsLavaStartAction => ({ phase: FloorIsLavaActionPhase.START, difficulty });
+
+const expectOk = <T extends { ok: boolean }>(result: T): Extract<T, { ok: true }> => {
+  if (!result.ok) {
+    throw new Error(`expected ok result, got ${JSON.stringify(result)}`);
+  }
+  return result as Extract<T, { ok: true }>;
+};
+
+const expectedMultiplier = (difficulty: FloorIsLavaDifficulty, levelsCleared: number, tilesRemainingInLevel: number, edgeBps: number = EDGE_BPS) =>
+  calculateEdgeMultiplier(edgeBps)
+    .multipliedBy(BigNumber(BOARD_SIZE).pow(levelsCleared + 1))
+    .dividedBy(BigNumber(tilesRemainingInLevel).multipliedBy(BigNumber(SURVIVING_TILES_MAP[difficulty]).pow(levelsCleared)));
+
+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('FloorIsLavaAutobet.autoBet', () => {
+  // With an ascending board, EASY (7 drops x 6 rounds) drops [0..6] in round 0, [7..13] in round 1
+  // and so on, leaving [42..48] surviving. Tile 48 therefore survives every round of every level,
+  // for every difficulty - it is the plan a fully surviving run is built from.
+  const ALWAYS_SAFE_TILE = BOARD_SIZE - 1;
+  const ASCENDING_BOARDS = boardFromLevelBoards(ASCENDING_BOARD, ASCENDING_BOARD, ASCENDING_BOARD);
+
+  // Spreads `rounds` identical picks across the per-level plan the engine takes, filling each
+  // level's rounds in turn.
+  const planOf = (difficulty: FloorIsLavaDifficulty, tile: number, rounds: number): FloorIsLavaTilesByLevel => {
+    const { roundsPerLevel } = DIFFICULTY_LEVEL_MAP[difficulty];
+    return tilesByLevel(level => Array(Math.min(roundsPerLevel, Math.max(0, rounds - level * roundsPerLevel))).fill(tile));
+  };
+
+  const autoBet = (difficulty: FloorIsLavaDifficulty, selectedTilesByLevel: FloorIsLavaTilesByLevel, board: FloorIsLavaBoard = ASCENDING_BOARDS) =>
+    FloorIsLavaAutobet.autoBet(difficulty, selectedTilesByLevel, board, EDGE_BPS);
+
+  const survivingTiles = (difficulty: FloorIsLavaDifficulty, level: number) => ASCENDING_BOARDS.boards[level].slice(-SURVIVING_TILES_MAP[difficulty]);
+
+  const survivingTilesEachLevel = (difficulty: FloorIsLavaDifficulty) => tilesByLevel(level => survivingTiles(difficulty, level));
+
+  describe('rejected plans', () => {
+    it('rejects an empty plan', () => {
+      expect(autoBet(FloorIsLavaDifficulty.EASY, [[], [], []])).toEqual({ ok: false, error: 'no-tiles-selected' });
+    });
+
+    it.each(ALL_DIFFICULTIES)('%s: rejects a level holding more tiles than the level has rounds', difficulty => {
+      const oneTooMany = Array(DIFFICULTY_LEVEL_MAP[difficulty].roundsPerLevel + 1).fill(ALWAYS_SAFE_TILE);
+
+      expect(autoBet(difficulty, [oneTooMany, [], []])).toEqual({ ok: false, error: 'too-many-tiles-selected' });
+    });
+
+    // Every round of a level has to be planned to reach the next one, so a gap has no reading.
+    it('rejects a plan that skips ahead to a later level', () => {
+      expect(autoBet(FloorIsLavaDifficulty.EASY, [[ALWAYS_SAFE_TILE], [ALWAYS_SAFE_TILE], []])).toEqual({
+        ok: false,
+        error: 'incomplete-level-plan',
+      });
+    });
+
+    it.each([[-1], [BOARD_SIZE], [1.5]])('rejects a plan containing the out-of-range tile %s', tile => {
+      expect(autoBet(FloorIsLavaDifficulty.EASY, [[ALWAYS_SAFE_TILE, tile], [], []])).toEqual({ ok: false, error: 'invalid-tile' });
+    });
+  });
+
+  describe('runs that survive', () => {
+    it.each(ALL_DIFFICULTIES)('%s: a plan for every round of every level completes the game', difficulty => {
+      const rounds = FloorIsLavaRules.maxAutoBetSelections(difficulty);
+      const plan = planOf(difficulty, ALWAYS_SAFE_TILE, rounds);
+
+      const { gameAction } = expectOk(autoBet(difficulty, plan));
+
+      expect(gameAction).toMatchObject({
+        phase: FloorIsLavaActionPhase.AUTO_BET,
+        difficulty,
+        autoBetSelectedTiles: plan,
+        autoBetStopReason: FloorIsLavaAutoBetStopReason.COMPLETED,
+        level: LEVELS_PER_DIFFICULTY - 1,
+        autoBetTilesThatSurviveLevel: survivingTilesEachLevel(difficulty),
+      });
+      expect(gameAction.multiplier.isEqualTo(FloorIsLavaRules.multiplierAfterRounds(difficulty, rounds, EDGE_BPS))).toBe(true);
+    });
+
+    // The multiplier a surviving run of N rounds pays is exactly what the max-payout pre-check
+    // quotes for a plan of N tiles, so the two must not drift apart.
+    it.each(ALL_DIFFICULTIES)('%s: a fully surviving run pays the plan length multiplier at every length', difficulty => {
+      for (let rounds = 1; rounds <= FloorIsLavaRules.maxAutoBetSelections(difficulty); rounds++) {
+        const { gameAction } = expectOk(autoBet(difficulty, planOf(difficulty, ALWAYS_SAFE_TILE, rounds)));
+
+        expect(gameAction.multiplier.isEqualTo(FloorIsLavaRules.multiplierAfterRounds(difficulty, rounds, EDGE_BPS))).toBe(true);
+      }
+    });
+
+    it('a plan shorter than the board stops when it runs out and cashes out at the multiplier reached', () => {
+      const { gameAction } = expectOk(autoBet(FloorIsLavaDifficulty.EASY, planOf(FloorIsLavaDifficulty.EASY, ALWAYS_SAFE_TILE, 3)));
+
+      expect(gameAction).toMatchObject({
+        autoBetStopReason: FloorIsLavaAutoBetStopReason.SELECTIONS_EXHAUSTED,
+        level: 0,
+        autoBetTilesThatSurviveLevel: survivingTilesEachLevel(FloorIsLavaDifficulty.EASY),
+      });
+      expect(gameAction.multiplier.isEqualTo(expectedMultiplier(FloorIsLavaDifficulty.EASY, 0, BOARD_SIZE - 3 * 7))).toBe(true);
+    });
+
+    it('repeating a tile that has not dropped is allowed', () => {
+      const { gameAction } = expectOk(autoBet(FloorIsLavaDifficulty.EASY, planOf(FloorIsLavaDifficulty.EASY, ALWAYS_SAFE_TILE, 6)));
+
+      expect(gameAction.autoBetStopReason).toBe(FloorIsLavaAutoBetStopReason.SELECTIONS_EXHAUSTED);
+      expect(gameAction.multiplier.isEqualTo(FloorIsLavaRules.multiplierAfterRounds(FloorIsLavaDifficulty.EASY, 6, EDGE_BPS))).toBe(true);
+    });
+
+    // A plan that ends exactly on a level clear reports the level it cleared, not the one it would
+    // have moved on to - the same shape a manual LEVEL_COMPLETE pick has.
+    it('reports the level just cleared when the plan ends on a level boundary', () => {
+      const { gameAction } = expectOk(autoBet(FloorIsLavaDifficulty.EASY, planOf(FloorIsLavaDifficulty.EASY, ALWAYS_SAFE_TILE, 6)));
+
+      expect(gameAction).toMatchObject({ level: 0 });
+    });
+
+    it('carries the plan into the next level once a level is cleared', () => {
+      const { gameAction } = expectOk(autoBet(FloorIsLavaDifficulty.EASY, planOf(FloorIsLavaDifficulty.EASY, ALWAYS_SAFE_TILE, 7)));
+
+      expect(gameAction).toMatchObject({
+        autoBetStopReason: FloorIsLavaAutoBetStopReason.SELECTIONS_EXHAUSTED,
+        level: 1,
+        autoBetTilesThatSurviveLevel: survivingTilesEachLevel(FloorIsLavaDifficulty.EASY),
+      });
+    });
+  });
+
+  describe('runs that stop early', () => {
+    it('a pick that lands on lava loses the whole run', () => {
+      const { gameAction } = expectOk(autoBet(FloorIsLavaDifficulty.EASY, [[ALWAYS_SAFE_TILE, 8, ALWAYS_SAFE_TILE], [], []]));
+
+      expect(gameAction).toMatchObject({
+        autoBetStopReason: FloorIsLavaAutoBetStopReason.LOST,
+        level: 0,
+        autoBetTilesThatSurviveLevel: survivingTilesEachLevel(FloorIsLavaDifficulty.EASY),
+      });
+      expect(gameAction.multiplier.isZero()).toBe(true);
+    });
+
+    // The plan commits tile 5 for round 5, but tile 5 dropped back in round 1 - it can never be
+    // stood on again, so the run cashes out at the 4 rounds it did survive.
+    it('a pick on a tile dropped in an earlier round of the level cashes the run out there', () => {
+      const blockedLevelOne = [...Array(4).fill(ALWAYS_SAFE_TILE), 5, ALWAYS_SAFE_TILE];
+
+      const { gameAction } = expectOk(autoBet(FloorIsLavaDifficulty.EASY, [blockedLevelOne, [], []]));
+
+      expect(gameAction).toMatchObject({
+        autoBetStopReason: FloorIsLavaAutoBetStopReason.TILE_ALREADY_DROPPED,
+        autoBetSelectedTiles: [blockedLevelOne, [], []],
+        level: 0,
+      });
+      expect(gameAction.multiplier.isEqualTo(expectedMultiplier(FloorIsLavaDifficulty.EASY, 0, BOARD_SIZE - 4 * 7))).toBe(true);
+    });
+
+    // HARD clears a level in 2 rounds, so this plan reaches level 1 and then picks tile 0 - lava
+    // back in round 0 of level 0, but every level draws its own board, so it is playable again.
+    it('a tile dropped in a previous level is still pickable in the current one', () => {
+      const safeInLevel1 = [...ASCENDING_BOARD.filter(tile => tile !== 0), 0];
+      const board = boardFromLevelBoards(ASCENDING_BOARD, safeInLevel1, ASCENDING_BOARD);
+
+      const { gameAction } = expectOk(autoBet(FloorIsLavaDifficulty.HARD, [[ALWAYS_SAFE_TILE, ALWAYS_SAFE_TILE], [0], []], board));
+
+      expect(gameAction).toMatchObject({ autoBetStopReason: FloorIsLavaAutoBetStopReason.SELECTIONS_EXHAUSTED, level: 1 });
+      expect(gameAction.multiplier.isEqualTo(FloorIsLavaRules.multiplierAfterRounds(FloorIsLavaDifficulty.HARD, 3, EDGE_BPS))).toBe(true);
+    });
+  });
+
+  it('stores the committed plan as it was submitted, one array per level', () => {
+    const { gameAction } = expectOk(autoBet(FloorIsLavaDifficulty.EASY, [[ALWAYS_SAFE_TILE], [], []]));
+
+    expect(gameAction.autoBetSelectedTiles).toEqual([[ALWAYS_SAFE_TILE], [], []]);
+  });
+
+  // Every level's board is spent the moment the run ends, so the survivors are recorded for all
+  // three - a reader never has to know where the run stopped to render the levels around it.
+  it('reveals the tiles that survive every level, not just the level the run ended on', () => {
+    const { gameAction } = expectOk(autoBet(FloorIsLavaDifficulty.EASY, [[ALWAYS_SAFE_TILE, 8], [], []]));
+
+    expect(gameAction).toMatchObject({ autoBetStopReason: FloorIsLavaAutoBetStopReason.LOST, level: 0 });
+    expect(gameAction.autoBetTilesThatSurviveLevel).toEqual(survivingTilesEachLevel(FloorIsLavaDifficulty.EASY));
+  });
+});
+
+// The frontend reads a finished bet the same way whatever produced it: fold the actions into a
+// state, then subtract the dropped tiles from the board to see what is still standing.
+describe('reading an autobet run back', () => {
+  const EASY = FloorIsLavaDifficulty.EASY;
+  const { dropsPerRound, roundsPerLevel } = DIFFICULTY_LEVEL_MAP[EASY];
+  const ALWAYS_SAFE_TILE = BOARD_SIZE - 1;
+  const board = boardFromLevelBoards(ASCENDING_BOARD, ASCENDING_BOARD, ASCENDING_BOARD);
+
+  const runOf = (selectedTilesByLevel: FloorIsLavaTilesByLevel) =>
+    expectOk(FloorIsLavaAutobet.autoBet(EASY, selectedTilesByLevel, board, EDGE_BPS)).gameAction;
+
+  const stillStanding = (droppedTilesInLevel: number[]) =>
+    Array.from({ length: BOARD_SIZE }, (_, tile) => tile).filter(tile => !droppedTilesInLevel.includes(tile));
+
+  it('reconstructs a run that stopped mid-level without a START action to lead it', () => {
+    const gameAction = runOf([Array(3).fill(ALWAYS_SAFE_TILE), [], []]);
+
+    expect(FloorIsLavaRules.reconstructState([gameAction])).toEqual({
+      status: 'completed',
+      difficulty: EASY,
+      currentLevel: 0,
+      roundsSurvivedInCurrentLevel: 3,
+      droppedTilesByLevel: [ASCENDING_BOARD.slice(0, 3 * dropsPerRound), [], []],
+    });
+  });
+
+  it('reconstructs a run that reached a later level', () => {
+    const gameAction = runOf([Array(roundsPerLevel).fill(ALWAYS_SAFE_TILE), [ALWAYS_SAFE_TILE], []]);
+
+    expect(FloorIsLavaRules.reconstructState([gameAction])).toMatchObject({
+      currentLevel: 1,
+      roundsSurvivedInCurrentLevel: 1,
+      droppedTilesByLevel: [ASCENDING_BOARD.slice(0, roundsPerLevel * dropsPerRound), ASCENDING_BOARD.slice(0, dropsPerRound), []],
+    });
+  });
+
+  // The losing round was played - its drops are recorded - but it was not survived.
+  it('does not count the losing round as survived', () => {
+    const gameAction = runOf([[ALWAYS_SAFE_TILE, 8], [], []]);
+
+    expect(gameAction.autoBetDroppedTiles[0]).toEqual(ASCENDING_BOARD.slice(0, 2 * dropsPerRound));
+    expect(FloorIsLavaRules.reconstructState([gameAction])).toMatchObject({ currentLevel: 0, roundsSurvivedInCurrentLevel: 1 });
+  });
+
+  it('rejects an AUTO_BET action mixed into a manual history', () => {
+    const gameAction = runOf([[ALWAYS_SAFE_TILE], [], []]);
+
+    expect(() => FloorIsLavaRules.reconstructState([startAction(EASY), gameAction])).toThrow(/cannot appear alongside/);
+    expect(() => FloorIsLavaRules.reconstructState([gameAction, gameAction])).toThrow(/cannot appear alongside/);
+  });
+
+  it('gives the tiles still standing when the run stopped, not just the ones that survive the level', () => {
+    const gameAction = runOf([Array(4).fill(ALWAYS_SAFE_TILE), [], []]);
+
+    const standing = stillStanding(gameAction.autoBetDroppedTiles[0]);
+    expect(standing).toHaveLength(BOARD_SIZE - 4 * dropsPerRound);
+    // the 7 that survive the whole level are a subset of the 21 standing after 4 of 6 rounds
+    expect(standing).toEqual(expect.arrayContaining(gameAction.autoBetTilesThatSurviveLevel[0]));
+    expect(gameAction.autoBetTilesThatSurviveLevel[0]).toHaveLength(SURVIVING_TILES_MAP[EASY]);
+  });
+
+  // An autobet run and a manual game that reached the same position must fold to the same state,
+  // or the frontend renders a different board depending on how the bet was placed. The level
+  // boundary is the case that catches a drift: the run's last pick was played on the level it
+  // cleared, but the player is standing at the start of the next one.
+  it.each(ALL_DIFFICULTIES)('%s: folds to the same state a manual game of the same length does', difficulty => {
+    const { roundsPerLevel } = DIFFICULTY_LEVEL_MAP[difficulty];
+    const levelBoards = boardFromLevelBoards(ASCENDING_BOARD, ASCENDING_BOARD, ASCENDING_BOARD);
+    const safeTile = BOARD_SIZE - 1;
+
+    for (let rounds = 1; rounds <= FloorIsLavaRules.maxAutoBetSelections(difficulty); rounds++) {
+      const manualHistory: FloorIsLavaGameAction[] = [startAction(difficulty)];
+      for (let round = 0; round < rounds; round++) {
+        manualHistory.push(expectOk(FloorIsLava.fromActions(manualHistory).next(safeTile, levelBoards, EDGE_BPS)).gameAction);
+      }
+
+      const plan = tilesByLevel(level => Array(Math.min(roundsPerLevel, Math.max(0, rounds - level * roundsPerLevel))).fill(safeTile));
+      const run = expectOk(FloorIsLavaAutobet.autoBet(difficulty, plan, levelBoards, EDGE_BPS)).gameAction;
+
+      const { status: _manualStatus, ...manualState } = FloorIsLavaRules.reconstructState(manualHistory);
+      const { status: _autoStatus, ...autoState } = FloorIsLavaRules.reconstructState([run]);
+
+      expect({ rounds, ...autoState }).toEqual({ rounds, ...manualState });
+    }
+  });
+
+  // Same property for runs that end on lava. The losing round is played - its drops are recorded -
+  // but it is not survived, so the fold has to discount it or an autobet loss reads as one round
+  // further along than the manual game that lost in the same place.
+  it.each(ALL_DIFFICULTIES)('%s: a losing run folds to the same state a manual loss does', difficulty => {
+    const { roundsPerLevel, dropsPerRound } = DIFFICULTY_LEVEL_MAP[difficulty];
+    const levelBoards = boardFromLevelBoards(ASCENDING_BOARD, ASCENDING_BOARD, ASCENDING_BOARD);
+    const safeTile = BOARD_SIZE - 1;
+
+    for (let survived = 0; survived < FloorIsLavaRules.maxAutoBetSelections(difficulty); survived++) {
+      // on an ascending board, the first tile to drop in a round is roundIndex * dropsPerRound
+      const fatalTile = (survived % roundsPerLevel) * dropsPerRound;
+      const picks = [...Array(survived).fill(safeTile), fatalTile];
+
+      const manualHistory: FloorIsLavaGameAction[] = [startAction(difficulty)];
+      for (const tile of picks) {
+        manualHistory.push(expectOk(FloorIsLava.fromActions(manualHistory).next(tile, levelBoards, EDGE_BPS)).gameAction);
+      }
+
+      const plan = tilesByLevel(level => picks.slice(level * roundsPerLevel, (level + 1) * roundsPerLevel));
+      const run = expectOk(FloorIsLavaAutobet.autoBet(difficulty, plan, levelBoards, EDGE_BPS)).gameAction;
+
+      expect(run.autoBetStopReason).toBe(FloorIsLavaAutoBetStopReason.LOST);
+      expect(run.multiplier.isZero()).toBe(true);
+
+      const { status: _manualStatus, ...manualState } = FloorIsLavaRules.reconstructState(manualHistory);
+      const { status: _autoStatus, ...autoState } = FloorIsLavaRules.reconstructState([run]);
+
+      expect({ survived, ...autoState }).toEqual({ survived, ...manualState });
+      expect(autoState.roundsSurvivedInCurrentLevel).toBe(survived % roundsPerLevel);
+    }
+  });
+
+  it("slices a level's drops back into the rounds they fell in", () => {
+    const gameAction = runOf([Array(3).fill(ALWAYS_SAFE_TILE), [], []]);
+    const dropped = gameAction.autoBetDroppedTiles[0];
+
+    expect(FloorIsLavaRules.roundsPlayedInLevel(EASY, dropped)).toBe(3);
+    expect([0, 1, 2].map(round => dropped.slice(round * dropsPerRound, (round + 1) * dropsPerRound))).toEqual([
+      board.tilesDroppedInRound(0, dropsPerRound, 0),
+      board.tilesDroppedInRound(0, dropsPerRound, 1),
+      board.tilesDroppedInRound(0, dropsPerRound, 2),
+    ]);
+  });
+});

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

@@ -0,0 +1,118 @@
+import BigNumber from 'bignumber.js';
+import { FloorIsLava } from './floor-is-lava';
+import { FloorIsLavaBoard } from './floor-is-lava-board';
+import {
+  DIFFICULTY_LEVEL_MAP,
+  FloorIsLavaActionPhase,
+  FloorIsLavaAutoBetAction,
+  FloorIsLavaAutoBetStopReason,
+  FloorIsLavaDifficulty,
+  FloorIsLavaGameAction,
+  FloorIsLavaGameStatus,
+  FloorIsLavaRules,
+  type FloorIsLavaTilesByLevel,
+  SURVIVING_TILES_MAP,
+} from './floor-is-lava-rules';
+
+export type FloorIsLavaAutoBetPlanError = 'no-tiles-selected' | 'too-many-tiles-selected' | 'incomplete-level-plan' | 'invalid-tile';
+
+export type FloorIsLavaAutoBetPlanResult = { ok: true; plannedTiles: number[] } | { ok: false; error: FloorIsLavaAutoBetPlanError };
+
+export type FloorIsLavaAutoBetError = FloorIsLavaAutoBetPlanError | 'no-rounds-played' | 'no-tiles-remaining';
+
+export type FloorIsLavaAutoBetResult = { ok: true; gameAction: FloorIsLavaAutoBetAction } | { ok: false; error: FloorIsLavaAutoBetError };
+
+export class FloorIsLavaAutobet {
+  public static validateAutoBetPlan(difficulty: FloorIsLavaDifficulty, selectedTilesByLevel: FloorIsLavaTilesByLevel): FloorIsLavaAutoBetPlanResult {
+    const { roundsPerLevel } = DIFFICULTY_LEVEL_MAP[difficulty];
+
+    if (selectedTilesByLevel.some(tiles => tiles.length > roundsPerLevel)) {
+      return { ok: false, error: 'too-many-tiles-selected' };
+    }
+    const firstUnfinishedLevel = selectedTilesByLevel.findIndex(tiles => tiles.length < roundsPerLevel);
+    if (firstUnfinishedLevel !== -1 && selectedTilesByLevel.slice(firstUnfinishedLevel + 1).some(tiles => tiles.length > 0)) {
+      return { ok: false, error: 'incomplete-level-plan' };
+    }
+
+    const plannedTiles = selectedTilesByLevel.flat();
+
+    if (plannedTiles.length === 0) {
+      return { ok: false, error: 'no-tiles-selected' };
+    }
+    if (plannedTiles.some(tile => !FloorIsLavaRules.isValidTile(tile))) {
+      return { ok: false, error: 'invalid-tile' };
+    }
+
+    return { ok: true, plannedTiles };
+  }
+
+  public static autoBet(
+    difficulty: FloorIsLavaDifficulty,
+    selectedTilesByLevel: FloorIsLavaTilesByLevel,
+    board: FloorIsLavaBoard,
+    edge: number,
+  ): FloorIsLavaAutoBetResult {
+    const plan = FloorIsLavaAutobet.validateAutoBetPlan(difficulty, selectedTilesByLevel);
+    if (!plan.ok) {
+      return plan;
+    }
+
+    const history: FloorIsLavaGameAction[] = [FloorIsLava.createAction(difficulty)];
+    const droppedTilesByLevel: FloorIsLavaTilesByLevel = [[], [], []];
+    let multiplier = BigNumber(0);
+    let level = 0;
+    let stopReason = FloorIsLavaAutoBetStopReason.SELECTIONS_EXHAUSTED;
+
+    for (const selectedTile of plan.plannedTiles) {
+      const result = FloorIsLava.fromActions(history).next(selectedTile, board, edge);
+
+      if (!result.ok) {
+        switch (result.error) {
+          case 'tile-already-dropped':
+            stopReason = FloorIsLavaAutoBetStopReason.TILE_ALREADY_DROPPED;
+            break;
+          case 'no-tiles-remaining':
+          case 'invalid-tile':
+            return { ok: false, error: result.error };
+          default:
+            return result.error satisfies never;
+        }
+
+        break;
+      }
+
+      const { gameAction } = result;
+      history.push(gameAction);
+      droppedTilesByLevel[gameAction.level].push(...gameAction.droppedTiles);
+      level = gameAction.level;
+      multiplier = gameAction.multiplier;
+
+      if (gameAction.gameStatus === FloorIsLavaGameStatus.LOST) {
+        stopReason = FloorIsLavaAutoBetStopReason.LOST;
+        break;
+      }
+      if (gameAction.gameStatus === FloorIsLavaGameStatus.COMPLETED) {
+        stopReason = FloorIsLavaAutoBetStopReason.COMPLETED;
+        break;
+      }
+    }
+
+    if (history.length === 1) {
+      return { ok: false, error: 'no-rounds-played' };
+    }
+
+    return {
+      ok: true,
+      gameAction: {
+        phase: FloorIsLavaActionPhase.AUTO_BET,
+        difficulty,
+        autoBetSelectedTiles: selectedTilesByLevel,
+        autoBetDroppedTiles: droppedTilesByLevel,
+        autoBetTilesThatSurviveLevel: board.tilesThatSurviveEachLevel(SURVIVING_TILES_MAP[difficulty]),
+        autoBetStopReason: stopReason,
+        level,
+        multiplier,
+      },
+    };
+  }
+}

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

@@ -59,3 +59,21 @@ describe('FloorIsLavaBoard.tilesThatSurviveLevel', () => {
     expect(board.tilesThatSurviveLevel(2, 4)).toEqual([45, 46, 47, 48]);
   });
 });
+
+describe('FloorIsLavaBoard.tilesThatSurviveEachLevel', () => {
+  // All three level boards differ, so a repeated or swapped level index cannot pass.
+  const ROTATED_BOARD = [...ASCENDING_BOARD.slice(1), 0];
+  const board = boardFromLevelBoards(ASCENDING_BOARD, [...ASCENDING_BOARD].reverse(), ROTATED_BOARD);
+
+  it('returns the survivors of every level, each read from its own level band', () => {
+    expect(board.tilesThatSurviveEachLevel(3)).toEqual([
+      [46, 47, 48],
+      [2, 1, 0],
+      [47, 48, 0],
+    ]);
+  });
+
+  it('gives each level exactly what tilesThatSurviveLevel gives for it', () => {
+    expect(board.tilesThatSurviveEachLevel(7)).toEqual([0, 1, 2].map(level => board.tilesThatSurviveLevel(level, 7)));
+  });
+});

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

@@ -1,5 +1,5 @@
 import { RandomNumberGenerator } from '../rng/random-number-generator.interface';
-import { BOARD_SIZE, LEVELS_PER_DIFFICULTY } from './floor-is-lava-rules';
+import { BOARD_SIZE, type FloorIsLavaTilesByLevel, LEVELS_PER_DIFFICULTY } from './floor-is-lava-rules';
 
 const assertValidLevel = (level: number): void => {
   const validLevels = Array.from({ length: LEVELS_PER_DIFFICULTY }, (_, i) => i);
@@ -9,9 +9,9 @@ const assertValidLevel = (level: number): void => {
 };
 
 export class FloorIsLavaBoard {
-  private readonly levelBoards: [number[], number[], number[]];
+  private readonly levelBoards: FloorIsLavaTilesByLevel;
 
-  get boards(): [number[], number[], number[]] {
+  get boards(): FloorIsLavaTilesByLevel {
     return this.levelBoards;
   }
 
@@ -22,7 +22,7 @@ export class FloorIsLavaBoard {
       count: BOARD_SIZE * LEVELS_PER_DIFFICULTY,
     });
 
-    const boards: [number[], number[], number[]] = [[], [], []];
+    const boards: FloorIsLavaTilesByLevel = [[], [], []];
     for (const value of raw) {
       boards[Math.floor(value / BOARD_SIZE)].push(value % BOARD_SIZE);
     }
@@ -42,4 +42,12 @@ export class FloorIsLavaBoard {
     assertValidLevel(level);
     return this.levelBoards[level].slice(-survivingTilesCount);
   }
+
+  public tilesThatSurviveEachLevel(survivingTilesCount: number): FloorIsLavaTilesByLevel {
+    return [
+      this.tilesThatSurviveLevel(0, survivingTilesCount),
+      this.tilesThatSurviveLevel(1, survivingTilesCount),
+      this.tilesThatSurviveLevel(2, survivingTilesCount),
+    ];
+  }
 }

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

@@ -2,7 +2,10 @@ import BigNumber from 'bignumber.js';
 import { calculateEdgeMultiplier } from '../../utils/edge';
 
 export const BOARD_SIZE = 49;
-export const LEVELS_PER_DIFFICULTY = 3;
+
+export type FloorIsLavaTilesByLevel = [number[], number[], number[]];
+
+export const LEVELS_PER_DIFFICULTY: FloorIsLavaTilesByLevel['length'] = 3;
 
 export enum FloorIsLavaDifficulty {
   EASY = 'EASY',
@@ -43,6 +46,7 @@ export enum FloorIsLavaActionPhase {
   START = 'START',
   PICK = 'PICK',
   CASHOUT = 'CASHOUT',
+  AUTO_BET = 'AUTO_BET',
 }
 
 export enum FloorIsLavaGameStatus {
@@ -66,6 +70,24 @@ export type FloorIsLavaPickAction = {
   multiplier: BigNumber;
 };
 
+export enum FloorIsLavaAutoBetStopReason {
+  LOST = 'LOST',
+  COMPLETED = 'COMPLETED',
+  TILE_ALREADY_DROPPED = 'TILE_ALREADY_DROPPED',
+  SELECTIONS_EXHAUSTED = 'SELECTIONS_EXHAUSTED',
+}
+
+export interface FloorIsLavaAutoBetAction {
+  phase: FloorIsLavaActionPhase.AUTO_BET;
+  difficulty: FloorIsLavaDifficulty;
+  autoBetSelectedTiles: FloorIsLavaTilesByLevel;
+  autoBetDroppedTiles: FloorIsLavaTilesByLevel;
+  autoBetTilesThatSurviveLevel: FloorIsLavaTilesByLevel;
+  autoBetStopReason: FloorIsLavaAutoBetStopReason;
+  level: number;
+  multiplier: BigNumber;
+}
+
 export interface FloorIsLavaCashoutAction {
   phase: FloorIsLavaActionPhase.CASHOUT;
   level: number;
@@ -74,11 +96,13 @@ export interface FloorIsLavaCashoutAction {
 
 export type FloorIsLavaGameAction = FloorIsLavaStartAction | FloorIsLavaPickAction | FloorIsLavaCashoutAction;
 
+export type FloorIsLavaStoredAction = FloorIsLavaGameAction | FloorIsLavaAutoBetAction;
+
 interface FloorIsLavaBaseState {
   difficulty: FloorIsLavaDifficulty;
   currentLevel: number;
   roundsSurvivedInCurrentLevel: number;
-  droppedTilesByLevel: number[][];
+  droppedTilesByLevel: FloorIsLavaTilesByLevel;
 }
 
 export interface FloorIsLavaInProgressState extends FloorIsLavaBaseState {
@@ -104,6 +128,14 @@ export class FloorIsLavaRules {
     return BOARD_SIZE - roundsSurvivedInCurrentLevel * dropsPerRound;
   }
 
+  public static maxAutoBetSelections(difficulty: FloorIsLavaDifficulty): number {
+    return DIFFICULTY_LEVEL_MAP[difficulty].roundsPerLevel * LEVELS_PER_DIFFICULTY;
+  }
+
+  public static roundsPlayedInLevel(difficulty: FloorIsLavaDifficulty, droppedTilesInLevel: number[]): number {
+    return droppedTilesInLevel.length / DIFFICULTY_LEVEL_MAP[difficulty].dropsPerRound;
+  }
+
   public static isValidTile(tile: number): boolean {
     return Number.isInteger(tile) && tile >= 0 && tile <= BOARD_SIZE - 1;
   }
@@ -139,8 +171,38 @@ export class FloorIsLavaRules {
     };
   }
 
-  public static reconstructState(gameActions: FloorIsLavaGameAction[]): FloorIsLavaReconstructedState {
+  public static multiplierAfterRounds(difficulty: FloorIsLavaDifficulty, roundsSurvived: number, edge: number): BigNumber {
+    const { dropsPerRound, roundsPerLevel } = DIFFICULTY_LEVEL_MAP[difficulty];
+    const levelsCleared = Math.floor(roundsSurvived / roundsPerLevel);
+    const roundsInCurrentLevel = roundsSurvived % roundsPerLevel;
+
+    return FloorIsLavaRules.multiplier(difficulty, levelsCleared, FloorIsLavaRules.tilesRemaining(roundsInCurrentLevel, dropsPerRound), edge);
+  }
+
+  public static reconstructState(gameActions: FloorIsLavaStoredAction[]): FloorIsLavaReconstructedState {
     const first = gameActions[0];
+
+    if (first?.phase === FloorIsLavaActionPhase.AUTO_BET) {
+      if (gameActions.length > 1) {
+        throw new Error('An AUTO_BET action is the whole game and cannot appear alongside other actions');
+      }
+
+      const { roundsPerLevel } = DIFFICULTY_LEVEL_MAP[first.difficulty];
+      const roundsPlayed = FloorIsLavaRules.roundsPlayedInLevel(first.difficulty, first.autoBetDroppedTiles[first.level]);
+      const lostTheLastRound = first.autoBetStopReason === FloorIsLavaAutoBetStopReason.LOST;
+      const roundsSurvived = lostTheLastRound ? roundsPlayed - 1 : roundsPlayed;
+
+      const clearedANonFinalLevel = !lostTheLastRound && roundsSurvived === roundsPerLevel && first.level < LEVELS_PER_DIFFICULTY - 1;
+
+      return {
+        status: 'completed',
+        difficulty: first.difficulty,
+        currentLevel: clearedANonFinalLevel ? first.level + 1 : first.level,
+        roundsSurvivedInCurrentLevel: clearedANonFinalLevel ? 0 : roundsSurvived,
+        droppedTilesByLevel: first.autoBetDroppedTiles,
+      };
+    }
+
     if (!first || first.phase !== FloorIsLavaActionPhase.START) {
       throw new Error('First action must be START');
     }
@@ -149,7 +211,7 @@ export class FloorIsLavaRules {
     const { roundsPerLevel } = DIFFICULTY_LEVEL_MAP[difficulty];
     let currentLevel = 0;
     let roundsSurvivedInCurrentLevel = 0;
-    const droppedTilesByLevel: number[][] = Array.from({ length: LEVELS_PER_DIFFICULTY }, () => []);
+    const droppedTilesByLevel: FloorIsLavaTilesByLevel = [[], [], []];
 
     for (let i = 1; i < gameActions.length; i++) {
       const action = gameActions[i];
@@ -160,6 +222,10 @@ export class FloorIsLavaRules {
           throw new Error('START action can only appear as the first action');
         }
 
+        case FloorIsLavaActionPhase.AUTO_BET: {
+          throw new Error('An AUTO_BET action is the whole game and cannot appear alongside other actions');
+        }
+
         case FloorIsLavaActionPhase.CASHOUT: {
           if (!isLastAction) {
             throw new Error('A CASHOUT action can only appear as the last action');