shufflecom-calculations 4.1.2 → 4.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shufflecom-calculations",
-  "version": "4.1.2",
+  "version": "4.1.3",
   "description": "",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
@@ -14,5 +14,5 @@
   },
   "author": "",
   "license": "ISC",
-  "gitHead": "4bbe832ca80faa167ab6dc578db44b6909747b0c"
+  "gitHead": "6da0f7d26f1edf330169aee529b2feec23db3443"
 }

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

@@ -4,17 +4,23 @@ import { FixedSequenceRng } from './fixed-rng';
 import {
   BOARD_SIZE,
   DIFFICULTY_DROP_MAP,
+  FloorIsLavaActionPhase,
   FloorIsLavaDifficulty,
-  FloorIsLavaPickAction,
   FloorIsLavaRules,
   FloorIsLavaStartAction,
+  FloorIsLavaSuccessfulPickAction,
 } from './floor-is-lava-rules';
 
 const EDGE_BPS = 200;
 
-const startAction = (difficulty: FloorIsLavaDifficulty): FloorIsLavaStartAction => ({ phase: 'START', difficulty });
+const startAction = (difficulty: FloorIsLavaDifficulty): FloorIsLavaStartAction => ({ phase: FloorIsLavaActionPhase.START, difficulty });
 
-const pickAction = (): FloorIsLavaPickAction => ({ phase: 'PICK', selectedTile: 0, droppedTiles: [], multiplier: new BigNumber(0) });
+const pickAction = (): FloorIsLavaSuccessfulPickAction => ({
+  phase: FloorIsLavaActionPhase.SUCCESSFUL_PICK,
+  selectedTile: 0,
+  droppedTiles: [],
+  multiplier: new BigNumber(0),
+});
 
 describe('FloorIsLavaRules.maxRounds', () => {
   it.each([
@@ -67,6 +73,14 @@ describe('FloorIsLavaRules.getRoundResults', () => {
   });
 });
 
+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()];
@@ -88,10 +102,22 @@ describe('FloorIsLavaRules.reconstructRounds', () => {
 
   it('throws when a CASHOUT action appears in the history', () => {
     expect(() =>
-      FloorIsLavaRules.reconstructRounds([startAction(FloorIsLavaDifficulty.MEDIUM), { phase: 'CASHOUT', multiplier: new BigNumber(1) }]),
+      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

@@ -21,24 +21,43 @@ export const DIFFICULTY_DROP_MAP: Readonly<Record<FloorIsLavaDifficulty, number>
 
 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: 'START';
+  phase: FloorIsLavaActionPhase.START;
   difficulty: FloorIsLavaDifficulty;
 }
 
-export interface FloorIsLavaPickAction {
-  phase: 'PICK';
+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: 'CASHOUT';
+  phase: FloorIsLavaActionPhase.CASHOUT;
   multiplier: BigNumber;
+  lastSurvivingTile: number;
 }
 
-export type FloorIsLavaGameAction = FloorIsLavaStartAction | FloorIsLavaPickAction | FloorIsLavaCashoutAction;
+export type FloorIsLavaGameAction =
+  | FloorIsLavaStartAction
+  | FloorIsLavaSuccessfulPickAction
+  | FloorIsLavaBustPickAction
+  | FloorIsLavaCashoutAction;
 
 export class FloorIsLavaRules {
   public static maxRounds(difficulty: FloorIsLavaDifficulty): number {
@@ -58,6 +77,11 @@ export class FloorIsLavaRules {
     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 });
 
@@ -70,7 +94,7 @@ export class FloorIsLavaRules {
 
   public static reconstructRounds(gameActions: FloorIsLavaGameAction[]): { roundsSurvived: number; dropsPerRound: number } {
     const first = gameActions[0];
-    if (!first || first.phase !== 'START') {
+    if (!first || first.phase !== FloorIsLavaActionPhase.START) {
       throw new Error('First action must be START');
     }
 
@@ -81,15 +105,17 @@ export class FloorIsLavaRules {
     for (let i = 1; i < gameActions.length; i++) {
       const action = gameActions[i];
       switch (action.phase) {
-        case 'START':
+        case FloorIsLavaActionPhase.START:
           throw new Error('START action can only appear as the first action');
-        case 'PICK':
+        case FloorIsLavaActionPhase.SUCCESSFUL_PICK:
           roundsSurvived++;
           if (roundsSurvived > maxRounds) {
             throw new Error(`Reconstructed rounds (${roundsSurvived}) exceeds max rounds (${maxRounds})`);
           }
           break;
-        case 'CASHOUT':
+        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');
       }
     }

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

@@ -6,11 +6,12 @@ import {
   DIFFICULTY_DROP_MAP,
   DROPPABLE_TILES,
   FloorIsLava,
+  FloorIsLavaActionPhase,
+  FloorIsLavaAutoBetRoundOutcome,
   FloorIsLavaDifficulty,
-  FloorIsLavaPickAction,
-  FloorIsLavaRoundOutcome,
   FloorIsLavaRules,
   FloorIsLavaStartAction,
+  FloorIsLavaSuccessfulPickAction,
 } from './floor-is-lava';
 import { TrueRandomRng } from './true-random-rng';
 
@@ -18,9 +19,22 @@ const ALL_DIFFICULTIES = [FloorIsLavaDifficulty.EASY, FloorIsLavaDifficulty.MEDI
 
 const EDGE_BPS = 200;
 
-const startAction = (difficulty: FloorIsLavaDifficulty): FloorIsLavaStartAction => ({ phase: 'START', difficulty });
+const startAction = (difficulty: FloorIsLavaDifficulty): FloorIsLavaStartAction => ({ phase: FloorIsLavaActionPhase.START, difficulty });
 
-const pickAction = (): FloorIsLavaPickAction => ({ phase: 'PICK', selectedTile: 0, droppedTiles: [], multiplier: new BigNumber(0) });
+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())]);
@@ -75,7 +89,11 @@ describe('FloorIsLava.fromActions', () => {
 
     it('throws when the history contains a CASHOUT action', () => {
       expect(() =>
-        FloorIsLava.fromActions([startAction(FloorIsLavaDifficulty.MEDIUM), pickAction(), { phase: 'CASHOUT', multiplier: new BigNumber(1) }]),
+        FloorIsLava.fromActions([
+          startAction(FloorIsLavaDifficulty.MEDIUM),
+          pickAction(),
+          { phase: FloorIsLavaActionPhase.CASHOUT, multiplier: new BigNumber(1), lastSurvivingTile: 0 },
+        ]),
       ).toThrow('An active game cannot have a CASHOUT action');
     });
 
@@ -101,20 +119,20 @@ describe('FloorIsLava.next', () => {
     expect(result).toMatchObject({
       isLoss: false,
       isLastTile: false,
-      gameAction: { phase: 'PICK', selectedTile: 5, droppedTiles: [10, 11, 12, 13, 14, 15] },
+      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 completes the game', () => {
-    const rng = new FixedSequenceRng([10, 11, 12, 13, 14, 15]);
+  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: 'PICK', selectedTile: 12, droppedTiles: [10, 11, 12, 13, 14, 15] },
+      gameAction: { phase: 'BUST_PICK', selectedTile: 12, droppedTiles: [10, 11, 12, 13, 14, 15], lastSurvivingTile: 32 },
     });
   });
 
@@ -133,10 +151,15 @@ describe('FloorIsLava.next', () => {
   });
 
   it('a loss deep into a streak still pays zero', () => {
-    const rng = new FixedSequenceRng([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 20, 21, 22, 23, 24, 25]);
+    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) });
+    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', () => {
@@ -178,7 +201,7 @@ describe('FloorIsLava.next', () => {
 
 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([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25]);
+    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));
@@ -192,12 +215,13 @@ describe('FloorIsLava — chained real sessions (fromActions replay of actual ne
     const game2 = FloorIsLava.fromActions([startAction(FloorIsLavaDifficulty.MEDIUM), round1.gameAction, round2.gameAction]);
     expect(game2.canCashout()).toBe(true);
 
-    const cashoutResult = expectOk(game2.cashout(EDGE_BPS));
+    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([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25]);
+    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));
@@ -205,7 +229,12 @@ describe('FloorIsLava — chained real sessions (fromActions replay of actual ne
     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) });
+    expect(round2).toMatchObject({
+      isLoss: true,
+      isLastTile: false,
+      multiplier: new BigNumber(0),
+      gameAction: { phase: 'BUST_PICK', lastSurvivingTile: 32 },
+    });
   });
 });
 
@@ -216,7 +245,7 @@ describe('FloorIsLava.cashout', () => {
     [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(EDGE_BPS));
+    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');
@@ -224,83 +253,87 @@ describe('FloorIsLava.cashout', () => {
   });
 
   it('returns no-tiles-selected with zero rounds survived', () => {
-    expect(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 0).cashout(EDGE_BPS)).toEqual({ ok: false, error: 'no-tiles-selected' });
+    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([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25, 40, 41, 42, 43, 44, 45]);
+    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: FloorIsLavaRoundOutcome.SURVIVED },
-        { droppedTiles: [20, 21, 22, 23, 24, 25], outcome: FloorIsLavaRoundOutcome.SURVIVED },
-        { droppedTiles: [40, 41, 42, 43, 44, 45], outcome: FloorIsLavaRoundOutcome.SURVIVED },
+        { 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([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25]);
+    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: FloorIsLavaRoundOutcome.SURVIVED },
-        { selectedTile: 21, droppedTiles: [20, 21, 22, 23, 24, 25], outcome: FloorIsLavaRoundOutcome.LOST },
+        { 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([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25, 40, 41, 42, 43, 44, 45]);
+    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: FloorIsLavaRoundOutcome.SURVIVED },
-        { selectedTile: 31, outcome: FloorIsLavaRoundOutcome.SURVIVED },
-        { selectedTile: 10, droppedTiles: [40, 41, 42, 43, 44, 45], outcome: FloorIsLavaRoundOutcome.CASHED_OUT },
+        { 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([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25]);
+    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: FloorIsLavaRoundOutcome.SURVIVED },
-        { selectedTile: 10, droppedTiles: [20, 21, 22, 23, 24, 25], outcome: FloorIsLavaRoundOutcome.CASHED_OUT },
+        { 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([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25]);
+    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 });
+    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: DROPPABLE_TILES }, (_, i) => i));
+    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') });
+    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', () => {
@@ -327,7 +360,7 @@ describe('FloorIsLava.autobet', () => {
 
 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(edgeBps));
+    const result = expectOk(gameWithRounds(FloorIsLavaDifficulty.MEDIUM, 3).cashout(fullBoardRng(), edgeBps));
     expect(result.multiplier.isEqualTo(expectedMultiplier(3, 6, edgeBps))).toBe(true);
   });
 
