Spielereignisse sind die Übersetzung der zufällig erzeugten Gleitkommazahlen in ein nachvollziehbares, spielspezifisches Ergebnis. Dazu gehört alles vom Ergebnis eines Würfelwurfs über die Reihenfolge der Karten in einem Deck bis hin zur Position jeder einzelnen Bombe in einem Mines-Spiel.

Im Folgenden wird ausführlich erläutert, wie wir für jedes einzelne Spiel auf unserer Plattform Quoten in Ereignisse umwandeln.

Blackjack, Hilo &

In einem Standardkartenspiel gibt es 52 mögliche, unterschiedliche Ergebnisse. Beim Spielen von Blackjack, Hilo & Baccarat auf unserer Plattform verwenden wir eine unbegrenzte Anzahl von Kartendecks zur Erzeugung des Spielevents, sodass jede gezogene Karte stets die gleiche Wahrscheinlichkeit hat. Um dies zu berechnen, multiplizieren wir jede zufällig erzeugte Gleitkommazahl mit 52 und übersetzen das Ergebnis anschließend anhand des folgenden Index in eine bestimmte Karte:

// Index von 0 bis 51 : ♦2 bis ♣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
];

// Übersetzung von Spielereignissen
const card = CARDS[Math.floor(float * 52)];

Der einzige unterscheidende Faktor bei diesen Spielen besteht darin, dass bei Hilo und Blackjack ein Cursor von 13 verwendet wird, um 52 mögliche Spielereignisse zu erzeugen, für Fälle, in denen eine große Anzahl von Karten an den Spieler ausgeteilt werden muss, wohingegen wir bei Baccarat nur 6 Spielereignisse erzeugen müssen, um die größtmögliche Anzahl spielbarer Karten abzudecken.

Bars

In einem Bars-Spiel werden 30 zufällige Gleitkommazahlen zwischen 0,0 und 1,0 erzeugt und als Wahrscheinlichkeiten verwendet, um die Gewinnleiste aus einer vordefinierten Auszahlungs­tabelle auszuwählen. Diese Auszahlungs­tabelle befindet sich im Footer des Bars-Spiels und auf der Seite zur Berechnung der überprüfbaren Fairness.

Fälle

Bei einer Cases-Wette wird eine einzelne Zufallszahl (Float) zwischen 0,0 und 1,0 erzeugt, die als Wahrscheinlichkeit verwendet wird, um den gewinnenden Case aus einer vordefinierten Auszahlungs­tabelle auszuwählen. Diese Auszahlungs­tabelle befindet sich im Footer des Cases-Spiels und auf der Seite zur Überprüfung der nachweislichen Fairness.

Pakete

Bei einer Packs-Wette werden fünf zufällige Gleitkommazahlen zwischen 0,0 und 1,0 erzeugt, jeweils eine für jede Karte im Pack. Jede dieser Zahlen wird als Wahrscheinlichkeit verwendet, um eine Karte aus einer vordefinierten Auszahlungstabelle auszuwählen, die 240 einzigartige Karten mit unterschiedlichen Multiplikatoren und Seltenheitsstufen enthält. Diese Auszahlungstabelle befindet sich im Footer des Packs-Spiels und auf der Seite zur Überprüfung der nachweislichen Fairness.

Jeder der 5 Gleitkommawerte wird unabhängig anhand kumulativer Wahrscheinlichkeitsbereiche einer Karte zugeordnet. Dadurch besteht die Möglichkeit, innerhalb einer einzigen Pack-Öffnung doppelte Karten mit derselben Seltenheit oder demselben Multiplikator zu erhalten.

Dart

Bei einer Darts-Wette werden zwei zufällige Gleitkommazahlen zwischen 0,0 und 1,0 erzeugt, die als Entfernung und Rotation verwendet werden, um den Dart auf der Scheibe zu positionieren. Der Rotationswert wird so dargestellt, dass 0,0 der obere Punkt der Dartscheibe ist, 0,5 der untere Punkt und 1,0 wieder oben ansetzt. Der Entfernungswert wird mit sqrt(float) / 2 normalisiert und gibt die Entfernung vom Mittelpunkt im Bereich von 0,0 bis 0,5 an, wobei 0,0 der Mittelpunkt und 0,5 der Rand der Scheibe ist.

Flip

Ein Flip-Spiel erzeugt 20 einzelne Spielereignisse, von denen jedes das Ergebnis eines Münzwurfs darstellt. Für jeden Münzwurf gilt: Ist der Wert der Fließkommazahl kleiner oder gleich 0,5, lautet das Ergebnis „Zahl“, andernfalls „Kopf“.

