एक नॉन्स, कई संख्याएँ: कर्सर क्या गिनता है

चौथा इनपुट

provably fair गेमिंग की हर व्याख्या, जिसमें हमारी भी शामिल है, तीन इनपुट बताती है: एक सर्वर सीड जिसे हाउस पहले से कमिट करता है, एक क्लाइंट सीड जिसे आप खुद सेट कर सकते हैं, और एक नॉन्स जो हर बेट के साथ एक-एक करके बढ़ता है। इन्हें एक keyed hash में डालो और राउंड की रैंडमनेस बाहर आ जाती है। यह विवरण एक कॉइन फ्लिप के लिए पूर्ण है। यह लगभग बाकी सब चीज़ों के लिए अधूरा है, क्योंकि एक हैश एक संख्या देता है और ज़्यादातर गेम्स को कई की ज़रूरत होती है।

चौथा इनपुट कर्सर है। इस साइट पर जिस मैसेज को हैश किया जाता है वह “क्लाइंट सीड-नॉन्स” नहीं बल्कि “क्लाइंट सीड-नॉन्स-कर्सर” है, और कर्सर राउंड के अंदर का एक काउंटर है: गेम को चाहिए पहली रैंडम संख्या के लिए 0, दूसरी के लिए 1, और आगे भी ऐसे ही। हर कर्सर वैल्यू एक ताज़ा 256-बिट डाइजेस्ट देती है, जो अपने पड़ोसियों से किसी भी तरह से जुड़ी नहीं होती जिसे आप एक्सप्लॉइट कर सकें, और इंजन हर डाइजेस्ट के पहले आठ बाइट्स को 0 और 1 के बीच की एक संख्या के रूप में पढ़ता है।

ENGINE-VERIFIED_shared/demoLocal.ts: uAt(pair, cursor) रिटर्न करता है u64(HMAC-SHA256(serverSeed, `${clientSeed}-${nonce}-${cursor}`)), जिसे सर्वर के RandomUtils.generateHash(“clientSeed-nonce-cursor”) से मेल खाता हुआ बताया गया है। _shared/rng.ts: u64 डाइजेस्ट के पहले आठ बाइट्स को hi/2^32 + lo/2^64 के रूप में पढ़ता है, “वही सिंगल-राउंडिंग कंस्ट्रक्शन” जो सर्वर के ULong→Double कन्वर्शन में है। नॉन्स सभी गेम्स में प्रति सीड जोड़ी एक स्ट्रीम है: हर बेट मौजूदा नॉन्स को इस्तेमाल करता है और nonce + 1 स्टोर करता है।

तो एक राउंड एक रैंडम संख्या नहीं बल्कि उनकी एक नंबरदार लिस्ट है, जितनी गेम को चाहिए उतनी लंबी, और लिस्ट की हर एंट्री उसी पल फिक्स हो जाती है जब सीड जोड़ी और नॉन्स तय होते हैं। गेम चलते-चलते ड्रॉ नहीं करता। यह एक पहले से मौजूद लिस्ट को नीचे की ओर पढ़ता है।

हर गेम क्या पढ़ता है

दिलचस्प बात यह है कि यह लिस्ट हर गेम के लिए अलग होती है, और हर derivation module अपने हेडर में अपना लेआउट बताता है। यहाँ हर उस ओरिजिनल का कर्सर स्ट्रीम है जो सीड जोड़ी से ड्रॉ करता है, इंजन सोर्स से लिया गया।

प्रति राउंड कर्सर उपयोग, हर गेम के derivation module से

Keno और Crash अपवाद हैं: उनके डेमो राउंड नीचे बताई गई सीड-पेयर nonce के बजाय प्रति-टिकट हैश चेन का उपयोग करते हैं। Mines और Plinko हाउस सर्विस द्वारा तय किए जाते हैं; mines API नोट करता है कि पूरा लेआउट एक ही nonce से आता है।