@@ -338,13 +371,13 @@ describe('FloorIsLava — edge parameter', () => {
   });
 
   it.each([100, 500, 1000])('autobet applies the given edge (%i bps) on a full survive', edgeBps => {
-    const rng = new FixedSequenceRng([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25]);
+    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(99)).toThrow('Exceeded Minimum edge allowed on platform');
+    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()', () => {
@@ -353,7 +386,7 @@ describe('FloorIsLava — edge parameter', () => {
   });
 
   it('rejects an edge below the platform minimum (100 bps) on a surviving autobet', () => {
-    const rng = new FixedSequenceRng([10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25]);
+    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');
   });
 });
@@ -429,7 +462,7 @@ describe('FloorIsLava — exhaustive multiplier & RTP across every endpoint', ()
       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(EDGE_BPS)).multiplier.isEqualTo(multiplier)).toBe(true);
+      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);

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

@@ -1,12 +1,14 @@
 import BigNumber from 'bignumber.js';
 import {
   DIFFICULTY_DROP_MAP,
+  FloorIsLavaActionPhase,
+  FloorIsLavaBustPickAction,
   FloorIsLavaCashoutAction,
   FloorIsLavaDifficulty,
   FloorIsLavaGameAction,
-  FloorIsLavaPickAction,
   FloorIsLavaRules,
   FloorIsLavaStartAction,
+  FloorIsLavaSuccessfulPickAction,
 } from './floor-is-lava-rules';
 import { RandomNumberGenerator } from './random-number-generator.interface';
 
