const TOWER_DIFFICULTY_TO_CONFIG: Record<TowerDifficulty, DifficultyConfig> = {
  [TowerDifficulty.EASY]: {
    count: 3,
    columns: 4,
  },
  [TowerDifficulty.MEDIUM]: {
    count: 2,
    columns: 3,
  },
  [TowerDifficulty.HARD]: {
    count: 1,
    columns: 2,
  },
  [TowerDifficulty.EXPERT]: {
    count: 1,
    columns: 3,
  },
  [TowerDifficulty.MASTER]: {
    count: 1,
    columns: 4,
  },
};


// Generate floats to determine the positions of safe tiles (keys) for each row
const floats = generateFloats({
  serverSeed,
  clientSeed,
  nonce,
  cursor,
  count,
});

// Get the tower configuration based on the selected difficulty
const towerConfig = TOWER_DIFFICULTY_TO_CONFIG[difficulty];
const results: number[][] = [];
const resultPerRow = towerConfig.count;

// Iterate through each row to determine the positions of safe tiles for that row
for (let i = 0; i < TOWER_TOTAL_ROWS.toNumber(); i++) {
  const result: number[] = [];
  const values = Array.from(Array(towerConfig.columns).keys());

  // Get positions for safe tiles in the current row
  for (let j = 0; j < resultPerRow; j++) {
    const float = floats[i * resultPerRow + j];
    if (float === undefined) {
      break;
    }

    const position = Math.floor(float * (towerConfig.columns - j));
    result.push(values.splice(position, 1)[0] ?? 0);
  }

  results.push(result);
}

return results;

// Example: when clientSeed='abc', serverSeed='def', nonce=1, difficulty='easy'
// results: [
// [0, 1, 2], 
// [0, 2, 3], 
// [0, 2, 3], 
// [0, 1, 2], 
// [0, 1, 3], 
// [0, 1, 2], 
// [1, 2, 3], 
// [0, 1, 3], 
// [0, 1, 3]
// ]
// Each sub-array represents the column indexes of safe tiles for that row
// (e.g., for the first row, safe tiles are in columns 0, 1, and 2)

const TOTAL_LANES = 20

// Number of lanes that the chicken can cross for each difficulty
const DIFFICULTY_TO_VALID_LANE_COUNT: Record<ChickenDifficulty, number> = {
    [ChickenDifficulty.EASY]: 19,
    [ChickenDifficulty.MEDIUM]: 17,
    [ChickenDifficulty.HARD]: 15,
    [ChickenDifficulty.EXPERT]: 10,
  };
  
// Number of gameResults generated depends on the difficulty
// Example with Hard difficulty, we generate 20 - 15 = 5 numbers 
// and the smallest number in the array is the danger lane
const gameResults = generateFloats({
  serverSeed,
  clientSeed,
  nonce,
  cursor: 0,
  count: TOTAL_LANES - DIFFICULTY_TO_VALID_LANE_COUNT[difficulty] // difficulty selected for the game
}).map((val, index) => Math.floor(val * (TOTAL_LANES - index)));

// Danger lane is determined by the smallest number in the game results array
const dangerLane = Math.min(...gameResults)

// Example: Hard difficulty - gameResults = [10, 4, 6, 15, 8] 
// Danger lane will be on 4 (this is zero based index)
// Lane 0 - 3 are safe and lane 4 will be the danger lane
// The chicken will lose upon reaching lane 4 if not cashed out earlier

// Create multiple floats between 0 and 1 
// Example: floats = [0.8320531346835196, 0.8531235849950463, 0.18227359023876488, 0.774284637067467, 0.18627392360940576, 0.6012540922965854, 0.608081541955471, 0.46018488449044526] when clientSeed='abc', serverSeed='def', nonce=1, count=8 
// count refers to the number of plinko rows 
const floats = generateFloats({ serverSeed, clientSeed, nonce, cursor, count }); 