ENGINE-VERIFIEDbingo/derive.ts में हेडर कमेंट्स (“Cursor stream: 0..24 — the card … 25..62 — the 38 balls”), hanabi/engine.ts (“base spin = cells 0..14 … free spin j = cells 15+15j .. 29+15j”), blackjack/derive.ts (“card i = floor(u × 52) at cursor i … Deal order (cursor): player1, dealer-up, player2, dealer-hole”), vpoker/derive.ts (“the first five are the deal, replacements continue the same sequence … Hold everything and no further cursor is read”), holdem/derive.ts (“player1, player2, dealer1, dealer2, flop1, flop2, flop3, turn, river. The turn/river cursors are only consumed on CALL”), andar/derive.ts (cursors 0–4 then “5.. one cursor per raced card”), koban/derive.ts (“flip i reads cursor i”), sicbo/derive.ts (“cursors 0/1/2 are the three dice”), roulette/derive.ts (“cursor 0 alone decides the pocket: floor(u × 37)”), fuku/derive.ts (“cursor 0 alone draws the item”), omikuji/derive.ts (cursor 0 tier, 1..3 winning cells, 4.. fillers); demoLocal.ts rollSide (chinchiro cursor = side*9 + attempt*3 + d), trapAt (pagoda: the floor number is the cursor), demoLimboBet (uAt(p, 0)); mines/minesApi.ts (“the whole mine layout comes off this one nonce”).

उस टेबल में तीन चीज़ें उभर कर सामने आती हैं। पहली, जो गेम्स कार्ड डील करते हैं वे एक निश्चित क्रम में प्रति कार्ड एक कर्सर पढ़ते हैं, यही कारण है कि ब्लैकजैक हैंड को उसकी एक्शन लिस्ट से रीप्ले किया जा सकता है: हिट करने का आपका निर्णय कोई नया कार्ड नहीं बनाता, बल्कि उस लिस्ट के अगले कार्ड को पलटता है जो डील से पहले ही पूरी थी। दूसरी, कई गेम्स जल्दी पढ़ना बंद कर देते हैं। एक वीडियो पोकर हैंड जिसमें आप सभी पांच कार्ड होल्ड करते हैं, वह कभी कर्सर 5 को नहीं छूता; एक Hold'em फोल्ड कभी टर्न या रिवर नहीं पढ़ता। नंबर वहां थे; गेम को उनकी ज़रूरत नहीं पड़ी। तीसरी, अंदर बहार में दो बूस्टेड बकेट और ओमिकुजी में फॉर्च्यून टियर, कार्ड्स और सेल्स से पहले, स्ट्रीम के आरंभ में ड्रॉ किए जाते हैं, इसलिए राउंड की विशेष विशेषताएं उसी कमिटमेंट से तय होती हैं जिससे उसकी सामान्य विशेषताएं होती हैं।

बिना रिप्लेसमेंट के ड्रॉइंग

0 और 1 के बीच की एक यूनिफॉर्म संख्या को रूलेट पॉकेट में बदलना आसान है: 37 से गुणा करें और नीचे की ओर राउंड करें। एक डेक ज़्यादा कठिन है, क्योंकि दूसरा कार्ड पहले कार्ड जैसा नहीं होना चाहिए। इंजन इसे उस तरीके से हैंडल करता है जिसे इसके कमेंट्स 'पूल हॉप' कहते हैं: पूल में अभी भी मौजूद कार्ड्स की एक लिस्ट रखें, कर्सर की संख्या का उपयोग उसमें एक पोजीशन चुनने के लिए करें, और चुने गए कार्ड को लिस्ट के अंत में स्वैप करें ताकि अगला ड्रॉ एक कम कार्ड में से चुने। वीडियो पोकर, कैसीनो होल्ड'एम, अंदर बहार और बिंगो कार्ड सभी इसी तरह ड्रॉ करते हैं, इसलिए एक राउंड के भीतर कोई कार्ड या संख्या दोहराई नहीं जाती।

