Így működik a provably fair a Dice: Golden Ticketben
Íme, hogyan játssz Dice: Golden Ticketet a Cloudbeten, és hogyan ellenőrizheted, hogy minden dobás és Golden Ticket-húzás provably fair.
Hogyan játssz Dice: Golden Tickettel
A Dice: Golden Ticket (DGT) ugyanúgy játszódik, mint a Cloudbet klasszikus Dice játéka, egy extra réteggel: egy rejtett bónuszcéllal, amely a normál nyereményed felett bónuszszorzót is kifizethet.
Alapjáték: válaszd a Roll Over-t (2,00–99,99) vagy a Roll Under-t (0,01–98,00), majd tedd meg a tétedet. Ha a dobás a célértéked oldalára esik, nyersz, a célértéked által meghatározott kifizetéssel (szűkebb célérték = nagyobb szorzó).
A Golden Ticket bónusz: minden körben egy második, rejtett érték — a Golden Ticket — is beállításra kerül a táblán, saját, 3x és 200x közötti bónuszszorzóval. Ha a dobásod a Golden Ticket pozíciójától ±1,75-ön belülre esik, azonnal és automatikusan megnyered a bónuszkifizetést ezzel a szorzóval — nincs szükség extra tétre, és ez hozzáadódik a normál nyereményedhez.
A Golden Tickettel nem közvetlenül célzol — nem olyasmi, amit befolyásolhatsz vagy célba vehetsz, egyszerűen mindig valahol a táblán van minden körben, és a közelébe esés bónusz a szokásos játékod tetejére.
Cloudbet Originals Dice: Golden Ticket
A Cloudbet saját Originals DGT játékának 99%-os RTP-je, x6 730-as maximális dobásszorzója és 1 000 000 $-os maximális nyereménye van.
A Dice: Golden Ticket (DGT) ugyanazon a provably fair alapon nyugszik, mint minden Cloudbet Original játék — az általános mechanizmusért lásd a Hogyan Működik a Provably Fair oldalt (Server Seed, Client Seed, Nonce, SHAKE256, elutasításos mintavétel). A dobás értékének mintavételezése is ugyanúgy működik, mint a sima Dice-nál — a DGT ehhez adja hozzá a Golden Ticket-értéket és -szorzót. Az alábbiakban bemutatjuk, hogyan válik ez a sorozat kifejezetten a DGT-eredményeddé.
Véletlenszámok átalakítása játékeredménnyé
A DGT-nek két értéket kell bizonyíthatóan ellenőrizhető véletlenszerűséggel meghatároznia: a dobás értékét és a Golden Ticket értékét.
A folyamat egyszerű: először egy 0 és 10000 közötti egész számot (a végpontokkal együtt) mintavételezünk, ez lesz a dobás végleges értéke. Ezután egy 175 és 9825 közötti egész számot (a végpontokkal együtt) mintavételezünk, ez lesz a Golden Ticket végleges értéke. Mindkét számot elosztjuk 100-zal, hogy mindkettőnek két tizedesjegye legyen — a dobás 0-tól 100-ig, a Golden Ticket 1,75-től 98,25-ig terjed.
A Golden Ticket tartományát szándékosan 1,75–98,25-re korlátozzuk, nem 0–100-ra, hogy bárhová is essen, mindig legyen egy teljes, 3,5 széles „arany zóna” körülötte, ahová a dobás értéke eshet, és megnyerheted vele a bónuszt. Ha a tartomány egészen a szélekig (0-ig vagy 100-ig) terjedne, egy szélhez közel eső Golden Ticketnek kisebb arany zónája — és rosszabb esélyei — lennének, mint egy középen elhelyezkedőnek.
A DGT-nek van egy egyedi jellemzője is: a Golden Ticket szorzóját maga is egy provably fair folyamat generálja. Egyszerűen fogalmazva: egy harmadik, 0 és 1 közötti véletlenszámot húzunk, majd ezt egy csonkolt Pareto-eloszlás segítségével 3 és 200 közötti szorzóvá alakítjuk.
Technikai részletek
A SHAKE256 által generált véletlenszerű byte-okat 4 byte-os előjel nélküli egészekre osztjuk, 0-tól 2³²-1-ig. Mivel a dobás értékének 10001 lehetséges kimenetele van (0–10000, a végpontokkal együtt), az elutasításos mintavétel P = 10001 értékkel dolgozik; a Golden Ticket értékének 9651 lehetséges kimenetele van (175–9825, a végpontokkal együtt), tehát ennek P = 9651. (Lásd a provably fair oldalt, hogy miért fontos ez a lépés.)
A dobás és a Golden Ticket értékének kiválasztása: a dobáshoz tartozó véletlenszámot modulo 10001 művelettel alakítjuk az értékévé. Ugyanezt tesszük a Golden Ticket véletlenszámával, 9651-gyel, majd az eredményhez hozzáadunk 175-öt (így 175–9825 közé esik). Mindkettőt ezután elosztjuk 100-zal.
A Golden Ticket szorzójának kiválasztása (valamennyi statisztikai ismeret hasznos itt): húzunk egy véletlenszerű 32 bites számot, és elosztjuk a lehetséges legnagyobb értékével, így egy egyenletes eloszlású, 0 és 1 közötti számot kapunk. Ezt az értéket egy csonkolt Pareto-eloszlássá alakítjuk (alsó határ 3, felső határ 200, alfa 1,343 — ezt úgy választottuk, hogy a szorzó várható értéke 9 legyen, ami megfelel a DGT 99%-os RTP célértékének), majd két tizedesjegyre kerekítjük.
Játékmenet
Mind a dobás, mind a Golden Ticket értéke szerveroldalon jön létre, és rejtve marad a kör végéig — észrevétlenül nem lehet megváltoztatni őket, miután a játék elkezdődött. Miután megtetted a tétedet, az általad választott küszöbértéket összehasonlítjuk a dobás értékével, és a Golden Ticket dobás értékétől mért távolságát összevetjük az 1,75-ös „arany zónával”, hogy lássuk, nyertél-e bónuszt.
Kód a független ellenőrzéshez
Pontosan megfelel a Cloudbeten futó DGT-implementációnak — add meg a Server Seededet, a Client Seededet és a Nonce-odat, hogy ellenőrizd saját játékaidat. (Ahhoz, hogy egy játék Server Seedjét felfedd a Cloudbeten, már át kellett váltanod egy új Server Seedre.)
Függőségek:
npm install js-sha3
A kód:
// 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 = 1; // ✍️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) {
// Dice
// Ranges from 0 to 100, with two decimal places
const diceMinValue = 0;
const diceMaxValue = 10000;
let diceValue = sampleFromRange(diceMinValue, diceMaxValue, rng);
diceValue = diceValue / 100; // Now the value ranges from 0 to 100
// Golden Ticket
// Ranges from 1.75 to 98.25 due to fairness
// (If it landed on 99, for example, then the chance of the dice landing near
// it would be smaller than the guarantee of 3.5%)
const gtMinValue = 175;
const gtMaxValue = 9825;
let goldenTicketValue = sampleFromRange(gtMinValue, gtMaxValue, rng);
goldenTicketValue = goldenTicketValue / 100;
// Golden Ticket Multiplier
const multiplier = getRandomNumberTruncatedPareto(rng); // Complicated maths, can be ignored ;)
return { diceValue, goldenTicketValue, multiplier };
}
// Sample a number using the truncated Pareto distribution
function getRandomNumberTruncatedPareto(rng) {
// Get a uniformly distributed number between 0 and 1
let randomInt32 = rng.next().value;
const fraction = randomInt32 / 0xFFFFFFFF;
// Truncated Pareto distribution. The expected value is 9.00
const m0 = 3;
const m1 = 200;
const alpha = 1.343;
const r = Math.pow(m0 / m1, alpha);
const inner = 1 - fraction * (1 - r);
let randomNumber = m0 / Math.pow(inner, 1 / alpha);
randomNumber = Math.round(randomNumber * 100) / 100; // Round to 2 decimal places
return randomNumber;
}
// Sample a number between 'min' to 'max' (inclusive) using Rejection Sampling
function sampleFromRange(min, max, rng) {
const P = max - min + 1;
const maxAcceptable = Math.floor(0x100000000 / P) * P;
// Rejection sampling
let rand;
do {
rand = rng.next().value;
} while (rand >= maxAcceptable);
// Modulo operation
const sampled_number = rand % P;
return sampled_number + min;
}
// 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 = 3 * 2; // We need 3 random numbers, however due to rejection sampling we may need more
const rng = createRandomNumberSequence(numbersToGenerate, roundSignature);
const { diceValue, goldenTicketValue, multiplier } = 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('🎯 Dice landed on:', diceValue);
console.log('🎫 Golden ticket landed on:', goldenTicketValue);
console.log('⭐ Multiplier:', multiplier);
})();