// Example: [1, 1, 0, 1, 0, 1, 1, 0] Each 1 represents a drop to the right whereas 0 represents a drop to the left 
const dropDirections = floats.map(val => Math.floor(val * 2)); 

// This sums up all the values in the array to get the final position of the ball from the left. 

// Example: finalPositionFromLeft = 5 (the ball will land on the 6th slot from the left) 
const finalPositionFromLeft = dropDirections.reduce((cur, acc) => cur + acc, 0)

// Creates an array of random numbers 
// Example: With clientSeed = 'abc', serverSeed = 'def', nonce = 1, floats = [0.43053962965495884] 
const floats = generateFloats({ serverSeed, clientSeed, nonce, cursor: 0, count: 1 }); 

// Converts the value in the array to a number between 0.00 to 100.00 and return the value 

// Example: resultValue = [43.05] 
const resultValue = floats.map(val => Math.floor(floats * 10001) / 100); 
return resultValue[0]; 
// Example: 43.05 is returned as the result of the game

// Generate float between 0 and 1 
// Example: floats = [0.43053962965495884], float = 0.43053962965495884, 
// when clientSeed='abc', serverSeed='def', nonce=1 
const floats = generateFloats({ serverSeed, clientSeed, nonce, cursor: 0, count: 1 }); 
const float = floats[0] 
// generate limbo game event results with house edge (1%) 
// using a hyperbolic 1/x curve 
// multiplying by this and dividing by (MAX_VALUE + 1) prevents division by 0 error 

const MAX_VALUE = 2 ** 24; 
const rtp = 0.99; 

// Example: rawValue = 2.298905 
const rawValue = (rtp * MAX_VALUE) / (MAX_VALUE * float + 1) 

// resultValue = 2.29 
const resultValue = (0.99 * MAX_VALUE / (MAX_VALUE * float +1)).toFixed(2,ROUND_DOWN); 
return resultValue;

// Generate 10 different floats as there are 10 positions that are selected when the game is played 
// Example: floats = [18, 26, 7, 22, 31, 10, 23, 8, 24, 13] when clientSeed='abc', serverSeed='def', nonce=1 

const floats = generateFloats({ serverSeed, clientSeed, nonce, cursor: 0, count: 10 }) .map((val, index) => Math.ceil(val * (40 - index))) 

// array used to store the position of the gems const gemLocations: number[] = []; 

// this loop helps to prevent duplicate gem positions by skipping positions that already contain a gem 
for (const val of floats) { let currentGem = val; 
let i = 0; 
while (i <= currentGem) { 
 if (gemLocations.includes(i)) { 
 currentGem++; 
} 
 i++; 
 }

gemLocations.push(currentGem); 
} 

// returns the location of the gem on the board 
// Example: [18, 27, 7, 24, 35, 11, 28, 9, 31, 16] return gemLocations;

// Generate 10 different floats 
// Example: [20, 20, 4] when clientSeed='abc', serverSeed='def', nonce=1, numberOfBombs=3 
const floats = generateFloats({ serverSeed, clientSeed, nonce, cursor: 0, count: numberOfBombs }) 
        .map((val, index) => Math.floor(val * (25 - index))); 

// array used to store the position of the bombs
 const mineLocations: number[] = []; 

// this loop helps to prevent duplicate bomb positions by skipping positions that already contain a mine
  for (const val of floats) { 
  let currentMine = val; 
  let i = 0; 

  while (i <= currentMine) { 
   if (mineLocations.includes(i)) {
      currentMine++;
 } i++; } mineLocations.push(currentMine); } 

// returns the location of the bombs on the board 
// Example: [20, 21, 4] 
 return mineLocations;

// Generate a float between 0 and 1 
// Example: floats = [0.43053962965495884] 
const floats = generateFloats({serverSeed, clientSeed, nonce, cursor: 0, count: 1 }); 