ब्लैकजैक जानबूझकर किया गया अपवाद है। इसका शू अनंत है: हर कार्ड अपने स्वयं के कर्सर से floor(u × 52) है, और एक हैंड में वही कार्ड दो बार दिखाई दे सकता है। यह एक डिज़ाइन विकल्प है जिसकी एक प्रकाशित लागत है, जिसकी चर्चा ब्लैकजैक पेआउट आर्टिकल में की गई है, और यह बिल्कुल वैसी चीज़ है जो कर्सर लेआउट आपको बताता है जो एक मार्केटिंग पेज नहीं बताएगा।

ENGINE-VERIFIEDvpoker/derive.ts: “Cards come from ONE without-replacement sequence over the 52-card deck (pool-hop, cursor per draw)”. holdem/derive.ts: “ONE without-replacement pool-hop sequence (cursor per draw)”. bingo/derive.ts: “five pool-hop draws per column” and “the 38 balls, pool-hops over 1..75”. blackjack/derive.ts: “Infinite shoe: card i = floor(u × 52) at cursor i”.

दो अपवाद

Keno और Crash डेमो इंजन में सीड-पेयर नॉन्स को बिल्कुल भी नहीं पढ़ते। Keno एक प्रति-टिकट योजना का उपयोग करता है: टिकट को अपना खुद का रैंडम हैश और एक साल्ट मिलता है, और दस गेंदों में से हर एक को पिछले हैश को फिर से हैश करके, अग्रणी बिट्स को एक संख्या के रूप में लेकर और सिकुड़ते हुए चालीस के पूल में से चुनकर निकाला जाता है। फेयरनेस पैनल एक keno टिकट को सीड पेयर के बजाय उन दो स्ट्रिंग्स से सत्यापित करता है। Crash bustabit परंपरा का पालन करता है, हैशों की एक श्रृंखला जहां हर राउंड का क्रैश पॉइंट अपनी ही लिंक से सटीक इंटीजर अंकगणित के साथ गणना किया जाता है।

ENGINE-VERIFIEDdemoLocal.ts kenoDraws: “प्रति-बेट randomHash चेन + साल्ट (फेयरनेस मोडल के जरिए प्रति टिकट सत्यापन योग्य) … सीड-पेयर नॉन्स को नहीं छूता”; लूप HMAC-SHA256(साल्ट, पिछला हैश) को दस बार हैश करता है, अग्रणी 52 बिट्स को पढ़ता है और 40-संख्या के पूल से इंडेक्स floor(norm × remaining) चुनता है, साथ में अंत में एक स्वैप। rng.ts h52 और क्रैश कमेंट: “bustabit क्रैश पॉइंट सौवें में: floor((n·e − h)/(e − h)), e = 2^52, n = 100 … सर्वर से मिलान के लिए सटीक BigInt गणित”।

न तो कोई अपवाद कर्सर योजना से कमजोर है; दोनों ही पुराने और अधिक जाने-माने हैं। एक खिलाड़ी के लिए जो मायने रखता है वह सिर्फ यह है कि पैनल दिखाता है कि किसी राउंड ने कौन सी योजना इस्तेमाल की, और यह कि हर एक को उसकी दिखाई गई स्ट्रिंग्स से फिर से गणना किया जा सकता है।

टेबल पर इसका क्या मतलब है

• राउंड आपके एक्ट करने से पहले ही मौजूद होता है। एक राउंड का हर कार्ड, गेंद और रील सिंबल सीड पेयर, नॉन्स और उसकी कर्सर पोजीशन का एक फंक्शन है। हिट करना, कॉल करना या होल्ड करना यह चुनता है कि कौन सी एंट्रीज पढ़ी जाएं, न कि वे क्या रखती हैं।
• आपकी चॉइस लिस्ट को नहीं बदल सकतीं, और न ही हाउस बदल सकता है। एक बार सर्वर सीड कमिट हो जाए और नॉन्स फिक्स हो जाए, तो कोई भी पक्ष एंट्री 7 को बिना सीड बदले नहीं बदल सकता, जिससे आपको दिखाया गया फिंगरप्रिंट टूट जाएगा।
• एक वेरिफायर को उसी लिस्ट को उसी तरह पढ़ना होता है। बिंगो राउंड को फिर से गणना करने का मतलब है सभी 63 कर्सर को प्रकाशित क्रम में डेराइव करना; Hold'em फोल्ड को फिर से गणना करने का मतलब है 7 डेराइव करना। सीड पैनल यह आपके ब्राउज़र में करता है, और ऊपर टेबल में दिए गए लेआउट इसी का पालन करते हैं।
• एक स्ट्रीक एक लिस्ट है, मूड नहीं। दो राउंड सिर्फ सीड पेयर साझा करते हैं; उनके नॉन्स अलग होते हैं और इसलिए हर डाइजेस्ट अलग होता है। यही बात हॉट हैंड आर्टिकल दूसरी दिशा से बनाता है।

