Pusat Bantuan

Game

Acara permainan adalah terjemahan dari float yang dihasilkan secara acak ke dalam hasil yang terkait yang spesifik untuk permainan. Ini mencakup apa saja mulai dari hasil lemparan dadu hingga urutan kartu dalam dek, atau bahkan lokasi setiap bom dalam permainan tambang.

Di bawah ini adalah penjelasan rinci tentang bagaimana kami menerjemahkan float menjadi acara untuk setiap permainan khusus di platform kami.

Hilo

Dalam dek kartu standar, ada 52 kemungkinan hasil unik. Ketika bermain Blackjack, Hilo, dan Baccarat di platform kami, kami menggunakan jumlah dek yang tidak terbatas saat menghasilkan acara permainan, dan oleh karena itu setiap giliran kartu selalu memiliki probabilitas yang sama. Untuk menghitung ini, kami mengalikan setiap float yang dihasilkan secara acak dengan 52, dan kemudian menerjemahkan hasil itu menjadi kartu tertentu, berdasarkan indeks berikut:

// Index of 0 to 51 : ♦2 to ♣A
const CARDS = [ 
♦2, ♥2, ♠2, ♣2, ♦3, ♥3, ♠3, ♣3, ♦4, ♥4,  
♠4, ♣4, ♦5, ♥5, ♠5, ♣5, ♦6, ♥6, ♠6, ♣6, 
♦7, ♥7, ♠7, ♣7, ♦8, ♥8, ♠8, ♣8, ♦9, ♥9, 
♠9, ♣9, ♦10, ♥10, ♠10, ♣10, ♦J, ♥J, ♠J, 
♣J, ♦Q, ♥Q, ♠Q, ♣Q, ♦K, ♥K, ♠K, ♣K, ♦A, 
♥A, ♠A, ♣A 
]; 

// Game event translation
const card = CARDS[Math.floor(float * 52)];

Satu-satunya faktor pembeda yang terlibat dalam permainan ini adalah bahwa dalam Hilo dan Blackjack ada kursor 13 untuk menghasilkan 52 kemungkinan acara permainan untuk kasus di mana sejumlah besar kartu harus dibagikan kepada pemain, sementara dalam Baccarat, kami hanya perlu menghasilkan 6 acara permainan untuk menutupi sebanyak mungkin kartu yang dapat dimainkan.

Berlian

Saat bermain Diamonds, ada 7 kemungkinan hasil dalam bentuk permata. Untuk mencapai ini, kami mengalikan setiap float yang dihasilkan dengan 7 sebelum diterjemahkan menjadi permata yang sesuai menggunakan indeks berikut:

// Index of 0 to 51 : ♦2 to ♣A
const CARDS = [ 
♦2, ♥2, ♠2, ♣2, ♦3, ♥3, ♠3, ♣3, ♦4, ♥4,  
♠4, ♣4, ♦5, ♥5, ♠5, ♣5, ♦6, ♥6, ♠6, ♣6, 
♦7, ♥7, ♠7, ♣7, ♦8, ♥8, ♠8, ♣8, ♦9, ♥9, 
♠9, ♣9, ♦10, ♥10, ♠10, ♣10, ♦J, ♥J, ♠J, 
♣J, ♦Q, ♥Q, ♠Q, ♣Q, ♦K, ♥K, ♠K, ♣K, ♦A, 
♥A, ♠A, ♣A 
]; 

// Game event translation
const card = CARDS[Math.floor(float * 52)];

Dadu

Dalam versi dadu kami, kami mencakup rentang gulungan yang mungkin dari 00.00 hingga 100.00, yang memiliki rentang 10.001 kemungkinan hasil. Terjemahan acara permainan dilakukan dengan mengalikan float dengan jumlah kemungkinan hasil dan kemudian membagi dengan 100 agar angka yang dihasilkan sesuai dengan batasan rentang dadu yang telah kami nyatakan.

// Game event translation
const roll = (float * 10001) / 100;

Lempar Koin

