Topic: Crash Game Reseeding Event @ BC.Game (Read 2117 times)

woww thats goods, best formula Shocked

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

Code:

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

Code:

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

Activity: 5

Merit: 0

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:56:44 PM

woww thats goods, best formula Shocked

Cristiano Luiz de Almeida

newbie

Activity: 5

Merit: 0

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 PM

Quote from: Ayush23 on October 21, 2023, 03:13:30 AM

woww thats goods, best formula Shocked

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 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

Code:

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

Code:

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.

Quote from: Monicaann0o on January 12, 2024, 06:06:16 PM

woww thats goods, best formula Shocked

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:56:44 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

Code:

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

Code:

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.

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 PM

Quote from: Ayush23 on October 21, 2023, 03:13:30 AM

woww thats goods, best formula Shocked

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 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

Code:

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

Code:

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.

Quote from: Monicaann0o on January 12, 2024, 06:06:16 PM

woww thats goods, best formula Shocked

Quote from: ngocloi93 on December 06, 2023, 05: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

Code:

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

Code:

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.

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:56:44 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

Code:

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

Code:

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.

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 PM

Quote from: Ayush23 on October 21, 2023, 03:13:30 AM

woww thats goods, best formula Shocked

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 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

Code:

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

Code:

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.

Quote from: Monicaann0o on January 12, 2024, 06:06:16 PM

woww thats goods, best formula Shocked

Quote from: Vyrine on February 08, 2021, 02:06:09 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

Code:

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

Code:

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.

Quote from: BC.GAME on June 19, 2020, 05: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/

Can I know what hash is used after the bet #2561902?

Cristiano Luiz de Almeida

newbie

Activity: 5

Merit: 0

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 PM

Quote from: Ayush23 on October 21, 2023, 03:13:30 AM

woww thats goods, best formula Shocked

Quote from: Cristiano Luiz de Almeida on April 02, 2024, 07:48:26 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

Code:

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

Code:

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.

Quote from: Monicaann0o on January 12, 2024, 06:06:16 PM

woww thats goods, best formula Shocked

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

Code:

  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

Code:

  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

Activity: 5

Merit: 0

Quote from: zanno on June 19, 2022, 03:34:27 AM

woww thats goods, best formula :o

Agbe

hero member

Activity: 854

Merit: 1246

~

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.

Quote from: worldofcoins on February 17, 2023, 01: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.

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.

Monicaann0o

newbie

Activity: 1

Merit: 0

Dancer teja

newbie

Activity: 1

Merit: 0

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

Code:

  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

Code:

  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

Activity: 3

Merit: 0

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

Code:

  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

Code:

  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

Activity: 4

Merit: 0

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

Code:

  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

Code:

  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

Activity: 4

Merit: 0

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

Code:

  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

Code:

  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

Activity: 4

Merit: 0

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

Code:

  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

Code:

  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

Activity: 4

Merit: 0

Quote from: ngocloi93 on September 25, 2023, 12: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

Code:

  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

Code:

  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

Quote from: ngocloi93 on September 25, 2023, 12: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

Code:

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

Code:

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.

Quote from: ngocloi93 on September 25, 2023, 12: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

Code:

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

Code:

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.

Quote from: ngocloi93 on September 25, 2023, 12: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

Code:

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

Code:

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

Code:

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

Code:

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.

ngocloi93

newbie

Activity: 3

Merit: 0

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

Code:

  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

Code:

  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

Activity: 1

Merit: 0

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

Code:

  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

Code:

  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.

Reuf

newbie

Activity: 3

Merit: 0

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

Code:

  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

Code:

  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.

kramtogo21

newbie

Activity: 1

Merit: 0

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

Code:

  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

Code:

  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

worldofcoins

sr. member

Activity: 1820

Merit: 418

Need a campaign manager? | Telegram:@worldofcoinss

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.

Nawteeboi

newbie

Activity: 1

Merit: 0

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

Code:

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

Code:

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

Activity: 1

Merit: 0