Provably Fair Gaming

Crash

No Crash, algoritmos comprovadamente justos garantem resultados justos e verificáveis. O ponto de crash é gerado usando semente do servidor, semente pública e número da rodada. Esses valores são combinados e hashados com o algoritmo SHA-256. Os primeiros 13 caracteres do hash são convertidos em um número inteiro. Para calcular o ponto de crash, 2^52 é dividido pela soma do inteiro e 1, multiplicado por (1 - 0,04) para a vantagem da casa, e arredondado para duas casas decimais. Os jogadores podem verificar independentemente o ponto de crash usando a semente pública e o número da rodada para confirmar a justiça do jogo.

const hashString = string => crypto.createHash('sha256').update(string).digest('hex');

const generateCrashTicket = (serverSeed, publicSeed, round) => {
    let combined = ${serverSeed}:${publicSeed}:${round};
    const hash = hashString(combined);
    return parseInt(hash.substring(0, 13), 16);
}
let intValue = generateCrashTicket(seed.server_seed, seed.public_seed, seed.round_number);
let crashpoint = Math.max(1, (2 ** 52 / (intValue + 1)) * (1 - 0.04)).toFixed(2);
if(crashpoint > 20000) {
    crashpoint = 20000.01;
}

Roulette

Na Roleta, algoritmos comprovadamente justos garantem resultados justos e verificáveis. Neste lobby multiplayer, o número da rodada e a semente pública são usados, com a semente do servidor e a semente pública alternando a cada 50 rodadas para manter a justiça. O jogo rola um número aleatório entre 0 e 14, determinando a cor e o prêmio correspondente com base nas apostas dos jogadores. Os resultados têm um multiplicador de 2x para vermelho (1-7) e preto (8-14), e um multiplicador de 14x para verde (0). O resultado é gerado usando a semente do servidor, a semente pública e o número da rodada, que são combinados e hashados com o algoritmo SHA-256. Os primeiros 13 caracteres do hash são convertidos em um número inteiro, e o resto da divisão do inteiro por 15 é considerado como o número do bilhete. Os jogadores podem verificar independentemente o resultado da roleta usando a semente pública e o número da rodada, confirmando a justiça do jogo.

const hashString = string => crypto.createHash('sha256').update(string).digest('hex');

const generateRouletteTicket = (serverSeed, publicSeed, round) => {
  let combined = ${serverSeed}:${publicSeed}:${round};
  const hash = hashString(combined); 
  return parseInt(hash.substring(0, 13), 16) % 15;
}
let ticketNumber = generateRouletteTicket(seed.server_seed, seed.public_seed, seed.round_number);
return ticketNumber;

Case Opening

No jogo de Abertura de Caixa, você abre uma caixa virtual para receber um item. Cada item tem uma probabilidade pré-designada de ser ganho, com a soma de todas as probabilidades sendo 100%. O jogo rola um número entre 0 e 99.999, e o intervalo no qual o número rolado cai determina o item que você recebe. O código PHP garante a equidade criando um resultado de rolagem randomizado usando sementes do servidor e do cliente e um identificador único. Esta "semente combinada" é processada através do algoritmo de hash SHA-256, e os primeiros 13 caracteres do hash resultante são convertidos em um número decimal. O resultado da rolagem é obtido tomando este número módulo 100.000. O resultado da rolagem é então comparado com o intervalo de cada item na caixa. O item correspondente ao intervalo no qual o resultado da rolagem cai é o que você ganha.

$hash_seed = hash('sha256', $server_seed . ':' . $client_seed . ':' . $nonce);
$roll_result = hexdec(substr($hash_seed, 0, 13)) % 100000;

foreach($item_details as $key => $value) {
    if($roll_result > $value['range_one'] && $roll_result < $value['range_two']) {	
        $winning_item = $value;
     }
}

Dice

No jogo de Dados, você escolhe um número e decide se vai ganhar quando o número rolado for maior ou menor que o seu número escolhido. O jogo rola um número entre 0 e 9.999 e multiplica o seu número escolhido por 100 para considerar decimais. Em seguida, o jogo compara o número multiplicado com o número rolado para determinar se você ganhou.

$hash_seed = hash('sha256', $server_seed . ':' . $client_seed . ':' . $nonce);
$roll_result_number = hexdec(substr($hash_seed, 0, 13)) % 10000;
$roll_convert = $user_roll * 100;

if($user_roll_direction) {
   if($roll_convert < $roll_result_number) {
      $roll_result = true;
   } else {
      $roll_result = false;
   } 
} else {
   if($roll_convert > $roll_result_number) {
      $roll_result = true;
   } else {
      $roll_result = false;
   }
}

Plinko

No jogo de Plinko, uma bola cai por um campo de pinos, movendo-se para a esquerda ou para a direita ao atingir cada pino. A direção de cada movimento é determinada aleatoriamente, com 0 indicando esquerda e 1 indicando direita. A posição final da bola (ou balde), determinada pela soma de todos os movimentos, corresponde a um prêmio ou multiplicador específico.

$plinko_index = array();
$combined_seed = hash('sha256',  $server_seed_value . ':' . $client_seed_value . ':' . $nonce_value);

for ($x=0; $x < 64; $x = $x+4) { 
   array_push($plinko_index, $combined_seed[$x] > '7' ? 1:0); 
} 
$plinko_index = array_splice($plinko_index, 0, $row_count);
$plinko_map = getPlinkoMap($risk_type, $row_count);
$multipliers = $plinko_map['multipliers'];
$plinko_ticket = array_sum($plinko_index);
$bucket = $multipliers[$plinko_ticket];

Este bloco primeiro gera uma semente combinada usando a semente do servidor, semente do cliente e nonce. Esta semente é hashada usando o algoritmo SHA-256. Em seguida, para cada 4 caracteres na semente hashada, o código verifica se o caractere é maior que '7'. Se for, ele adiciona '1' no array $plinko_index; caso contrário, adiciona '0'. Este array, após ser dividido para a contagem de linhas necessária, representa o caminho da bola. A função $plinko_map recupera o tipo de risco e a contagem de linhas, e $multipliers contém os multiplicadores para cada balde. O balde final é determinado somando os valores no array $plinko_index (ou seja, o caminho da bola) e usando essa soma como um índice para selecionar o multiplicador correspondente do array $multipliers.