Provably fair

Provably Fair

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 betinha.com.

Blackjack, Hilo & Baccarat!

In the realm of card games, the deck holds 52 unique surprises. Dive into the excitement of Blackjack, Hilo & Baccarat on betinha.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.

// 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)];

But here's where the games diverge: Hilo and Blackjack wield a spectrum of 13 to conjure 52 game events, ideal for cascades of card cascades. On the flip side, Baccarat demands only 6 game events to unveil its full potential, offering a streamlined experience without compromise.

Dice

Within betinha'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 betinha dice range.

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

Limbo

In the realm of betinha, 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 betinha'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 betinha.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)];

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 betinha 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, betinha.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
        ]
    }
};

// Translating game eventconst
spin = PAYOUTS[segments][risk][float * segments];