तीन इनपुट राउंड तय करते हैं। चौथा तय करता है कि राउंड कितना लंबा है। एक लाइन में, कर्सर

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

अक्सर पूछे जाने वाले सवाल

प्रोवेबली फेयर राउंड में कर्सर क्या है?

राउंड के अंदर एक काउंटर। सर्वर सीड के साथ हैश किया गया मैसेज है “client seed-nonce-cursor”; कर्सर 0 गेम को चाहिए वाला पहला रैंडम नंबर देता है, कर्सर 1 दूसरा, और इसी तरह। एक गेम जिसे सिर्फ एक नंबर चाहिए वह केवल कर्सर 0 पढ़ता है।

कर्सर नॉन्स से कैसे अलग है?

नॉन्स राउंड गिनता है और हर ओरिजिनल में हर बेट के साथ एक-एक करके बढ़ता है। कर्सर एक राउंड के भीतर ड्रॉज़ गिनता है और हर राउंड 0 पर फिर से शुरू होता है। सीड पेयर के साथ मिलकर, ये साइट द्वारा उत्पन्न हर रैंडम नंबर की पहचान करते हैं।

एक बिंगो राउंड कितने रैंडम नंबर इस्तेमाल करता है?

तिरसठ: कर्सर 0 से 24 कार्ड के 25 सेल्स को बिछाते हैं और कर्सर 25 से 62 तक 38 गेंदें निकालते हैं, सभी अपने-अपने पूल के भीतर बिना रिप्लेसमेंट के।

क्या ब्लैकजैक में हिट करना अगले कार्ड को बदल देता है?

नहीं। हर कार्ड डील ऑर्डर में अपने ही कर्सर से डेराइव होता है, और पूरी लिस्ट तब मौजूद हो जाती है जब सीड पेयर और नॉन्स फिक्स हो जाते हैं। हिट करना अगली एंट्री पढ़ता है; स्टैंड करना उसे अनरीड छोड़ देता है।

क्या सभी गेम कर्सर स्कीम का उपयोग करते हैं?

Keno और Crash इसके बजाय हैश चेन का उपयोग करते हैं: keno एक प्रति-टिकट रैंडम हैश और सॉल्ट को दस बार हैश करता है, और crash बस्टाबिट चेन का पालन करता है सटीक इंटीजर अरिथमेटिक के साथ। फेयरनेस पैनल दिखाई गई स्ट्रिंग्स से प्रत्येक को सत्यापित करता है।

स्रोत और संदर्भ

• Betkyo इंजन सोर्स: _shared/demoLocal.ts (uAt, rollSide, trapAt, kenoDraws), _shared/rng.ts (u64, h52, crash point), और bingo, hanabi, blackjack, vpoker, holdem, andar, koban, sicbo, roulette, fuku और omikuji के लिए डेरिवेशन मॉड्यूल्स
• RFC 2104 — HMAC: Keyed-Hashing for Message Authentication
• Bustabit प्रोवेबली फेयर स्कीम (क्रैश-पॉइंट कंस्ट्रक्शन जिसे इंजन प्रतिबिंबित करता है)

इस लेख में गेम्स

Blackjack — नियम और फ्री प्ले →Bingo — नियम और फ्री प्ले →Sic Bo — नियम और फ्री प्ले →