Schlangen

Bei einer Snakes-Wette werden 10 Würfelwürfe mit ganzzahligen Werten zwischen 1 und 6 erzeugt. Die Werte werden für jede Runde addiert, sodass sich insgesamt 5 Paare von Würfen mit sechsseitigen Würfeln pro Runde ergeben.

Diamanten

Beim Spielen von Diamonds gibt es 7 mögliche Ergebnisse in Form von Edelsteinen. Um dies zu erreichen, multiplizieren wir jede erzeugte Gleitkommazahl mit 7, bevor sie mithilfe des folgenden Index in einen entsprechenden Edelstein umgewandelt wird:

// Index von 0 bis 6: Grün bis Blau
const GEMS = [ green, purple, yellow, red, cyan, pink, blue ];

// Übersetzung von Spielereignissen
const gem = GEMS[Math.floor(float * 7)];

Dem Spieler werden dann 5 Edelsteine ausgeteilt.

Würfelwurf

In unserer Version von Würfeln decken wir eine mögliche Spannweite von 00,00 bis 100,00 ab, was einem Bereich von 10.001 möglichen Ergebnissen entspricht. Die Übersetzung des Spielergebnisses erfolgt, indem die Fließkommazahl mit der Anzahl der möglichen Ergebnisse multipliziert und anschließend durch 100 geteilt wird, sodass die resultierende Zahl in den Rahmen unseres angegebenen Würfelbereichs passt.

// Spielereignis-Übersetzung
const roll = (float * 10001) / 100;

Primedice

Primedice verwendet denselben Würfelmechanismus wie das normale Dice-Spiel und deckt einen möglichen Wurfbereich von 00,00 bis 100,00 ab, was einer Spanne von 10.001 möglichen Ergebnissen entspricht. Die Umrechnung des Spielergebnisses erfolgt, indem die Fließkommazahl mit der Anzahl der möglichen Ergebnisse multipliziert und anschließend durch 100 geteilt wird, sodass die resultierende Zahl in den festgelegten Würfelbereich passt. Der Unterschied bei Primedice besteht darin, dass komplexere Wettbedingungen möglich sind, darunter Würfe zwischen zwei Zahlen, Würfe außerhalb eines Bereichs oder Würfe zwischen zwei Zahlenpaaren.

// Spielereignis-Übersetzung
const roll = (float * 10001) / 100;

Limbus

Wenn es um Limbo geht, verwenden wir einen zweistufigen Prozess. Zuerst nehmen wir die Zufallszahl (Float) und multiplizieren sie sowohl mit dem maximal möglichen Multiplikator als auch mit dem Hausvorteil. Dann, um ein Spielergebnis mit einer zu erzeugen, teilen wir den maximal möglichen Multiplikator durch das Ergebnis des ersten Schritts und erhalten so das Spielergebnis in Form eines Crash-Punkts.

// Spielereignis-Berechnung mit houseEdge von 0,99 (1%)
const floatPoint = 1e8 / (float * 1e8) * houseEdge;

// Crash-Punkt auf den erforderlichen Nenner abgerundet
const crashPoint = Math.floor(floatPoint * 100) / 100;

// Alle Crash-Punkte unter 1 zusammenfassen
const result = Math.max(crashPoint, 1);

Plinko

Bei jedem Plinko-Spiel basiert das erzeugte Ergebnis auf dem Weg der fallenden Kugel. Das Spielereignis bestimmt für jede Ebene im Fallprozess die Richtung der Kugel. Die Spieler können zwischen 8 und 16 Pins wählen, was die Anzahl der Spielereignisse festlegt, die benötigt werden, um einen vollständigen Weg von oben nach unten zu erzeugen. Da es nur zwei mögliche Richtungen gibt (links oder rechts), erfolgt die Umrechnung, indem jede Fließkommazahl mit 2 multipliziert wird, was dem folgenden Index entspricht:

// Index von 0 bis 1 : von links nach rechts
const DIRECTIONS = [ left, right ];

// Übersetzung des Spielereignisses
const direction = CARDS[Math.floor(float * 2)];

Roulette-Rolle

Unser Roulette basiert auf der europäischen Version des Spiels, bei der das Rad aus 37 verschiedenen möglichen Fächern besteht, von 0 bis 36. Das Spielergebnis wird berechnet, indem der Float-Wert mit 37 multipliziert und anschließend mithilfe des folgenden Indexes in das entsprechende Fach übersetzt wird:

