Hilo

In 'n standaard kaartspeelstel is daar 52 unieke moontlike uitslae. Wanneer dit by Blackjack, Hilo en Baccarat op ons platform kom, gebruik ons 'n onbeperkte aantal dekke wanneer ons die speletjie gebeurtenis genereer, en daarom het elke kaart se beurt altyd dieselfde waarskynlikheid. Om dit te bereken, vermenigvuldig ons elke lukraak gegenereerde float met 52, en vertaal dan daardie resultaat na 'n spesifieke kaart, gebaseer op die volgende indeks:

// Index of 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 translation
const card = CARDS[Math.floor(float * 52)];

Die enigste verskil wat betrokke is by hierdie speletjies is dat daar met Hilo en Blackjack 'n kursor van 13 is om 52 moontlike speletjie-gebeurtenisse te genereer vir gevalle waar 'n groot aantal kaarte aan die speler versprei moet word, terwyl ons in Baccarat net 6 speletjie-gebeurtenisse hoef te genereer om soveel speelbare kaarte as moontlik te dek.

Diamante

Wanneer jy Diamonds speel, is daar 7 moontlike uitkomste in die vorm van juwele. Om dit te bereik, vermenigvuldig ons elke gegenereerde float met 7 voordat dit in 'n ooreenstemmende juweel vertaal word met behulp van die volgende indeks:

// Index of 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 translation
const card = CARDS[Math.floor(float * 52)];

Dobbelsteen

In ons weergawe van dobbelsteen dek cover ons 'n moontlike rolverspreiding van 00.00 tot 100.00, wat 'n reeks van 10,001 moontlike uitkomste het. Die vertaling van die speletjie-gebeurtenis word gedoen deur die float met die aantal moontlike uitkomste te vermenigvuldig en dit dan deur 100 te deel sodat die resulterende nommer in die grense van ons verklaring dobbelsteenreeks pas.

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

Muntwerp

Wanneer jy Coinflip speel, is daar 2 moontlike uitkomste in die vorm van munte. Om dit te bereik, vermenigvuldig ons elke gegenereerde float met 2 voordat dit in 'n ooreenstemmende juweel vertaal word met behulp van die volgende indeks:

// Index of 0 & 1 : batman & joker
const COINS = [ 0, 1 ];

// Game event translation
const coin = COINS[Math.floor(float * 2)];

Limbo

Wanneer dit by Limbo kom, gebruik ons 'n twee-stap proses. Eerstens neem ons die float en vermenigvuldig dit met beide die maksimum moontlike vermenigvuldiger en die huisrand. Dan, om 'n speletjie-gebeurtenis te genereer wat Kansverdeling Ons verdeel die maksimum moontlike vermenigvuldiger deur die resultaat van die eerste stap om die speletjie-gebeurtenis in die vorm van 'n crashpunt te skep.

// 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

Vir enige Plinko-spel is die gegenereerde resultaat gebaseer op die pad van die valbal. Die speletjie-gebeurtenis bepaal die rigting van die valbal vir elke vlak in die valproses. Spelers kan tussen 8 en 16 punte kies, wat die aantal speletjie-gebeurtenisse bepaal wat benodig word om 'n volledige pad van bo na onder te genereer. Aangesien daar slegs twee moontlike rigtings (links of regs) is, word die vertaling gedoen deur elke float met 2 te vermenigvuldig, wat na die volgende indeks kaart.

// Index of 0 to 1 : left to right
const DIRECTIONS = [ left, right ];

// Game event translation
const direction = CARDS[Math.floor(float * 2)];

Keno

Tradisionele Keno speletjies vereis die keuse van 10 moontlike spelet

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

Die Fisher-Yates-skudimplementering word gebruik om te voorkom dat duplikaat moontlike treffers gegenereer word.

Myns

n Mynspel word gegenereer met 24 afsonderlike speletjie-gebeurtenisse, in die vorm van myne op die bord. Elke float word vermenigvuldig met die aantal moontlike unieke teëls wat steeds op die bord oorbly. Dit word gedoen deur die aantal teëls wat oorbly met 1 te verminder vir elke iterasie van die speletjie-gebeurtenis resultaat wat gegenereer word met behulp van die ooreenstemmende float wat verskaf is. Die ligging van die myn word geteken met behulp van 'n roosterposisie van links na regs, van bo na onder.

Die Fisher-Yates-skudimplementering word gebruik om te voorkom dat duplikaat moontlike treffers gegenereer word. Tussen 1 en 24 speletjie gebeurtenisresultate word gebruik, gebaseer op die gekose instellings.

Wiel

Die speletjie-gebeurtenisnommer word bereken deur die float met die moontlike uitkomste in die segment te vermenigvuldig. Dit word dan gebruik om die speletjie-gebeurtenisresultaat as 'n vermenigvuldiger te bepaal, met behulp van die volgende indeks:

// Index per payout configuration
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
    ]
}
};

// Game event translation
const spin = PAYOUTS[segments][risk][float * segments];

Crash

Om ons regverdigheid te bewys, het ons 'n ketting van 10 000 000 SHA256-hashes gegenereer, waar elke hash die hash van die hexadeciemale voorstelling van die vorige hash is. Die laaste hash in die ketting is: 78a9757d3be42b74a3f70239078ad9317125fe9ee630d5bdada46de963e56752

Die formule om die speletjie-resultaat te genereer:

const gameHash = hashChain.pop()

const hmac = createHmac('sha256', gameHash);

// blockHash is the hash of bitcoin block 584,500

hmac.update(blockHash);

const hex = hmac.digest('hex').substr(0, 8);
const int = parseInt(hex, 16);

// 0.01 will result in 1% house edge with a lowest crashpoint of 1

const crashpoint = Math.max(1, (2 ** 32 / (int + 1)) * (1 - 0.01))

Dubbel

Ons Dubbel is afgeleid van die Europese weergawe van die spel waar die wiel uit 15 moontlike verskillende sakke bestaan, wat van 0 tot 14 strek. Die speletjie-gebeurtenis word bereken deur die float met 15 te vermenigvuldig en dan in 'n ooreenstemmende sak te vertaal deur die volgende indeks te gebruik:

// Index of 0 to 14
const POCKETS = [ 
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 
    10, 11, 12, 13, 14
];

// Game event translation
const pocket = POCKETS[Math.floor(float * 15)];

Toren

n Toren spel word gegenereer met 9 aparte spelevents, in die vorm van die vlakke van die toren. Ons genereer 'n aantal eiers afhangende van die moeilikheidsgraad vir elke vlak, en het 'n reeks teëls waarop die eier ook deur 'n geheel getal voorgestel kan word.

Elke gegenereerde float wordt omgezet in gehele getallen om de locatie van de eieren op elke rij te bepalen. Bijvoorbeeld: Een niveau met een gemakkelijke moeilijkheidsgraad zou als volgt worden weergegeven: [0, 1, 3] - de eieren zouden aanwezig zijn op tegel 1, 2 en 4.

// count represents the number of eggs
// size represents the number of possible squares

const LEVEL_MAP = {
easy: { count: 3, size: 4 },
medium: { count: 2, size: 3 },
hard: { count: 1, size: 2 },
expert: { count1, size: 3 },
master: { count: 1, size: 4 },}

Die Fisher-Yates Shuffle-Implementierung wird verwendet, um doppelte Eier in einer Reihe zu verhindern.