// generate an integer from 0 to 37 to represent the pocket to land on 
// Example: resultValue = 15 
 const resultValue = floats.map(val => Math.floor(val * 37))[0]; 
 return resultValue

// Generate a float between 0 and 1 
// Example: floats = [0.43053962965495884] 
const floats = generateFloats({serverSeed, clientSeed, nonce, cursor,                                                                      count:1 }); 

// Get an integer representing the number of segments set in the game 
// Example: resultSegment = 8 
const resultSegment = floats.map(val => Math.floor(val * numberOfSegments))[0]; 

return resultSegment

// Generate a float between 0 and 1 
// Example: floats = [0.43053962965495884, 0.6645898742135614, 0.17454026662744582, 0.5729992990382016, 0.850033157505095] (52 elements are generated but only 5 are shown here for brevity) 
const floats = generateFloats({serverSeed, clientSeed, nonce, cursor, count:52 }); 

const CARDS = [ ♦2, ♥2, ♠2, ♣2, ♦3, ♥3, ♠3, ♣3, ♦4, ♥4, ♠4, ♣4, ♦5, ♥5, ♠5, ♣5, ♦6, ♥6, ♠6, ♣6, ♦7, ♥7, ♠7, ♣7, ♦8, ♥8, ♠8, ♣8, ♦9, ♥9, ♠9, ♣9, ♦10, ♥10, ♠10, ♣10, ♦J, ♥J, ♠J, ♣J, ♦Q, ♥Q, ♠Q, ♣Q, ♦K, ♥K, ♠K, ♣K, ♦A, ♥A, ♠A, ♣A 
]; 

// Get an integer 0 to 51, representing the index of the cards 
// Example: cardFloats = [22, 34, 9, 29, 44] 
const cardFloats = floats.map(val => Math.floor(val * 52)); 

// Example: cards = [♠7, ♠10, ♥4, ♥9, ♦K] 
const cards = cardFloats.map(val => CARDS[val]) 
return cards;

// Generate a float between 0 and 1 
// Example: floats = [0.43053962965495884, 0.6645898742135614, 0.17454026662744582, 0.5729992990382016, 0.850033157505095] (an unlimited number of cards can be drawn but only 5 are shown here for brevity) 
const floats = generateFloats({serverSeed, clientSeed, nonce, cursor, count:52 }); 

const CARDS = [ 
♦2, ♥2, ♠2, ♣2, ♦3, ♥3, ♠3, ♣3, ♦4, ♥4, ♠4, ♣4, ♦5, ♥5, ♠5, ♣5, ♦6, ♥6, ♠6, ♣6, ♦7, ♥7, ♠7, ♣7, ♦8, ♥8, ♠8, ♣8, ♦9, ♥9, ♠9, ♣9, ♦10, ♥10, ♠10, ♣10, ♦J, ♥J, ♠J, ♣J, ♦Q, ♥Q, ♠Q, ♣Q, ♦K, ♥K, ♠K, ♣K, ♦A, ♥A, ♠A, ♣A 
]; 

// Get an integer 0 to 51, representing the index of the cards 
// Example: cardFloats = [22, 34, 9, 29, 44] 
const cardFloats = floats.map(val => Math.floor(val * 52)); 


// Example: cards = [♠7, ♠10, ♥4, ♥9, ♦K] 
const cards = cardFloats.map(val => CARDS[val]) 
return cards;

// Generate a float between 0 and 1
// Example: floats = [0.40353962965495884, 0.6645898742135614, 0.17454026662744582, 0.5729992990382016, 0.850033157505095] (an unlimited number of cards can be drawn but only 5 are shown here for brevity)
const floats = generateFloats({serverSeed, clientSeed, nonce, cursor, count:52 });

