BC.GAME (OP)
Copper Member
Full Member
Offline
Activity: 238
Merit: 119
|
|
June 19, 2020, 05:45:30 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
|
|
"Bitcoin: the cutting edge of begging technology." -- Giraffe.BTC
|
|
|
Advertised sites are not endorsed by the Bitcoin Forum. They may be unsafe, untrustworthy, or illegal in your jurisdiction.
|
|
elfane20
Newbie
Offline
Activity: 1
Merit: 0
|
|
June 19, 2020, 06:03:21 AM |
|
woww thats goods, best formula
|
|
|
|
okseo122
Newbie
Offline
Activity: 6
Merit: 0
|
|
June 19, 2020, 06:05:56 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. coco asked me to quote this. So I'm quoting this and fuck coco btw
|
|
|
|
BC.GAME (OP)
Copper Member
Full Member
Offline
Activity: 238
Merit: 119
|
|
June 19, 2020, 06:12:06 AM |
|
|
|
|
|
|
Zaynab
Newbie
Offline
Activity: 17
Merit: 0
|
|
June 19, 2020, 09:04:02 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. coco asked me to quote this. So I'm quoting this and fuck coco btw
|
|
|
|
BC.GAME (OP)
Copper Member
Full Member
Offline
Activity: 238
Merit: 119
|
|
June 19, 2020, 09:26:46 AM |
|
We made the decision to update Crash using a salted hash as requested by our players in order to provide the most randomized and fair results possible after Bet # 2561902 For further details, please visit https://bcsnproject.github.io/bcgame-crash/
|
|
|
|
ChuckBuck
|
|
June 19, 2020, 06:07:30 PM |
|
Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:
Although I cannot understand the technical changes in your site details, but I appreciate upgrading your site system based on community feedback. This shows how much you value your customers Also, it is rare for me to see casinos publishing their algorithms publicly on this forum Hope you will have more and more customers
|
|
|
|
nakamura12
|
|
June 19, 2020, 09:21:47 PM |
|
Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated:
Although I cannot understand the technical changes in your site details, but I appreciate upgrading your site system based on community feedback. This shows how much you value your customers Also, it is rare for me to see casinos publishing their algorithms publicly on this forum Hope you will have more and more customers Indeed, when a company is serving the customers first is one of the things that I want to a company or a platform which in my opinion will greatly improve the platform but also the reputation rather than not doing at all. I notice you did change some of the codw but I am not exoert at it so it is best that you did explained which you did and it help some to check the game fairness.
|
| | | | | | | ███▄▀██▄▄ ░░▄████▄▀████ ▄▄▄ ░░████▄▄▄▄░░█▀▀ ███ ██████▄▄▀█▌ ░▄░░███▀████ ░▐█░░███░██▄▄ ░░▄▀░████▄▄▄▀█ ░█░▄███▀████ ▐█ ▀▄▄███▀▄██▄ ░░▄██▌░░██▀ ░▐█▀████ ▀██ ░░█▌██████ ▀▀██▄ ░░▀███ | | ▄▄██▀▄███ ▄▄▄████▀▄████▄░░ ▀▀█░░▄▄▄▄████░░ ▐█▀▄▄█████████ ████▀███░░▄░ ▄▄██░███░░█▌░ █▀▄▄▄████░▀▄░░ █▌████▀███▄░█░ ▄██▄▀███▄▄▀ ▀██░░▐██▄░░ ██▀████▀█▌░ ▄██▀▀██████▐█░░ ███▀░░ | | | | |
|
|
|
lokieluke
Newbie
Offline
Activity: 7
Merit: 0
|
|
June 21, 2020, 11:35:41 AM |
|
Can i get a shit code.. but a good shit code.
|
|
|
|
Saint-loup
Legendary
Offline
Activity: 2604
Merit: 2354
|
|
June 21, 2020, 06:00:05 PM Last edit: June 21, 2020, 06:20:42 PM by Saint-loup |
|
We made the decision to update Crash using a salted hash as requested by our players in order to provide the most randomized and fair results possible after Bet # 2561902 For further details, please visit https://bcsnproject.github.io/bcgame-crash/Hello Are you using a hash chain for your seeds? If yes, why don't you post it like you've done for your other games : Keno Starting with a secret I've generated a chain of 10,000,000 SHA256 hashes. Each element is the hash of the lowercase, hexadecimal string representation of the previous hash. The hash of the chain's last element is 54fe30623823224ef8379e00f3d88a02ed3333937862ee0383b9cbb3d1e43763
Roulette game Starting with a secret I've generated a chain of 10,000,000 SHA256 hashes. Each element is the hash of the lowercase, hexadecimal string representation of the previous hash. The hash of the chain's last element is f6c4a94c4a2dd2912fbef23fb68aa56488313a343c9cf6c95e52b8ef74230991 .
If no, could you tell us how you are choosing your seeds please? TYVM
|
|
|
|
TBCT Boy
Newbie
Offline
Activity: 2
Merit: 0
|
|
October 18, 2020, 08:05:02 AM |
|
Thank you so much guys:))
|
|
|
|
BC.GAME (OP)
Copper Member
Full Member
Offline
Activity: 238
Merit: 119
|
|
October 18, 2020, 08:19:37 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. coco asked me to quote this. So I'm quoting this and fuck coco btw LMAO af. I can't believe I didn't see this endearing comment!.
|
|
|
|
|
BC.GAME (OP)
Copper Member
Full Member
Offline
Activity: 238
Merit: 119
|
|
October 21, 2020, 01:04:43 AM |
|
So it could be easily found and referenced by anyone rather than being lost somewhere in the middle of our main thread. This has been the most common way of doing these seeding events here at the forum.
|
|
|
|
TBCT Boy
Newbie
Offline
Activity: 2
Merit: 0
|
|
October 23, 2020, 12:09:58 PM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
apaktomy
Newbie
Offline
Activity: 3
Merit: 0
MMMGLOBAL - a right step to make a better life
|
|
December 30, 2020, 06:42:48 PM |
|
|
lets us all make 100% profit per month..
|
|
|
apaktomy
Newbie
Offline
Activity: 3
Merit: 0
MMMGLOBAL - a right step to make a better life
|
|
January 01, 2021, 05:46:30 PM |
|
|
lets us all make 100% profit per month..
|
|
|
apaktomy
Newbie
Offline
Activity: 3
Merit: 0
MMMGLOBAL - a right step to make a better life
|
|
January 06, 2021, 04:52:08 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
lets us all make 100% profit per month..
|
|
|
Celina14493
Newbie
Offline
Activity: 1
Merit: 0
|
|
January 21, 2021, 04:59:51 PM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
Vyrine
Newbie
Offline
Activity: 14
Merit: 28
|
|
February 08, 2021, 06:06:09 AM |
|
We made the decision to update Crash using a salted hash as requested by our players in order to provide the most randomized and fair results possible after Bet # 2561902 For further details, please visit https://bcsnproject.github.io/bcgame-crash/Can I know what hash is used after the bet #2561902?
|
|
|
|
Taisoon00
Newbie
Offline
Activity: 1
Merit: 0
|
|
May 01, 2021, 01:39:50 PM Last edit: May 01, 2021, 01:52:25 PM by Taisoon00 |
|
سلام،خسته نباشید.اگر شما صادقانه حرف میزنید چرا با بیتکوین حساب میکنید،بروید با ترتل حساب کنید،ارز مرکزی است،اولین ارز است ،خواهش میکنم چند دقیقه با وژدان خود تنها باشید.اگر با بیتکوین شما نتیجه انصاف را اعلام می کنید در این صورت فقط ثروتمندان می توانند بردهای خوبی داشته باشند،من که جزو قشر ضعیف جامعه هستم چه،،باید فقط بیاورم در سایت شما خالی کنم و شاهد بردهای ثروتمندان باشم،این را انصاف نام نگذارید،انصاف این است گوش کن،اول همین که من در این سایت سرمایه گذاری می کنم،دوم همین که مشتری وکاربر فعال سایت شما هستم،همین که در سالن گفتگوهای سایت شرکت میکنم، انصاف این است همین که به هر تقاضای شما احترام کذاشتم،این را هم به من نگویید در عوضش شما ارز می گیرید،اگر من در عوض فعالیت در این سایت ارزی دریافت کرده باشم،همش ثبت شده آی دی من هم مشخص است ،پیگیری کنید متوجه می شوید،عزیز من ما مگر خواستیم به ما کمک کنید،خنده دار است کمک دیکر کجا بود شما به قول های که داده اید عمل کنید کمک بر سر من بخورد،تیم محترم وبزرگ قبل از میلاد آنقدر از کیف پولم در این سایت سرمایه گذاشتم که حسرت یک برد شیرین برایم مانند یک سرطان در گلویم گیر کرده،میدانم این را می خواهید،ولی عاقبت خوش در انتظار شما نیست
|
|
|
|
mehdipik
Newbie
Offline
Activity: 1
Merit: 0
|
|
June 05, 2021, 06:29:07 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
Tonu
Newbie
Offline
Activity: 1
Merit: 0
|
|
June 05, 2021, 05:30:52 PM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
Damian1989
Newbie
Offline
Activity: 1
Merit: 0
|
|
May 06, 2022, 02:06:55 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
|
ArErD
Newbie
Offline
Activity: 3
Merit: 0
|
|
October 12, 2022, 12:22:40 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
one owner
Newbie
Offline
Activity: 1
Merit: 0
|
|
November 16, 2022, 03:07:31 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
Nawteeboi
Newbie
Offline
Activity: 1
Merit: 0
|
|
February 13, 2023, 07:44:59 PM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
worldofcoins
|
|
February 17, 2023, 05:29:43 PM |
|
Thank you for sharing this piece of valuable information with us. However, many of us here might not be familiar with these code-based formulae, but it can be beneficial for the rest of the others who are well-known about it.
|
|
|
|
kramtogo21
Newbie
Offline
Activity: 1
Merit: 0
|
|
February 22, 2023, 12:37:10 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use // 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex); // 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 4. X = 99 / (1-X) X = 99 / (1 - X); // 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); }; Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 758,160. This block has not been mined yet as of this pos
|
|
|
|
Reuf
Newbie
Offline
Activity: 3
Merit: 0
|
|
September 05, 2023, 05:13:07 PM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
Shiendyhana
Newbie
Offline
Activity: 1
Merit: 0
|
|
September 15, 2023, 03:31:31 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
ngocloi93
Newbie
Offline
Activity: 3
Merit: 0
|
|
September 25, 2023, 04:15:21 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
Ayush23
Newbie
Offline
Activity: 4
Merit: 0
|
|
October 17, 2023, 08:56:34 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
Ayush23
Newbie
Offline
Activity: 4
Merit: 0
|
|
October 21, 2023, 07:13:30 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
Ayush23
Newbie
Offline
Activity: 4
Merit: 0
|
|
October 21, 2023, 01:46:36 PM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
Ayush23
Newbie
Offline
Activity: 4
Merit: 0
|
|
October 23, 2023, 03:51:43 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
ngocloi93
Newbie
Offline
Activity: 3
Merit: 0
|
|
December 06, 2023, 09:21:50 PM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
Dancer teja
Newbie
Offline
Activity: 1
Merit: 0
|
|
December 17, 2023, 05:04:47 AM |
|
Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
Monicaann0o
Newbie
Offline
Activity: 1
Merit: 0
|
|
January 12, 2024, 10:06:16 PM |
|
|
|
|
|
Agbe
|
|
January 13, 2024, 07:16:36 PM |
|
~
Have you contact the customer service because they have the best answer to give if the Manuel verification has been added to the site or not. Or you send them email to know anything you want to. Though I am not a fan of Crash Game so I can't input anything thing here. Thank you for sharing this piece of valuable information with us. However, many of us here might not be familiar with these code-based formulae, but it can be beneficial for the rest of the others who are well-known about it.
Exactly and that what I also noticed. I have heard Crash Game before but I have not played it to know the outcome. I also really appreciate the Op for bringing this here foe people to participate.
|
|
|
|
|
Cristiano Luiz de Almeida
Newbie
Offline
Activity: 5
Merit: 0
|
|
April 02, 2024, 11:56:44 PM |
|
woww thats goods, best formula Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. woww thats goods, best formula Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
Cristiano Luiz de Almeida
Newbie
Offline
Activity: 5
Merit: 0
|
|
April 03, 2024, 12:20:01 AM |
|
woww thats goods, best formula Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. woww thats goods, best formula Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. woww thats goods, best formula Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. woww thats goods, best formula Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. woww thats goods, best formula Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. woww thats goods, best formula Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash. We made the decision to update Crash using a salted hash as requested by our players in order to provide the most randomized and fair results possible after Bet # 2561902 For further details, please visit https://bcsnproject.github.io/bcgame-crash/Can I know what hash is used after the bet #2561902?
|
|
|
|
|
Cristiano Luiz de Almeida
Newbie
Offline
Activity: 5
Merit: 0
|
|
April 09, 2024, 05:39:33 AM |
|
woww thats goods, best formula Hello world, Based on community feedback, we're currently in the process of upgrading the Crash game algorithm with salting as requested. The purpose of this post is to describe the new changes within the game result algorithm in addition to publicizing our reseeding event for Crash. Below are the differences in how the game results are generated: OLD GAME RESULT FORMULA const gameResult = (seed) => { const nBits = 52; // number of most significant bits to use // 1. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16); // 2. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9)); // 3. X = 99 / (1-X) X = 99 / (1 - X); // 4. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
NEW GAME RESULT FORMULA const gameResult = (seed, salt) => { const nBits = 52; // number of most significant bits to use
// 1. HMAC_SHA256(message=seed, key=salt) const hmac = CryptoJS.HmacSHA256(CryptoJS.enc.Hex.parse(seed), salt); seed = hmac.toString(CryptoJS.enc.Hex);
// 2. r = 52 most significant bits seed = seed.slice(0, nBits / 4); const r = parseInt(seed, 16);
// 3. X = r / 2^52 let X = r / Math.pow(2, nBits); // uniformly distributed in [0; 1) X = parseFloat(X.toPrecision(9));
// 4. X = 99 / (1-X) X = 99 / (1 - X);
// 5. return max(trunc(X), 100) const result = Math.floor(X); return Math.max(1, result / 100); };
Prior to being used for calculation, each game hash is salted with the lowercase + hexadecimal string representation of the hash from pre-selected Bitcoin block 635,380. This block has not been mined yet as of this post, proving that we have not deliberately selected a mined block with a hash that could be favorable to the house. Once block 635,380 has been mined, the results will be posted to this thread as a reply. The game this post is referencing is at https://bc.game/crash.
|
|
|
|
|