Így működik a provably fair a Mines-ban
Íme, hogyan játssz Mines-t a Cloudbeten, és hogyan ellenőrizheted, hogy minden kör aknaelhelyezése provably fair.
Hogyan játssz Mines-t
Minden Mines-kör a Cloudbeten ugyanazon a provably fair alapon nyugszik — Server Seed, Client Seed, Nonce, valamint SHA3-256/SHAKE256 —, amelyet részletesen bemutatunk a Hogyan Működik a Provably Fair központi oldalunkon. Ez az oldal azt mutatja be, ami kifejezetten a Mines-ra jellemző: hogyan válik az a véletlenszám-sorozat azzá az aknarácsá, amely ellen ténylegesen játszol.
Véletlenszámokból aknarács
A játék elején kiválasztod, hány aknát szeretnél elhelyezni — ezt a számot N-nek nevezzük. Az 5×5-ös Mines-rács egyetlen, 25 pozícióból álló sorrá alakítható ki, mindegyik saját indexszel, 1-től kezdve:
A véletlenszám-sorozatból (ugyanúgy generálva, ahogy a Provably Fair oldalon leírtuk) mintavételezünk egy számot, hogy meghatározzuk az első akna helyét:
Ha több aknát kell elhelyezni, újabb véletlenszámot húzunk, és megismételjük a folyamatot — de ekkor már csak 24 fennmaradó hely közül választhatunk:
Ez addig ismétlődik, amíg minden akna el nem helyezésre kerül. A teljes rács ezután összeáll, és titokban marad a kör végéig:
Technikai részletek: az egyes aknapozíciók kiválasztása
Minden egyes húzás előtt ismerjük P-t — a még rendelkezésre álló, aknamentes pozíciók számát. P kezdetben 25, és minden akna elhelyezésekor eggyel csökken.
Minden aknához a SHAKE256 kimenetéből egy véletlenszerű 4 byte-os (32 bites) számot húzunk, 0 és 4 294 967 295 között. Hogy P pozíció közül tisztességesen válasszunk, elutasításos mintavételt alkalmazunk (lásd az általános elvet a Hogyan Működik a Provably Fair oldalon), majd az eredményt modulo P-vel elosztva kapjuk meg az elhelyezési indexet:
// Pseudo Code
const placementIndex = randomNumber % P;
Ha még maradt elhelyezendő akna, a kiválasztott pozíciót eltávolítjuk a listáról, P eggyel csökken, és a folyamat megismétlődik.
Játékmenet
A végleges, aknákkal feltöltött rács a szerveren jön létre és marad rejtve, mielőtt bármilyen lépést tennél — ezután észrevétlenül nem lehet megváltoztatni, hála a veled már megosztott Commitmentnek. Minden egyes mező, amit kiválasztasz, egyszerűen ehhez a rejtett rácshoz van hasonlítva.
Kód a független ellenőrzéshez
Ez a program pontosan megfelel a Mines Cloudbeten futó implementációjának. Add meg a Server Seededet, a Client Seededet, a Nonce-odat és az aknák számát, telepítsd az egyetlen függőséget, majd futtasd le magad, hogy visszaállítsd a játékod eredményét.
Megjegyzés: ahhoz, hogy egy lezárt játék Server Seedjét felfedd a Cloudbeten, már el kellett indítanod egy új kört (ami új seed-párra vált).
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
let myNumberOfMines = 3; // ✍️YOUR_INPUT✍️: Enter your number of mines 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); // shaker256 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: Generate the mine locations
function pickUniquePositions(mineCount, totalTiles, rng) {
const available = Array.from({ length: totalTiles }, (_, i) => i);
let result = [];
for (let i = 0; i < mineCount; ++i) {
const index = sample(available.length, rng);
result.push(available[index]);
available.splice(index, 1); // Remove chosen position from list of available positions
}
result.sort((a, b) => a - b); // Sort the mine positions from smallest to largest
result = result.map(num => num + 1); // Increment positions by one so that they start with 1, 2, 3, ...
return result;
}
// Rejection sampling for fair results
function sample(P, rng) {
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;
}
// Example usage
(function main() {
const gridSize = 25;
let mineCount = 3;
let nonce = 1;
if (usingCustomData) { mineCount = myNumberOfMines; nonce = myNonce; }
const { serverSeed, commitment } = generateServerSeed();
const clientSeed = getClientSeed();
const roundSignature = createRoundSignature(serverSeed, clientSeed, nonce);
const numbersToGenerate = 24 * 2; // There are max. 24 mines, however due to rejection sampling we may need more random numbers
const rng = createRandomNumberSequence(numbersToGenerate, roundSignature);
const minePositions = pickUniquePositions(mineCount, gridSize, 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('💣 Mine Positions (1 = top-left square, 5 = top-right square, 25 = bottom-right square):', minePositions);
})();
Próbáld ki most: tedd próbára a szerencsédet a Mines-ban
Élőben is megnéznéd? Játssz egy kört a Cloudbet Mines-ban — majd ellenőrizd az eredményeidet a provably fair kalkulátorral. Mindössze pár másodpercet vesz igénybe. Semmilyen technikai tudásra nincs szükséged hozzá.
Így élőben is láthatod a folyamatot, megvizsgálhatod a seedjeidet, és megnézheted, hogyan építi fel az eszköz nulláról az eredményedet.
