shufflecom-calculations 4.2.2 → 4.2.3

package/package.json

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

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

@@ -20,15 +20,15 @@ describe('FloorIsLavaBoard.draw', () => {
 
     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);
+    expect(board.tilesThatSurviveLevel(0, BOARD_SIZE)).toEqual(ASCENDING_BOARD);
+    expect(board.tilesThatSurviveLevel(1, BOARD_SIZE)).toEqual([...ASCENDING_BOARD].reverse());
+    expect(board.tilesThatSurviveLevel(2, BOARD_SIZE)).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));
+    expect(board.tilesThatSurviveLevel(0, BOARD_SIZE)).not.toEqual(board.tilesThatSurviveLevel(1, BOARD_SIZE));
   });
 });
 
@@ -48,14 +48,14 @@ describe('FloorIsLavaBoard.tilesDroppedInRound', () => {
   });
 });
 
-describe('FloorIsLavaBoard.remainingTilesInLevel', () => {
+describe('FloorIsLavaBoard.tilesThatSurviveLevel', () => {
   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('returns the last x tiles of the level board, not everything past a drop count', () => {
+    expect(board.tilesThatSurviveLevel(0, 7)).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]);
+    expect(board.tilesThatSurviveLevel(2, 4)).toEqual([45, 46, 47, 48]);
   });
 });

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