@@ -15,7 +17,13 @@ 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: FloorIsLavaPickAction; isLoss: boolean; isLastTile: boolean }
+  | {
+      ok: true;
+      multiplier: BigNumber;
+      gameAction: FloorIsLavaSuccessfulPickAction | FloorIsLavaBustPickAction;
+      isLoss: boolean;
+      isLastTile: boolean;
+    }
   | { ok: false; error: FloorIsLavaNextError };
 
 export type FloorIsLavaCashoutError = 'no-tiles-selected';
@@ -24,22 +32,22 @@ export type FloorIsLavaCashoutResult =
   | { ok: true; multiplier: BigNumber; gameAction: FloorIsLavaCashoutAction }
   | { ok: false; error: FloorIsLavaCashoutError };
 
-export enum FloorIsLavaRoundOutcome {
+export enum FloorIsLavaAutoBetRoundOutcome {
   SURVIVED = 'SURVIVED',
   LOST = 'LOST',
   CASHED_OUT = 'CASHED_OUT',
 }
 
-export interface FloorIsLavaRoundResult {
+export interface FloorIsLavaAutoBetRoundResult {
   selectedTile: number;
   droppedTiles: number[];
-  outcome: FloorIsLavaRoundOutcome;
+  outcome: FloorIsLavaAutoBetRoundOutcome;
 }
 
 export type FloorIsLavaAutoBetError = 'invalid-selected-tiles-count' | 'invalid-tile';
 
 export type FloorIsLavaAutoBetResult =
-  | { ok: true; multiplier: BigNumber; results: FloorIsLavaRoundResult[]; survivedRounds: number }
+  | { ok: true; multiplier: BigNumber; results: FloorIsLavaAutoBetRoundResult[]; survivedRounds: number; lastSurvivingTile: number }
   | { ok: false; error: FloorIsLavaAutoBetError };
 
 export class FloorIsLava {
@@ -49,7 +57,7 @@ export class FloorIsLava {
   ) {}
 
   public static createAction(difficulty: FloorIsLavaDifficulty): FloorIsLavaStartAction {
-    return { phase: 'START', difficulty };
+    return { phase: FloorIsLavaActionPhase.START, difficulty };
   }
 
   public static fromActions(gameActions: FloorIsLavaGameAction[]): FloorIsLava {
@@ -83,21 +91,25 @@ export class FloorIsLava {
     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: {
-        phase: 'PICK',
-        selectedTile,
-        droppedTiles: thisRoundDrops,
-        multiplier,
-      },
+      gameAction,
       isLoss,
       isLastTile,
     };
   }
 
-  public cashout(edge: number): FloorIsLavaCashoutResult {
+  public cashout(generator: RandomNumberGenerator, edge: number): FloorIsLavaCashoutResult {
     if (!this.canCashout()) {
       return { ok: false, error: 'no-tiles-selected' };
     }
@@ -107,7 +119,7 @@ export class FloorIsLava {
     return {
       ok: true,
       multiplier,
-      gameAction: { phase: 'CASHOUT', multiplier },
+      gameAction: { phase: FloorIsLavaActionPhase.CASHOUT, multiplier, lastSurvivingTile: FloorIsLavaRules.lastSurvivingTile(generator) },
     };
   }
 
@@ -130,8 +142,9 @@ export class FloorIsLava {
 
     const rounds = FloorIsLavaRules.getRoundResults(generator, dropsPerRound, selectedTiles.length);
 
-    const results: FloorIsLavaRoundResult[] = [];
+    const results: FloorIsLavaAutoBetRoundResult[] = [];
     let survivedRounds = 0;
+    const lastSurvivingTile = FloorIsLavaRules.lastSurvivingTile(generator);
 
     for (let round = 0; round < selectedTiles.length; round++) {
       const selectedTile = selectedTiles[round];
@@ -141,20 +154,21 @@ export class FloorIsLava {
       const priorDrops = results.flatMap(result => result.droppedTiles);
       const isUnselectableDropTile = priorDrops.includes(selectedTile);
       if (isUnselectableDropTile) {
-        results.push({ selectedTile, droppedTiles, outcome: FloorIsLavaRoundOutcome.CASHED_OUT });
+        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 ? FloorIsLavaRoundOutcome.LOST : FloorIsLavaRoundOutcome.SURVIVED });
+      results.push({ selectedTile, droppedTiles, outcome: isLoss ? FloorIsLavaAutoBetRoundOutcome.LOST : FloorIsLavaAutoBetRoundOutcome.SURVIVED });
 
       if (isLoss) {
-        return { ok: true, multiplier: BigNumber(0), results, survivedRounds };
+        return { ok: true, multiplier: BigNumber(0), results, survivedRounds, lastSurvivingTile };
       }
       survivedRounds++;
     }
@@ -164,6 +178,7 @@ export class FloorIsLava {
       multiplier: FloorIsLavaRules.multiplier(survivedRounds, dropsPerRound, edge),
       results,
       survivedRounds,
+      lastSurvivingTile,
     };
   }
 }

package/src/sports/sports.types.ts

@@ -638,21 +638,12 @@ export class MarketLayout {
   marketDisplayType: SportsMarketDisplayType;
 }
 
-export enum MarketInfoVariantKey {
-  MAP = 'MAP',
-}
-
-export type MapVariant = string;
-
 export class BaseDisplayGroup {
   groupKey: string;
   groupName: string;
   groupSortName: string;
   selectionGroups: SelectionGroup[] | null;
   layout: MarketLayout;
-  variantData: Nullable<{
-    [MarketInfoVariantKey.MAP]?: MapVariant; // used for map market of oddin
-  }>;
   is2UpAvailable: boolean;
 }
 
@@ -720,10 +711,16 @@ export class SportsNewMarketOddsUpdate extends SportsMarketOddsBase {
   expiryTime: Nullable<Date>;
 }
 
+export class SgmSubGroup {
+  group: SportsMarketGroup;
+  weight: number;
+}
+
 export class SportsMarketInfo {
   odds: SportsNewMarketOddsUpdate[];
   display: DisplayGroup[];
   updatedAt: Nullable<Date>;
+  sgmSubGroups: Nullable<SgmSubGroup[]>;
 }
 
 export class SportsMarketSubInfo extends SportsMarketInfo {