Saat bermain Coinflip, ada 2 kemungkinan hasil dalam bentuk koin. Untuk mencapai ini, kami mengalikan setiap float yang dihasilkan dengan 2 sebelum diterjemahkan menjadi permata yang sesuai menggunakan indeks berikut:

// Index of 0 & 1 : batman & joker
const COINS = [ 0, 1 ];

// Game event translation
const coin = COINS[Math.floor(float * 2)];

Limbo

Ketika datang ke Limbo, kami menggunakan proses dua langkah. Pertama, kami mengambil float dan mengalikannya dengan baik pengganda maksimum yang mungkin dan tepi rumah. Kemudian, untuk menghasilkan acara permainan yang memiliki Distribusi Probabilitas Kami membagi pengganda maksimum yang mungkin dengan hasil langkah pertama untuk membuat acara permainan dalam bentuk titik crash.

// Game event translation with houseEdge of 0.99 (1%)
const floatPoint = 1e8 / (float * 1e8) * houseEdge;

// Crash point rounded down to required denominator
const crashPoint = Math.floor(floatPoint * 100) / 100;

// Consolidate all crash points below 1
const result = Math.max(crashPoint, 1);

Plinko

Untuk setiap permainan Plinko, hasil yang dihasilkan didasarkan pada jalur bola yang jatuh. Acara permainan menentukan arah bola yang jatuh untuk setiap level dalam proses jatuh. Pemain dapat memilih antara 8 dan 16 pin permainan, yang menentukan jumlah acara permainan yang diperlukan untuk menghasilkan jalur lengkap dari atas ke bawah. Karena hanya ada dua arah yang mungkin (kiri atau kanan), terjemahan dilakukan dengan mengalikan setiap float dengan 2, yang dipetakan ke indeks berikut:

// Index of 0 to 1 : left to right
const DIRECTIONS = [ left, right ];

// Game event translation
const direction = CARDS[Math.floor(float * 2)];

Keno

Permainan Keno tradisional mengharuskan pemilihan 10 acara permainan yang mungkin dalam bentuk serangan di papan.

// Index of 0 to 39 : 1 to 40
const SQUARES = [ 
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
    11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
    21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
    31, 32, 33, 34, 35, 36, 37, 38, 39, 40
];

const hit = SQUARES[Math.floor(float * 40)];

Implementasi pengocokan Fisher-Yates digunakan untuk mencegah kemungkinan hasil yang duplikat dihasilkan.

Tambang

Sebuah permainan tambang dihasilkan dengan 24 peristiwa permainan terpisah, dalam bentuk tambang di papan. Setiap float dikalikan dengan jumlah ubin unik yang mungkin masih tersisa di papan. Ini dilakukan dengan mengurangi jumlah ubin yang tersisa sebanyak 1 untuk setiap iterasi hasil peristiwa permainan yang dihasilkan menggunakan float yang sesuai yang disediakan. Lokasi tambang dipetakan menggunakan posisi grid dari kiri ke kanan, atas ke bawah.

Implementasi pengocokan Fisher-Yates digunakan untuk mencegah kemungkinan hasil yang duplikat dihasilkan. Antara 1 dan 24 hasil acara permainan digunakan, berdasarkan pengaturan yang dipilih.

Roda

Nomor acara permainan dihitung dengan mengalikan float dengan kemungkinan hasil di segmen tersebut. Kemudian digunakan untuk menentukan hasil acara permainan sebagai pengali, menggunakan indeks berikut:

