हीलो

मानक कार्ड डेक में, 52 अद्वितीय संभावित परिणाम हैं। जब हमारी प्लेटफ़ॉर्म पर ब्लैकजैक, हिलो और बकार खेलने की बात आती है, तो हम गेम इवेंट उत्पन्न करते समय अनंत संख्या में डेक का उपयोग करते हैं, और इसलिए कार्ड का हर टर्न हमेशा समान संभावना रखता है। इसे गणना करने के लिए, हम प्रत्येक यादृच्छिक रूप से उत्पन्न फ्लोट को 52 से गुणा करते हैं, और फिर उस परिणाम को निम्नलिखित सूची के आधार पर एक विशेष कार्ड में अनुवाद करते हैं:

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

इन खेलों में एकमात्र भेद करने वाला कारक यह है कि हिलो और ब्लैकजैक में, एक कर्सर 13 है जो उन मामलों के लिए 52 संभावित गेम इवेंट उत्पन्न करता है जहां खिलाड़ी को बड़ी मात्रा में कार्ड वितरित करने की आवश्यकता होती है, जबकि बकार में, हमें केवल 6 गेम इवेंट उत्पन्न करने की आवश्यकता होती है ताकि अधिकतम खेलने योग्य कार्ड को कवर किया जा सके।

हीरे

जब हम डायमंड खेलते हैं, तो वहाँ 7 संभावित परिणाम होते हैं जो रत्न के रूप में होते हैं। इसे प्राप्त करने के लिए, हम प्रत्येक उत्पन्न फ्लोट को 7 से गुणा करते हैं, इससे पहले कि इसे निम्नलिखित अनुक्रमिका का उपयोग करके संबंधित रत्न में अनुवादित किया जाए:

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

पासा

हमारे डाइस के संस्करण में, हम 00.00 से 100.00 के संभावित रोल स्प्रेड को कवर करते हैं, जिसमें 10,001 संभावित परिणामों की एक श्रृंखला होती है। गेम इवेंट का अनुवाद संभावित परिणामों की संख्या से फ्लोट को गुणा करके किया जाता है और फिर 100 से विभाजित किया जाता है ताकि परिणामी संख्या हमारे बताए गए डाइस रेंज की सीमाओं में फिट हो सके।

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

सिक्का पलटना

जब हम कॉइनफ्लिप खेलते हैं, तो वहाँ सिक्कों के रूप में 2 संभावित परिणाम होते हैं। इसे प्राप्त करने के लिए, हम प्रत्येक उत्पन्न फ्लोट को 2 से गुणा करते हैं, इससे पहले कि इसे निम्नलिखित अनुक्रमिका का उपयोग करके संबंधित रत्न में अनुवादित किया जाए:

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

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

लिम्बो

जब लिम्बो की बात आती है, तो हम एक दो-चरणीय प्रक्रिया का उपयोग करते हैं। सबसे पहले, हम फ्लोट को अधिकतम संभव गुणक और हाउस एज दोनों से गुणा करते हैं। फिर, एक गेम इवेंट उत्पन्न करने के लिए जिसमें संभाव्यता वितरण हम अधिकतम संभावित गुणक को पहले चरण के परिणाम से विभाजित करते हैं ताकि एक गेम इवेंट को क्रैश पॉइंट के रूप में बनाया जा सके।

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

प्लिन्को

किसी भी प्लिंको खेल के लिए, उत्पन्न परिणाम गिरते गेंद के पथ पर आधारित है। खेल इवेंट गिरते गेंद के गिरने की प्रक्रिया में प्रत्येक स्तर के लिए गिरते गेंद की दिशा निर्धारित करता है। खिलाड़ी 8 और 16 पिन के बीच चुन सकते हैं, जो शीर्ष से नीचे तक एक पूर्ण पथ उत्पन्न करने के लिए आवश्यक खेल घटनाओं की संख्या निर्धारित करता है। चूंकि केवल दो संभावित दिशाएँ हैं (बाएँ या दाएँ), अनुवाद प्रत्येक फ़्लोट को 2 से गुणा करके किया जाता है, जो निम्नलिखित सूचकांक पर मैप करता है：

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

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

