shufflecom-calculations 4.1.1 → 4.1.2

package/package.json

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

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

@@ -193,8 +193,6 @@ describe('CoinflipRules.validateActiveProgressiveClassicGame', () => {
 });
 
 describe('CoinflipRules.isValidTargetConfig', () => {
-  const EDGE_BPS = 200;
-
   it('returns true for every allowed (N, M) pair from the game-design table', () => {
     const allowedPairs: [number, number][] = [
       [1, 1],
@@ -219,7 +217,7 @@ describe('CoinflipRules.isValidTargetConfig', () => {
       [20, 9],
     ];
     for (const [n, m] of allowedPairs) {
-      expect(CoinflipRules.isValidTargetConfig(n, m, EDGE_BPS)).toBe(true);
+      expect(CoinflipRules.isValidTargetConfig(n, m)).toBe(true);
     }
   });
 
@@ -244,19 +242,19 @@ describe('CoinflipRules.isValidTargetConfig', () => {
       [20, 8],
     ];
     for (const [totalFlips, minSuccesses] of belowMinimum) {
-      expect(CoinflipRules.isValidTargetConfig(totalFlips, minSuccesses, EDGE_BPS)).toBe(false);
+      expect(CoinflipRules.isValidTargetConfig(totalFlips, minSuccesses)).toBe(false);
     }
   });
 
   it('rejects totalFlips outside 1..MAX_FLIPS', () => {
-    expect(CoinflipRules.isValidTargetConfig(0, 1, EDGE_BPS)).toBe(false);
-    expect(CoinflipRules.isValidTargetConfig(MAX_FLIPS + 1, 1, EDGE_BPS)).toBe(false);
-    expect(CoinflipRules.isValidTargetConfig(-1, 1, EDGE_BPS)).toBe(false);
+    expect(CoinflipRules.isValidTargetConfig(0, 1)).toBe(false);
+    expect(CoinflipRules.isValidTargetConfig(MAX_FLIPS + 1, 1)).toBe(false);
+    expect(CoinflipRules.isValidTargetConfig(-1, 1)).toBe(false);
   });
 
   it('rejects minSuccesses outside 1..totalFlips', () => {
-    expect(CoinflipRules.isValidTargetConfig(5, 0, EDGE_BPS)).toBe(false);
-    expect(CoinflipRules.isValidTargetConfig(5, 6, EDGE_BPS)).toBe(false);
-    expect(CoinflipRules.isValidTargetConfig(5, -1, EDGE_BPS)).toBe(false);
+    expect(CoinflipRules.isValidTargetConfig(5, 0)).toBe(false);
+    expect(CoinflipRules.isValidTargetConfig(5, 6)).toBe(false);
+    expect(CoinflipRules.isValidTargetConfig(5, -1)).toBe(false);
   });
 });

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

@@ -92,7 +92,7 @@ export class CoinflipRules {
     return calculateEdgeMultiplier(edgeBps).dividedBy(CoinflipRules.calculateTargetWinChance(flips, minSuccesses));
   }
 
-  public static isValidTargetConfig(totalFlips: number, minSuccesses: number, edgeBps: number): boolean {
+  public static isValidTargetConfig(totalFlips: number, minSuccesses: number): boolean {
     if (totalFlips < 1 || totalFlips > MAX_FLIPS) {
       return false;
     }

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

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

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