// Index per payout configuration
const PAYOUTS = {
'10': {
    low: [ 1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0 ],
    medium: [ 0, 1.9, 0, 1.5, 0, 2, 0, 1.5, 0, 3 ],
    high: [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 9.9 ]
},
'20': {
    low: [
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0
    ],
    medium: [ 
        1.5, 0, 2, 0, 2, 0, 2, 0, 1.5, 0, 
        3, 0, 1.8, 0, 2, 0, 2, 0, 2, 0 
    ],
    high: [ 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 19.8 
    ]
},
'30': {
    low: [ 
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0, 
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0
    ],
    medium: [
        1.5, 0, 1.5, 0, 2, 0, 1.5, 0, 2, 0, 
        2, 0, 1.5, 0, 3, 0, 1.5, 0, 2, 0,
        2, 0, 1.7, 0, 4, 0, 1.5, 0, 2, 0
    ],
    high: [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 29.7
    ]
},
'40': {
    low: [
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0,
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0,
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0,
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0
    ],
    medium: [
        2, 0, 3, 0, 2, 0, 1.5, 0, 3, 0,
        1.5, 0, 1.5, 0, 2, 0, 1.5, 0, 3, 0,
        1.5, 0, 2, 0, 2, 0, 1.6, 0, 2, 0,
        1.5, 0, 3, 0, 1.5, 0, 2, 0, 1.5, 0
    ],
    high: [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 39.6
    ]
},
'50': {
    low: [
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0,
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0,
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0,
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0,
        1.5, 1.2, 1.2, 1.2, 0, 1.2, 1.2, 1.2, 1.2, 0
    ],
    medium: [
        2, 0, 1.5, 0, 2, 0, 1.5, 0, 3, 0,
        1.5, 0, 1.5, 0, 2, 0, 1.5, 0, 3, 0,
        1.5, 0, 2, 0, 1.5, 0, 2, 0, 2, 0,
        1.5, 0, 3, 0, 1.5, 0, 2, 0, 1.5, 0,
        1.5, 0, 5, 0, 1.5, 0, 2, 0, 1.5, 0
    ],
    high: [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 49.5
    ]
}
};

// Game event translation
const spin = PAYOUTS[segments][risk][float * segments];

Hancur

Adapun untuk membuktikan keadilan kami, kami telah menghasilkan rangkaian 10.000.000 hash SHA256 di mana setiap hash adalah hash dari representasi heksadesimal dari hash sebelumnya. Hash terakhir dalam rangkaian ini adalah: 78a9757d3be42b74a3f70239078ad9317125fe9ee630d5bdada46de963e56752

Rumus untuk menghasilkan hasil permainan:

const gameHash = hashChain.pop()

const hmac = createHmac('sha256', gameHash);

// blockHash is the hash of bitcoin block 584,500

hmac.update(blockHash);

const hex = hmac.digest('hex').substr(0, 8);
const int = parseInt(hex, 16);

// 0.01 will result in 1% house edge with a lowest crashpoint of 1

const crashpoint = Math.max(1, (2 ** 32 / (int + 1)) * (1 - 0.01))

Ganda

Double kami berasal dari versi Eropa dari permainan di mana roda terdiri dari 15 kantong yang berbeda, berkisar dari 0 hingga 14. Peristiwa permainan dihitung dengan mengalikan float dengan 15 dan kemudian diterjemahkan menjadi kantong yang sesuai menggunakan indeks berikut:

// Index of 0 to 14
const POCKETS = [ 
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 
    10, 11, 12, 13, 14
];

// Game event translation
const pocket = POCKETS[Math.floor(float * 15)];

Menara

Permainan Menara dihasilkan dengan 9 acara permainan terpisah, dalam bentuk level menara. Kami menghasilkan sejumlah telur tergantung pada kesulitan untuk setiap level, dan memiliki rentang ubin tempat telur dapat berada yang juga diwakili oleh bilangan bulat.

Setiap float yang dihasilkan kemudian diubah menjadi bilangan bulat untuk menentukan lokasi telur di setiap baris. Misalnya: Tingkat kesulitan mudah akan direpresentasikan seperti ini: [0, 1, 3] - telur akan ada di ubin 1, 2, dan 4.

// count represents the number of eggs
// size represents the number of possible squares

const LEVEL_MAP = {
easy: { count: 3, size: 4 },
medium: { count: 2, size: 3 },
hard: { count: 1, size: 2 },
expert: { count1, size: 3 },
master: { count: 1, size: 4 },}

Fisher-Yates shuffle diimplementasikan untuk mencegah telur duplikat dalam satu baris.