केनो

पारंपरिक केनो खेलों में बोर्ड पर हिट के रूप में 10 संभावित गेम इवेंट का चयन करने की आवश्यकता होती है।

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

फिशर-येट्स शफल कार्यान्वयन दोहराए जाने वाले संभावित हिट उत्पन्न होने से रोकने के लिए उपयोग किया जाता है।

खनिज

एक खदान का खेल 24 अलग-अलग गेम इवेंट के साथ उत्पन्न होता है, जो बोर्ड पर खदानों के रूप में होते हैं। प्रत्येक फ़्लोट को बोर्ड पर अभी भी बचे हुए संभावित अद्वितीय टाइलों की संख्या से गुणा किया जाता है। यह प्रत्येक गेम इवेंट परिणाम के लिए एकत्र किए गए फ़्लोट का उपयोग करते हुए उत्पन्न होने वाली इवेंट की संख्या को 1 से घटाकर किया जाता है। खदान की स्थिति को बाएँ से दाएँ, ऊपर से नीचे की ग्रिड स्थिति का उपयोग करके तैयार किया जाता है।

फिशर-येट्स शफल कार्यान्वयन दोहराए जाने वाले संभावित हिट उत्पन्न होने से रोकने के लिए उपयोग किया जाता है। चुने गए सेटिंग्स के आधार पर 1 से 24 गेम इवेंट परिणामों का उपयोग किया जाता है।

पहिया

खेल इवेंट संख्या को फ़्लोट को खंड में संभावित परिणामों से गुणा करके गणना की जाती है। फिर इसका उपयोग गेम इवेंट परिणाम को गुणक के रूप में निर्धारित करने के लिए किया जाता है, निम्नलिखित अनुक्रमांक का उपयोग करके:

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

क्रैश

हमारी निष्पक्षता को साबित करने के लिए, हमने 10,000,000 SHA256 हैश का एक श्रृंखला उत्पन्न की है, जहाँ प्रत्येक हैश पिछले हैश के हेक्साडेसिमल प्रतिनिधित्व का हैश है। श्रृंखला में अंतिम हैश है: 78a9757d3be42b74a3f70239078ad9317125fe9ee630d5bdada46de963e56752

खेल के परिणाम उत्पन्न करने का सूत्र:

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

डबल

हमारा डबल यूरोपीय संस्करण से लिया गया है जिसमें पहिया में 0 से 14 तक के 15 विभिन्न पॉकेट होते हैं। गेम इवेंट को 15 से गुणा करके और फिर निम्नलिखित सूची का उपयोग करके एक संबंधित पॉकेट में अनुवादित किया जाता है:

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

टॉवर

एक टॉवर खेल 9 अलग-अलग गेम इवेंट्स के साथ बनाया जाता है, जो टॉवर के स्तर के रूप में होते हैं। हम प्रत्येक स्तर के लिए कठिनाई के आधार पर अंडों की एक संख्या उत्पन्न करते हैं, और अंडे जिस टाइल पर हो सकते हैं, उसे भी पूर्णांक के रूप में दर्शाते हैं।

प्रत्येक उत्पन्न फ्लोट को पूर्णांकों में परिवर्तित किया जाता है ताकि प्रत्येक पंक्ति पर अंडे के स्थान का निर्धारण किया जा सके। उदाहरण के लिए: आसान स्तर को इस प्रकार दर्शाया जाएगा: [0, 1, 3] - अंडे टाइल 1, 2 और 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 },}

फिशर-येट्स शफल कार्यान्वयन का उपयोग एक पंक्ति में डुप्लिकेट अंडों को रोकने के लिए किया जाता है।