// Index von 0 bis 36
const POCKETS = [
0, 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
];

// Übersetzung des Spielereignisses
const pocket = POCKETS[Math.floor(float * 37)];

Keno

Traditionelle Keno-Spiele erfordern die Auswahl von 10 möglichen Spielereignissen in Form von Treffern auf einem Spielfeld. Um dies zu erreichen, multiplizieren wir jede Gleitkommazahl mit der Anzahl der möglichen eindeutigen Felder, die existieren. Sobald ein Treffer gesetzt wurde, kann er nicht noch einmal gewählt werden, was die Größe des Pools möglicher Ergebnisse verändert. Dies geschieht, indem bei jeder Iteration eines erzeugten Spielergebnis-Ereignisses die Anzahl der maximal möglichen Ergebnisse um 1 verringert wird, basierend auf der entsprechenden bereitgestellten Gleitkommazahl und unter Verwendung des folgenden Index:

// Index von 0 bis 39 : 1 bis 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)];

Die Fisher-Yates-Sortiermethode wird verwendet, um zu verhindern, dass doppelte mögliche Treffer erzeugt werden.

Minen

Ein Minenspiel wird mit 24 einzelnen Spielereignissen erzeugt, dargestellt als Minen auf dem Spielfeld. Jede Gleitkommazahl wird mit der Anzahl der noch verbleibenden möglichen einzigartigen Felder auf dem Spielfeld multipliziert. Dies geschieht, indem bei jeder Iteration eines erzeugten Spielereignisses die Anzahl der verbleibenden Felder um 1 verringert wird, basierend auf der jeweils verwendeten Gleitkommazahl. Die Position der Mine wird anhand einer Gitterposition von links nach rechts und von oben nach unten bestimmt.

Die Fisher-Yates-Sortierung wird verwendet, um zu verhindern, dass doppelte mögliche Treffer erzeugt werden. Je nach gewählten Einstellungen werden zwischen 1 und 24 Spielergebnis-Ereignisse verwendet.

Pumpe

Ein Pump-Spiel wird mit 24 einzelnen Spielereignissen erzeugt, in Form von Platzern in jeder Runde. Jeder Float-Wert wird mit der Anzahl der verbleibenden Runden multipliziert. Dies geschieht, indem für jeden Pump die Anzahl der verbleibenden Runden um 1 verringert wird.

Die Fisher-Yates-Sortierung wird verwendet, um zu verhindern, dass doppelte mögliche Treffer erzeugt werden. Je nach gewählten Einstellungen werden zwischen 1 und 24 Spielergebnis-Ereignisse verwendet.

Hähnchen

Ein Chicken-Spiel wird mit 20 einzelnen Spielereignissen erzeugt, in Form von Toden in jeder Runde. Jede Gleitkommazahl wird mit der Anzahl der verbleibenden Runden multipliziert. Dies geschieht, indem bei jedem Schritt die Anzahl der verbleibenden Runden um 1 verringert wird.

Die Fisher-Yates-Sortierung wird verwendet, um zu verhindern, dass doppelte mögliche Treffer erzeugt werden. Je nach gewählten Einstellungen werden zwischen 1 und 20 Spielergebnis-Ereignisse verwendet.

Schere, Stein, Papier

Schere-Stein-Papier-Runden werden einzeln für eine unbegrenzte Anzahl von Runden generiert, mit Ausnahme des Autobet-Modus, der auf maximal 20 Runden begrenzt ist. Für jede Runde wird eine Zahl zwischen 0 und 2 erzeugt und jeweils Stein (0), Papier (1) oder Schere (2) zugewiesen.

Video Poker

Ein Video-Poker-Spiel umfasst 52 einzelne Spielereignisse in Form von Karten in einem Kartendeck. Jede Gleitkommazahl wird mit der Anzahl der noch im Deck verbleibenden möglichen Karten multipliziert. Dies geschieht, indem bei jeder Iteration eines mit der entsprechenden Gleitkommazahl erzeugten Spielergebnis-Ereignisses die Anzahl der verbleibenden Karten um 1 verringert wird. Anschließend wird eine Karte aus dem folgenden Index ausgewählt:

// Index von 0 bis 51 : ♦2 bis ♣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
];

// Übersetzung des Spielereignisses
const card = CARDS[Math.floor(float * 52)];