const CARDS = [
♠2, ♥2, ♦2, ♣2, ♠3, ♥3, ♦3, ♣3, ♠4, ♥4,
♦4, ♣4, ♠5, ♥5, ♦5, ♣5, ♠6, ♥6, ♦6, ♣6,
♠7, ♥7, ♦7, ♣7, ♠8, ♥8, ♦8, ♣8, ♠9, ♥9,
♦9, ♣9, ♠10, ♥10, ♦10, ♣10, ♠J, ♥J, ♦J,
♣J, ♠Q, ♥Q, ♦Q, ♣Q, ♠K, ♥K, ♦K, ♣K, ♠A,
♥A, ♦A, ♣A
];

// Get an integer 0 to 51, representing the index of the cards
// Example: cardFloats = [22, 34, 9, 29, 44]
const cardFloats = floats.map(val => Math.floor(val * 52));

// Example: cards = [♠7, ♠10, ♥4, ♠9, ♦K]
const cards = cardFloats.map(val => CARDS[val])
return cards;

// Generate a float between 0 and 1
// Example: floats = [0.43053962965495884, 0.6645898742135614, 0.17454026662744582, 0.5729992990382016, 0.850033157505095] (an unlimited number of cards can be drawn but only 5 are shown here for brevity)
const floats = generateFloats({serverSeed, clientSeed, nonce, cursor, count:52 });

const CARDS = [
♠2, ♥2, ♣2, ♦2, ♠3, ♥3, ♣3, ♦3, ♠4, ♥4,
♣4, ♦4, ♠5, ♥5, ♣5, ♦5, ♠6, ♥6, ♣6, ♦6,
♠7, ♥7, ♣7, ♦7, ♠8, ♥8, ♣8, ♦8, ♠9, ♥9,
♣9, ♦9, ♠10, ♥10, ♣10, ♦10, ♠J, ♥J, ♣J, ♦J,
♠Q, ♥Q, ♣Q, ♦Q, ♠K, ♥K, ♣K, ♦K, ♠A,
♥A, ♣A, ♦A
];

// Get an integer 0 to 51, representing the index of the cards
// Example: cardFloats = [22, 34, 9, 29, 44]
const cardFloats = floats.map(val => Math.floor(val * 52));

// Example: cards = [♠7, ♠10, ♥4, ♠9, ♦K]
const cards = cardFloats.map(val => CARDS[val])
return cards;

// Generate floats to determine each flip outcome
// Example: floats = [0.43053962965495884, 0.6645898742135614, ...] when clientSeed='abc', serverSeed='def', nonce=1
const floats = generateFloats({ serverSeed, clientSeed, nonce, cursor, count });

// Each float maps to 0 or 1, which maps to HEADS or TAILS
// Example: [0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1]
const flipValues = floats.map(val => Math.floor(val * 2));
const flipResults = flipValues.map(val => (val === 0 ? 'HEADS' : 'TAILS'));


// Example: [HEADS, TAILS, HEADS, TAILS, TAILS, HEADS, TAILS, HEADS, TAILS, HEADS,
//           TAILS, HEADS, TAILS, HEADS, HEADS, TAILS, HEADS, HEADS, HEADS, TAILS]
return flipResults;

// Draw a random permutation of 0..146 without replacement 
// Example: raw = [103, 12, 140, 76, 3, ...] 
const boards = [[], [], []]; 
for (const value of raw) {
  boards[Math.floor(value / 49)].push(value % 49); // bucket = level, residue = tile index } 
// boards[0], boards[1], boards[2] are each a uniformly random ordering of tiles 0..48 

tilesDroppedInRound(level, dropsPerRound, roundIndex) = levelBoard.slice(roundIndex * dropsPerRound, (roundIndex + 1) * dropsPerRound) 

tilesThatSurviveLevel(level, survivingCount) = levelBoard.slice(-survivingCount) 

isLoss = droppedTiles.includes(selectedTile) 

multiplier = edgeMultiplier * 49^(levelsCleared+1) / (tilesRemainingInLevel * survivingTiles^levelsCleared)