@@ -11,6 +11,10 @@ const assertValidLevel = (level: number): void => {
 export class FloorIsLavaBoard {
   private readonly levelBoards: [number[], number[], number[]];
 
+  get boards(): [number[], number[], number[]] {
+    return this.levelBoards;
+  }
+
   private constructor(generator: RandomNumberGenerator) {
     const raw = generator.getRandomIntsWithoutReplacement({
       min: 0,
@@ -34,8 +38,8 @@ export class FloorIsLavaBoard {
     return this.levelBoards[level].slice(roundIndex * dropsPerRound, (roundIndex + 1) * dropsPerRound);
   }
 
-  public remainingTilesInLevel(level: number, tilesDroppedInCurrentLevel: number): number[] {
+  public tilesThatSurviveLevel(level: number, survivingTilesCount: number): number[] {
     assertValidLevel(level);
-    return this.levelBoards[level].slice(tilesDroppedInCurrentLevel);
+    return this.levelBoards[level].slice(-survivingTilesCount);
   }
 }

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

@@ -201,7 +201,7 @@ describe('FloorIsLava.next', () => {
     const result = expectOk(gameAtState(FloorIsLavaDifficulty.EASY, 0, 0).next(5, board, EDGE_BPS));
 
     expect(result).toMatchObject({
-      tilesDroppedInCurrentLevel: 7,
+      survivingTilesCount: SURVIVING_TILES_MAP[FloorIsLavaDifficulty.EASY],
       gameAction: {
         phase: 'PICK',
         level: 0,
@@ -219,7 +219,7 @@ describe('FloorIsLava.next', () => {
 
     expect(result).toMatchObject({
       multiplier: new BigNumber(0),
-      tilesDroppedInCurrentLevel: 7,
+      survivingTilesCount: SURVIVING_TILES_MAP[FloorIsLavaDifficulty.EASY],
       gameAction: {
         phase: 'PICK',
         level: 0,
@@ -238,7 +238,7 @@ describe('FloorIsLava.next', () => {
 
     const result = expectOk(gameAtState(FloorIsLavaDifficulty.EASY, 0, 2).next(30, board, EDGE_BPS));
 
-    expect(result).toMatchObject({ tilesDroppedInCurrentLevel: 21, gameAction: { droppedTiles: thisRound } });
+    expect(result).toMatchObject({ survivingTilesCount: SURVIVING_TILES_MAP[FloorIsLavaDifficulty.EASY], gameAction: { droppedTiles: thisRound } });
     expect(result.multiplier.isEqualTo(expectedMultiplier(FloorIsLavaDifficulty.EASY, 0, 28))).toBe(true);
   });
 
@@ -276,7 +276,7 @@ describe('FloorIsLava.next', () => {
     const result = expectOk(gameAtState(difficulty, 0, roundsPerLevel - 1).next(35, board, EDGE_BPS));
 
     expect(result).toMatchObject({
-      tilesDroppedInCurrentLevel: roundsPerLevel * dropsPerRound,
+      survivingTilesCount: SURVIVING_TILES_MAP[difficulty],
       gameAction: { phase: 'PICK', level: 0, gameStatus: 'LEVEL_COMPLETE', selectedTile: 35, droppedTiles: lastRoundDrops },
     });
     expect(result.multiplier.isEqualTo(expectedMultiplier(difficulty, 0, SURVIVING_TILES_MAP[difficulty]))).toBe(true);
@@ -292,7 +292,7 @@ describe('FloorIsLava.next', () => {
     const result = expectOk(gameAtState(difficulty, LEVELS_PER_DIFFICULTY - 1, roundsPerLevel - 1).next(35, board, EDGE_BPS));
 
     expect(result).toMatchObject({
-      tilesDroppedInCurrentLevel: roundsPerLevel * dropsPerRound,
+      survivingTilesCount: SURVIVING_TILES_MAP[difficulty],
       gameAction: {
         phase: 'PICK',
         level: LEVELS_PER_DIFFICULTY - 1,
@@ -379,7 +379,7 @@ describe('FloorIsLava.cashout', () => {
     const tilesRemainingInLevel = FloorIsLavaRules.tilesRemaining(rounds, dropsPerRound);
     expect(result.multiplier.isEqualTo(expectedMultiplier(difficulty, levelsCleared, tilesRemainingInLevel))).toBe(true);
     expect(result.gameAction).toEqual({ phase: FloorIsLavaActionPhase.CASHOUT, level: levelsCleared, multiplier: result.multiplier });
-    expect(result.tilesDroppedInCurrentLevel).toBe(rounds * dropsPerRound);
+    expect(result.survivingTilesCount).toBe(SURVIVING_TILES_MAP[difficulty]);
   });
 
   it('returns no-tiles-selected with zero rounds survived at level 0', () => {

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

@@ -13,18 +13,19 @@ import {
   FloorIsLavaRules,
   FloorIsLavaStartAction,
   LEVELS_PER_DIFFICULTY,
+  SURVIVING_TILES_MAP,
 } 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; tilesDroppedInCurrentLevel: number }
+  | { ok: true; multiplier: BigNumber; gameAction: FloorIsLavaPickAction; survivingTilesCount: number }
   | { ok: false; error: FloorIsLavaNextError };
 
 export type FloorIsLavaCashoutError = 'no-tiles-selected';
 
 export type FloorIsLavaCashoutResult =
-  | { ok: true; multiplier: BigNumber; gameAction: FloorIsLavaCashoutAction; tilesDroppedInCurrentLevel: number }
+  | { ok: true; multiplier: BigNumber; gameAction: FloorIsLavaCashoutAction; survivingTilesCount: number }
   | { ok: false; error: FloorIsLavaCashoutError };
 
 export class FloorIsLava {
@@ -72,7 +73,7 @@ export class FloorIsLava {
 
     const droppedTiles = board.tilesDroppedInRound(currentLevel, dropsPerRound, roundsSurvivedInCurrentLevel);
     const isLoss = droppedTiles.includes(selectedTile);
-    const tilesDroppedInCurrentLevel = (roundsSurvivedInCurrentLevel + 1) * dropsPerRound;
+    const survivingTilesCount = SURVIVING_TILES_MAP[difficulty];
 
     if (isLoss) {
       return {
@@ -86,7 +87,7 @@ export class FloorIsLava {
           gameStatus: FloorIsLavaGameStatus.LOST,
           multiplier: BigNumber(0),
         },
-        tilesDroppedInCurrentLevel,
+        survivingTilesCount,
       };
     }
 
@@ -115,7 +116,7 @@ export class FloorIsLava {
         gameStatus,
         multiplier: nextMultiplier,
       },
-      tilesDroppedInCurrentLevel,
+      survivingTilesCount,
     };
   }
 
@@ -124,15 +125,14 @@ export class FloorIsLava {
       return { ok: false, error: 'no-tiles-selected' };
     }
 
-    const { currentLevel, roundsSurvivedInCurrentLevel, difficulty } = this.state;
-    const { dropsPerRound } = DIFFICULTY_LEVEL_MAP[difficulty];
+    const { currentLevel, difficulty } = this.state;
     const { currentMultiplier } = FloorIsLavaRules.multipliers(this.state, edge);
 
     return {
       ok: true,
       multiplier: currentMultiplier,
       gameAction: { phase: FloorIsLavaActionPhase.CASHOUT, level: currentLevel, multiplier: currentMultiplier },
-      tilesDroppedInCurrentLevel: roundsSurvivedInCurrentLevel * dropsPerRound,
+      survivingTilesCount: SURVIVING_TILES_MAP[difficulty],
     };
   }
 }