Die Fisher-Yates-Shuffle-Implementierung wird verwendet, um zu verhindern, dass doppelte Karten erzeugt werden.

Rad

Die Spielereignisnummer wird berechnet, indem die Gleitkommazahl mit den möglichen Ergebnissen im Segment multipliziert wird. Anschließend wird sie verwendet, um das Ergebnis des Spielereignisses als Multiplikator zu bestimmen, anhand des folgenden Index:

// 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 translationconst spin = PAYOUTS[segments][risk][float * segments];

Absturz

Siehe den , um mehr darüber zu erfahren, wie wir das auf Salt-Hash basierende, nachweislich faire Modell für dieses spezielle Spiel einsetzen.

Folie

Siehe den , um mehr darüber zu erfahren, wie wir das auf Salt-Hash basierende, nachweislich faire Modell für dieses spezielle Spiel einsetzen.

Skarabäus-Spin / Buch des Lebens

Die Spielereignisnummer wird berechnet, indem die Gleitkommazahl mit den möglichen Symbolpositionen auf der Walze multipliziert wird. Die ersten 4 Walzen haben jeweils 30 mögliche Positionen, während die letzte Walze 41 hat. Das Spielereignis bestimmt die zentrale Stopp-Position für jede Walze. Dieses Spiel besteht aus 5 Spielereignisnummern, außer im Fall einer Bonusrunde, in der weitere erzeugt werden.

Blaue Samurai

Blue Samurai Slots bietet 3 verschiedene Arten von Spins: reguläre, Bonus- und Spezial-Spins.

Für reguläre und Bonus-Spins werden aus deinem Hash 18 Gleitkommazahlen zwischen 0 und 1 erzeugt. Anders als bei den Scarab-Spin-Slots, die feste Walzen haben, verfügen die Samurai-Slots über dynamische Walzen. Das bedeutet, dass jedes Symbol aus der entsprechenden Gleitkommazahl generiert wird, die ihm zugewiesen wurde.

Wir verwenden gewichtete Zufallsstichproben, um jede Zahl ihrem entsprechenden Feld zuzuweisen, in derselben Reihenfolge, von oben nach unten auf den Walzen und von links nach rechts. Jedes Symbol hat seine eigene feste Wahrscheinlichkeit/Chance, in einem beliebigen Feld zu erscheinen, wobei die äußeren 2 Walzen einen anderen Satz von Wahrscheinlichkeiten haben als die inneren 3 Walzen. Für weitere Informationen dazu, wie Symbole ausgewählt werden, siehe , um mehr zu erfahren.

Spezial-Spins funktionieren ein wenig anders. Zunächst werden nur 12 Floats aus deinem Hash entnommen, da die äußeren Walzen deaktiviert sind. Zwischen den einzelnen Spezial-Spins bleiben alle Samurai-Symbole für den Rest des Spiels an ihrer Position, und die Auszahlung richtet sich nach der endgültigen Anzahl der Samurais. Das bedeutet, dass wir zum Beispiel, wenn im ersten Spin 1 Samurai kleben bleibt, technisch gesehen nur noch 11 Floats für den nächsten Spin benötigen würden. Der Einfachheit halber erzeugen wir im Provably-Fair-Modell jedoch jedes Mal 12 Floats, und wenn das für ein Feld vorgesehene Float auf eine Position trifft, auf der bereits ein Samurai aus einem vorherigen Spin feststeckt, wird dieses Float einfach nicht verwendet.

Drachenturm

Ein Dragon-Tower-Spiel wird mit 9 einzelnen Spielereignissen erzeugt, die den Ebenen des Turms entsprechen. Für jede Ebene generieren wir je nach Schwierigkeitsgrad eine bestimmte Anzahl von Eiern und definieren einen Bereich von Feldern, auf denen sich ein Ei befinden kann, der ebenfalls durch eine ganze Zahl dargestellt wird.

Jede erzeugte Gleitkommazahl wird anschließend in ganze Zahlen umgewandelt, um die Position des Eis in jeder Reihe zu bestimmen. Zum Beispiel: Ein Level mit dem Schwierigkeitsgrad „einfach“ würde so dargestellt: [0, 1, 3] – Eier wären dann auf Kachel 1, 2 und 4 vorhanden.

// count steht für die Anzahl der Eier
// size steht für die Anzahl der möglichen Felder

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 },
}

Die Fisher-Yates-Shuffle-Implementierung wird verwendet, um doppelte Eier in einer Reihe zu verhindern.