Provably Fair
🔐 उचित खेल प्रणाली: मल्टीप्लेयर हैश चेन जनरेशन
अवलोकन
पारदर्शिता और प्रमाणित निष्पक्षता सुनिश्चित करने के लिए, हमने प्रत्येक मल्टीप्लेयर गेम के लिए 10 मिलियन SHA256 हैशेस की एक श्रृंखला बनाई है, एक सर्वर गुप्त से शुरू करते हुए जिसे SHA256 के आउटपुट को 10 मिलियन बार खुद में वापस डाला गया है
Platform के लिए अंतिम हैश का SHA256 है: eeb4d340bfaed702601b9a08faba2f8088c4810c3e3a883293accaf25053b883
Crash के लिए अंतिम हैश का SHA256 है: c46f0705f6ba4df891ce44accda8f89f5a6fa8b987eb7c7b445280cf6cabfbc6
Battle के लिए अंतिम हैश का SHA256 है: 63cb1eb64ec4eb4de02f6bad85e42365d08f37497a1b7e907bd0b9183f27e1b3
इसे यहां प्रकाशित करके, हम एक वैकल्पिक SHA256 चेन चुनने की क्षमता को रोक रहे हैं। अब गेम सर्वर इस हैशेस की श्रृंखला को रिवर्स ऑर्डर में चला रहा है, गेम परिणामों को सिद्ध रूप से निष्पक्ष तरीके से गणना करने के लिए इन मानों का उपयोग कर रहा है।
यह कैसे काम करता है
1. गुप्त प्रारंभिक हैश: प्रत्येक मल्टीप्लेयर गेम प्रकार के अपने निजी प्रारंभिक हैश हैं (केवल सर्वर द्वारा ज्ञात), एक अद्वितीय हैश चेन की जड़ बनाते हैं।
2. हैश चेन जनरेशन: प्रारंभिक गुप्त हैश से, हम SHA256 को बार-बार लागू करके 10,000,000 हैशेस की एक श्रृंखला बनाते हैं।
func HashSeed(seed string) string {
hash := sha256.Sum256([]byte(seed))
return hex.EncodeToString(hash[:])
}
func CalculateHashChain(firstHash string) []string {
hashes := make([]string, 10_000_000)
for i := int64(0); i <= 10_000_000; i++ {
firstHash = HashSeed(firstHash)
hashes[i] = firstHash
}
return hashes
}
3. रिवर्स खपत: हम चेन में अंतिम हैश को जनता के सामने प्रकट करते हैं। प्रत्येक गेम राउंड हैशेस को रिवर्स ऑर्डर में खपत करता है: राउंड 1 हैश[10_000_000] का उपयोग करता है, राउंड 2 हैश[9_999_999] का उपयोग करता है, और इसी तरह...
4. यह डिज़ाइन भविष्य के हैशेस को जाली करना असंभव बनाता है, जबकि किसी को भी सभी पिछले हैशेस को सत्यापित करने की अनुमति देता है।
🔒 सुरक्षा और निष्पक्षता लाभ
अप्रत्याशितता: भविष्य के गेम परिणाम ज्ञात या प्रभावित नहीं हो सकते, यहां तक कि सर्वर द्वारा भी।
सत्यापन योग्यता: खिलाड़ी केवल सार्वजनिक रूप से प्रकट अंतिम हैश का उपयोग करके किसी भी पिछले राउंड की अखंडता को सत्यापित कर सकते हैं।
गेम अलगाव: प्रत्येक गेम प्रकार की अपनी चेन है, जो गेम-पार जोड़तोड़ को रोकता है।
सिंगल-प्लेयर गेम्स के लिए उचित खेल
सिंगल-प्लेयर गेम्स में सिद्ध निष्पक्षता सुनिश्चित करने के लिए, हमारा प्लेटफ़ॉर्म परिणाम बीज उत्पन्न करने के लिए तीन मुख्य घटकों पर आधारित एक प्रणाली का उपयोग करता है:
1. क्लाइंट सीड: यह एक उपयोगकर्ता-नियंत्रित बीज है। यह उपयोगकर्ता के पंजीकरण के समय स्वचालित रूप से उत्पन्न होता है, लेकिन उपयोगकर्ता इसे किसी भी समय बदल सकता है। क्लाइंट सीड को बदलने से एक नया सर्वर सीड उत्पन्न होता है।
2. सर्वर सीड: यह सर्वर द्वारा आंतरिक पैरामीटर का उपयोग करके उत्पन्न होता है जो उपयोगकर्ता को प्रकट नहीं किए जाते हैं। यह वर्तमान क्लाइंट सीड के लिए अद्वितीय रूप से बाध्य है। प्रत्येक क्लाइंट सीड के लिए, एक संबंधित सर्वर सीड है। जब उपयोगकर्ता क्लाइंट सीड बदलता है, तो पिछला सर्वर सीड सत्यापन उद्देश्यों के लिए प्रकट किया जाता है।
3. नॉन्स: एक अद्वितीय संख्या जो दांव के समय टिकट (मिलीसेकंड में) पर आधारित है। यह सुनिश्चित करता है कि दोहराए गए क्रियाएं भी विभिन्न परिणाम देते हैं।
गेम सीड जनरेशन
ये तीनों मान HMAC-SHA256 का उपयोग करके संयुक्त और हैश किए जाते हैं अंतिम गेम सीड उत्पन्न करने के लिए, जिसका उपयोग गेम के परिणाम निर्धारित करने के लिए किया जाता है।
func GenerateUserGameSeed(userSeed string, userServerSeed string, nonce int64) (string, error) {
data := fmt.Sprintf("%s:%s:%d", userServerSeed, userSeed, nonce)
mac := hmac.New(sha256.New, []byte(data))
gameSeed := hex.EncodeToString(mac.Sum(nil))
return gameSeed, nil
}
सत्यापन
सर्वर किसी भी दांव से पहले वर्तमान सर्वर सीड का हैश किया गया संस्करण प्रदान करता है।
जब उपयोगकर्ता अपने क्लाइंट सीड को बदलता है, तो पहले उपयोग किया जाने वाला सर्वर सीड प्रकट किया जाता है।
यह उपयोगकर्ताओं को सत्यापित करने की अनुमति देता है कि पिछले सर्वर सीड के साथ उत्पन्न सभी परिणाम सुसंगत और निष्पक्ष थे।