Come funziona il provably fair in Limbo
Ecco come giocare a Limbo su Cloudbet, e come verificare che ogni moltiplicatore sia provably fair.
Come giocare a Limbo
Limbo è un gioco veloce e semplice basato su un moltiplicatore: prima di ogni round, imposti un moltiplicatore obiettivo — quanto grande vuoi che sia la tua vincita. Piazza la tua scommessa, poi viene generato un moltiplicatore risultante. Se raggiunge o supera il tuo obiettivo, vinci il tuo obiettivo moltiplicato per la tua scommessa. Se si ferma sotto il tuo obiettivo, perdi il round.
Più alto è il moltiplicatore obiettivo che imposti, maggiore è la potenziale vincita — ma minore è la probabilità che il risultato lo raggiunga. Puoi impostare il tuo obiettivo alto o basso quanto vuoi prima di ogni scommessa.
Cloudbet Originals Limbo
Il Limbo degli Originals di Cloudbet ha un RTP del 99%, un moltiplicatore massimo di x1.000.000 e accetta scommesse da 0,01 $ a 20.000 $.
I numeri casuali di Limbo vengono generati nello stesso modo verificabile di ogni altro Cloudbet Original — consulta il sistema provably fair di Cloudbet per sapere come Server Seed, Client Seed e Nonce si combinano in una Round Signature e poi in un flusso di numeri casuali tramite SHAKE256. Questa pagina copre ciò che è specifico di Limbo: come quel numero casuale diventa il moltiplicatore contro cui giochi.
Come viene calcolato il moltiplicatore
Limbo parte da un numero casuale a 32 bit — generato da SHAKE256, distribuito uniformemente, il che significa che ogni valore tra 0 e 2³²-1 ha la stessa probabilità.
Questa però non è la distribuzione di cui abbiamo bisogno. Un moltiplicatore dovrebbe cadere su valori piccoli molto più spesso che su valori enormi — le probabilità di un 1,01x dovrebbero essere molto più alte di quelle di un 100.000x. Quindi il numero casuale viene rimodellato, passo dopo passo, in quella distribuzione:
- Viene utilizzato il rejection sampling, ma in modo leggero — solo per evitare di estrarre il singolo numero massimo possibile, dato che il numero sta per essere incrementato di uno.
- Il numero viene incrementato di uno (così non è mai zero, il che è importante per la divisione al passo 4).
- Viene riscalato a un decimale tra 0 e 1, dividendolo per il suo valore massimo possibile.
- 0,99 (l'RTP di Limbo) viene diviso per quel decimale — questo è il passaggio che trasforma una distribuzione uniforme in una in cui i moltiplicatori piccoli sono esponenzialmente più comuni di quelli grandi.
- Il risultato viene arrotondato per difetto a due cifre decimali.
- Infine, viene "tagliato" all'intervallo valido di Limbo: qualsiasi valore sotto 1 diventa 1 (la scommessa minima è 1,01, quindi i risultati sotto 1 sono semplicemente una perdita), e qualsiasi valore sopra 1.000.000 diventa 1.000.000 (la vincita massima di Limbo).
Una volta generato, il moltiplicatore è fisso e nascosto — non può essere cambiato dopo che la scommessa è stata piazzata. Incassare (o meno) prima di raggiungerlo è ciò che decide il round.
Verifica le tue partite a Limbo
Il codice qui sotto è fedele all'implementazione di Limbo su Cloudbet. Inserisci il tuo Server Seed, Client Seed e Nonce per riprodurre il tuo risultato. A proposito: per rivelare il Server Seed di una partita su Cloudbet devi iniziare a usare un altro Server Seed.
Dipendenze:
npm install js-sha3
Codice:
// If you are running this yourself, then you can input your own data here
// You can then compare:
// 1) Cloudbet's provided Commitment to the Commitment outputted here. This proves that the Server Seed was not altered during gameplay.
// 2) Cloudbet's provided game outcome to the game outcome outputted here. This proves that your game's outcome was determined solely by the pre-game seeds and was not altered afterwards.
let myServerSeed = 'your_server_seed'; // ✍️YOUR_INPUT✍️: Enter your (unhashed) Server Seed here
let myClientSeed = 'your_client_seed'; // ✍️YOUR_INPUT✍️: Enter your Client Seed here
let myNonce = 0; // ✍️YOUR_INPUT✍️: Enter your Nonce here
const usingCustomData = false; // Change this to true if you are using your own data
// Load libraries
const crypto = require('crypto');
const { sha3_256, shake256 } = require('js-sha3');
// Step 1: Generate a Server Seed and Commitment
// And generate a Client Seed - either by player input or by the player's browser
function generateServerSeed() {
let seed = crypto.randomBytes(32).toString('hex');
if (usingCustomData) { seed = myServerSeed; }
const commitment = sha3_256(seed);
return { 'serverSeed': seed, 'commitment': commitment };
}
function getClientSeed() {
let seed = crypto.randomBytes(32).toString('hex');
if (usingCustomData) { seed = myClientSeed; }
return seed;
}
// Step 2: Create a Round Signature with SHA3 using a Server Seed, Client Seed and Nonce
function createRoundSignature(serverSeed, clientSeed, nonce) {
return sha3_256(`${serverSeed}:${clientSeed}:${nonce}`);
}
// Step 3: Create a SHAKE256 stream generator from a Round Signature.
// To simplify this example program, this function doesn't create a stream, but instead a sequence of custom length.
function* createRandomNumberSequence(numbersToGenerate, roundSignature) {
const numOfBytes = 4 * numbersToGenerate; // 4 bytes (32 bits) per random number we generate
const byteStream = shake256.create(8 * numOfBytes); // shake takes bits as input
byteStream.update(roundSignature); // Use the Round Signature to seed the generator
const buf = Buffer.from(byteStream.digest()); // The Buffer class lets us package every 4 bytes into one 32-bit integer
for (let i = 0; i < numbersToGenerate; i++) {
yield buf.readUInt32BE(i * 4); // Read buf in 4-byte steps
}
throw new Error("No more numbers in the random number sequence! Fix: make 'numbersToGenerate' larger.");
}
// Step 4: Draw from the random number sequence to calculate the game result
function getGameResult(rng) {
let randomInt32 = rng.next().value; // 'randomInt32' ranges from 0 and 4294967295
while (randomInt32 == 0xFFFFFFFF) { randomInt32 = rng.next().value; } // This can basically be ignored
const fraction = (randomInt32 + 1) / 0xFFFFFFFF; // 'fraction' ranges from 0 to 1
const inverse = 0.99 / fraction; // 'inverse' ranges from 0 to (basically) infinity
let crashPoint = Math.floor(inverse * 100) / 100; // Cut off everything past the second decimal place
// We force the crashpoint to range from 1 to 1,000,000
if (crashPoint < 1.0) {
crashPoint = 1.0;
}
if (crashPoint > 1000000) {
crashPoint = 1000000;
}
return crashPoint;
}
// Example usage
(function main() {
let nonce = 1;
if (usingCustomData) { nonce = myNonce; }
const { serverSeed, commitment } = generateServerSeed();
const clientSeed = getClientSeed();
const roundSignature = createRoundSignature(serverSeed, clientSeed, nonce);
const numbersToGenerate = 1 * 2; // We need 1 random number, but there is an improbable case we'll need two
const rng = createRandomNumberSequence(numbersToGenerate, roundSignature);
const value = getGameResult(rng);
console.log('📝 Commitment (shown before the game):', commitment);
console.log('🔒 Server Seed (revealed after the game):', serverSeed);
console.log('🎲 Client Seed:', clientSeed);
console.log('🔢 Nonce:', nonce);
console.log('🔁 Round Signature (can be verified after the game):', roundSignature);
console.log('⛓️💥 Break Point:', value);
})();
