🎲Game events

The phenomenon of game events involves the conversion of randomly generated floats into outcomes that are pertinent to the specific game at hand. This encompasses various occurrences such as the result of a dice roll, the sequence of cards in a deck, or the distribution of bombs in a minesweeper game.

Herein lies an elaborate elucidation of the process by which we translate floats into events tailored for each distinct game featured on our platform at Pigmo.com.

Blackjack & Hilo!

In the realm of card games, the deck holds 52 unique surprises. Dive into the excitement of Blackjack and Hi-Lo on Pigmo.com, where an infinite array of decks shapes each game. Here's the magic: every card flip maintains identical odds. How? By multiplying a random float by 52, we unlock a world of possibilities, each represented by a distinct card.

Witness the shuffle:

// From index 0 to 51: ♦2 to ♣A
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
];
// Game event decoded
const card = CARDS[Math.floor(float * 52)];

Hilo and Blackjack wield a spectrum of 13 to conjure 52 game events, ideal for cascades of card cascades.

Dice

Within Pigmo's dice realm, we encompass a broad spectrum of potential rolls, spanning from 00.00 to 100.00, offering a vast array of 10,001 conceivable outcomes. The conversion of game events is facilitated through a simple formula: the float is multiplied by the total number of potential outcomes (10,001), and then divided by 100 to ensure alignment with the designated Pigmo dice range.

// Game event translation
const roll = (float * 10001) / 100;

Limbo

In the realm of Pigmo, our approach to ensuring fairness is a meticulous two-fold process. Initially, we harness the float and subject it to multiplication by both the highest attainable multiplier and the intrinsic house edge. Subsequently, to manifest a game event governed by a probability distribution, we divide the maximum achievable multiplier by the outcome of the preliminary computation, thus fashioning the game event in the configuration of a crash point.

// Game event translation with houseEdge of 0.99 (1%)
const floatPoint = 1e8 / (float * 1e8) * houseEdge;

// Crash point rounded down to required denominator
const crashPoint = Math.floor(floatPoint * 100) / 100;

// Consolidate all crash points below 1
const result = Math.max(crashPoint, 1);

Plinko

Embark on the captivating journey of Pigmo's Plinko, where the fate of each play hinges on the trajectory of a descending sphere. The essence of the game lies in the cascading descent, where every level directs the ball's course. With a choice between 8 and 16 pins, players dictate the number of pivotal moments shaping the ball's path from zenith to nadir. As the ball teeters left or right, the unfolding drama intensifies, guided by a precise formula:

// Mapping from 0 to 1: left or right
const PATHS = [ left, right ];

// Deciphering the game's twists
const direction = PATHS[Math.floor(float * 2)];

Roulette

Explore the allure of Pigmo.com's Roulette, crafted in the image of its European counterpart boasting 37 distinct pockets, spanning the numerical spectrum from 0 to 36. The game's essence lies in the arithmetic precision: multiplying the float by 37 unveils the key to unlocking the pocket's secrets, orchestrated through an intricate index:

// From 0 to 36: the realm of possibilities
const POCKETS = [
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
    30, 31, 32, 33, 34, 35, 36
];

// Unveiling the game's enigma
const pocket = POCKETS[Math.floor(float * 37)];

Keno

In the world of Pigmo gaming, Keno offers a thrilling adventure with its unique gameplay dynamics. The essence of Keno lies in selecting 10 potential game events, represented as hits on a designated board. Each selection is crucial, as once a hit is placed, it's off the table for further consideration. This alters the landscape of potential outcomes, influencing subsequent choices.

To navigate this game effectively, we employ a strategic approach. First, we determine the range of available options for each decision point. This involves multiplying a float by the number of distinct squares on the board. The resulting index corresponds to a specific square, guiding our selection process.

// Index of 0 to 39 : 1 to 40
const SQUARES = [
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
    11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
    21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
    31, 32, 33, 34, 35, 36, 37, 38, 39, 40
];
const hit = SQUARES[Math.floor(float * 40)];

Additionally, we implement the Fisher-Yates shuffle algorithm to maintain the integrity of the game. This ensures that duplicate hits are avoided, enhancing the fairness and excitement of each round.

Mines

Embark on a daring expedition with Pigmo Mines, where every move holds the promise of discovery or peril. Unlike Keno, Mines presents players with 24 distinct game events scattered across the board in the form of mines. Navigating this labyrinth requires keen observation and strategic planning.

With each decision, a float is multiplied by the number of remaining tiles on the board, shaping the outcome of the game event. As tiles are revealed and accounted for, the landscape shifts, offering new opportunities and challenges.

To maintain the integrity of the gameplay experience, we employ the Fisher-Yates shuffle algorithm. This algorithm ensures that each game event is unique, preventing predictability and enhancing the thrill of exploration.

Whether you're uncovering hidden treasures in Keno or braving the dangers of Mines, Pigmo.com offers an immersive gaming experience that captivates players worldwide

Wheel

The float is utilized to determine the game event number by multiplying it with the potential outcomes within the segment. Subsequently, this figure is applied to ascertain the game event outcome, functioning as a multiplier, based on the subsequent index:

// Payout configurations index
const PAYOUTS = {
    '10': {
        low: [ 1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0 ],
        medium: [ 0, 1.9, 0, 1.5, 0, 2, 0, 1.5, 0, 3 ],
        high: [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 9.9 ]
    },
    '20': {
        low: [1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0],
        medium: [1.5, 0, 2, 0, 2, 0, 2, 0, 1.5, 0, 3, 0, 1.8, 0, 2, 0, 2, 0, 2, 0],
        high: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19.8]
    },
    '30': {
        low: [1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0],
        medium: [1.5, 0, 1.5, 0, 2, 0, 1.5, 0, 2, 0, 2, 0, 1.5, 0, 3, 0, 1.5, 0, 2, 0, 2, 0, 1.7, 0, 4, 0, 1.5, 0, 2, 0],
        high: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29.7]
    },
    '40': {
        low: [1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0],
        medium: [2, 0, 3, 0, 2, 0, 1.5, 0, 3, 0, 1.5, 0, 1.5, 0, 2, 0, 1.5, 0, 3, 0, 1.5, 0, 2, 0, 2, 0, 1.6, 0, 2, 0, 1.5, 0, 3, 0, 1.5, 0, 2, 0, 1.5, 0],
        high: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 39.6]
    },
    '50': {
        low: [1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0],
        medium: [2, 0, 1.5, 0, 2, 0, 1.5, 0, 3, 0, 1.5, 0, 1.5, 0, 2, 0, 1.5, 0, 3, 0, 1.5, 0, 2, 0, 1.5, 0, 2, 0, 2, 0, 1.5, 0, 3, 0, 1.5, 0, 2, 0, 1.5, 0, 1.5, 0, 5, 0, 1.5, 0, 2, 0, 1.5, 0],
        high: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49.5]
    }
};

Coinflip

The player has the option to toss between 1 and 10 coins at the same time. The outcome of each toss is determined by multiplying a random float by 2.

// From 0 to 1: heads or tails
const FACES = ["heads", "tails"];

// Decoding the game event
const side = FACES[Math.floor(float * 2)];