Ich habe es derzeit mit einem Mehrspieler-Kampfsystem zu tun, bei dem der von den Spielern verursachte Schaden immer mit einem Zufallsfaktor zwischen 0,8 und 1,2 multipliziert wird.

Theoretisch kann ein wirklich zufälliger RNG am Ende viele Male dieselbe Zahl ergeben (siehe das Tetris-Dilemma ). Dies könnte zu einem Match führen, in dem der Spieler immer sehr hohen Schaden verursacht, während der andere immer sehr geringen Schaden verursacht.

Was kann ich tun, um sicherzustellen, dass dies nicht passiert? Können manche RNGs Wiederholungen besser vermeiden als andere?

Sie können es auf die gleiche Weise wie Tetris lösen, indem Sie eine voreingestellte Liste der Schadensergebnisse und des Mischens erstellen.

Angenommen, Sie wissen, dass der Spieler mit einer linearen Verteilung 0,8x bis 1,2x Schaden verursachen wird. Nehmen Sie die Liste [0.8, 0.9, 1.0, 1.1, 1.2]. Mische es zufällig , so dass du zB [1.2, 1.0, 0.8, 0.9, 1.1] erhältst.

Wenn der Spieler zum ersten Mal Schaden verursacht, verursacht er 1,2x Schaden. Dann 1x. Dann usw auf 1.1x.Nur wenn das Array leer ist, sollten Sie ein neues Array generieren und mischen.

In der Praxis möchten Sie dies wahrscheinlich mit 4+ Arrays gleichzeitig tun (z. B. beginnen Sie mit [0.8,0.8,0.8,0.8,0.9,0.9.9,0.9, ...]). Andernfalls ist der Zeitraum der Sequenz so kurz, dass die Spieler herausfinden können, ob ihr nächster Treffer "gut" ist oder nicht. (Auch wenn dies dem Kampf mehr Strategie verleihen kann, wie in der Hoimi-Tabelle von Dragon Quest IX, in der anhand von Heilungszahlen und Optimierungen herausgefunden wurde, wie man prüft , bis ein seltener Fall garantiert ist.)

Ich habe tatsächlich welche geschrieben Code geschrieben . Der Kern davon ist die Verwendung von Statistiken, um Pechsträhnen zu korrigieren. Sie können dies tun, indem Sie nachverfolgen, wie oft das Ereignis aufgetreten ist, und die vom PRNG generierte Zahl anhand dieser Werte beeinflussen.

Erstens, wie behalten wir den Prozentsatz der Ereignisse im Auge? Die naive Art, dies zu tun, wäre, alle jemals generierten Zahlen im Speicher zu halten und sie zu mitteln: Das würde funktionieren, ist aber schrecklich ineffizient. Nachdem ich ein wenig nachgedacht hatte, kam ich auf Folgendes (das ist im Grunde genommen a kumulativer gleitender Durchschnitt ist ).

Nehmen Sie die folgenden PRNG-Proben (wo wir verarbeiten, wenn die Probe> = 0,5 ist):

Values: 0.1, 0.5, 0.9, 0.4, 0.8
Events: 0  , 1  , 1  , 0  , 1
Percentage: 60%

Beachten Sie, dass jeder Wert zu 1/5 des Endergebnisses beiträgt. Schauen wir es uns anders an:

Values: 0.1, 0.5
Events: 0  , 1

Beachten Sie, dass das 0zu 50% des Wertes beiträgt und das1 beiträgt. Etwas weiter genommen:

Values: [0.1, 0.5], 0.9
Events: [0  , 1  ], 1

Jetzt tragen die ersten Werte 66% und die letzten 33% zum Wert bei. Wir können dies im Grunde auf den folgenden Prozess zurückführen:

result = // 0 or 1 depending on the result of the event that was just generated
new_samples = samples + 1

average = (average * samples / new_samples) + (result * 1 / new_samples)
// Essentially:
average = (average * samples / new_samples) + (result / new_samples)

// You might want to limit this to, say, 100.
// Leaving it to carry on increasing can lead to unfairness
// if the game draws on forever.
samples = new_samples

Jetzt müssen wir das Ergebnis des vom PRNG abgetasteten Werts verzerren, da wir hier eine prozentuale Chance haben, dass die Dinge viel einfacher sind (im Vergleich zu beispielsweise zufälligen Schadensbeträgen in einem RTS). Das wird schwer zu erklären sein, weil es mir gerade eingefallen ist. Wenn der Durchschnitt niedriger ist, bedeutet dies, dass wir die Wahrscheinlichkeit des Eintretens des Ereignisses erhöhen müssen und umgekehrt. Also einige Beispiele

average = 0.1
desired = 0.5
corrected_chance = 83%

average = 0.2
desired = 0.5
corrected_chance = 71%

average = 0.5
desired = 0.5
corrected_change = 50%

Was mir jetzt einfiel, war, dass im ersten Beispiel 83% nur "0,5 von 0,6" waren (mit anderen Worten "0,5 von 0,5 plus 0,1"). In zufälligen Ereignissen bedeutet dies entweder:

procced = (sample * 0.6) > 0.1
// or
procced = (sample * 0.6) <= 0.5

Um also ein Ereignis zu generieren, würden Sie grundsätzlich den folgenden Code verwenden:

total = average + desired
sample = rng_sample() * total // where the RNG provides a value between 0 and 1
procced = sample <= desired

Und deshalb bekommst du den Code, den ich in den Kern geschrieben habe. Ich bin mir ziemlich sicher, dass dies alles in dem zufälligen Schadensfall-Szenario verwendet werden kann, aber ich habe mir nicht die Zeit genommen, dies herauszufinden.

Haftungsausschluss: Dies ist alles einheimische Statistik, ich habe keine Ausbildung in diesem Bereich. Meine Unit-Tests bestehen allerdings.

Was Sie fordern, ist eigentlich das Gegenteil der meisten PRNGs, eine nichtlineare Verteilung. Setzen Sie einfach eine Art von abnehmender Ertragslogik in Ihre Regeln ein. Angenommen, alles über 1.0x ist ein "kritischer Treffer". Sagen Sie einfach, dass Ihre Chancen, einen kritischen Treffer zu erzielen, in jeder Runde um X steigen, bis Sie einen erreichen Welchen Punkt sie auf Y zurücksetzen

Sid Meier hielt auf der GDC 2010 eine hervorragende Rede zu diesem Thema und zu Civilization Games. Ich werde versuchen, den Link später zu finden und einzufügen. Im Wesentlichen - wahrgenommene Zufälligkeit ist nicht dasselbe wie wahre Zufälligkeit. Damit sich die Dinge fair anfühlen, müssen Sie frühere Ergebnisse analysieren und die Psychologie der Spieler berücksichtigen.

Vermeiden Sie Pechsträhnen um jeden Preis (wenn die vorherigen beiden Runden Pech hatten, sollte die nächste garantiert Glück haben). Der Spieler sollte immer mehr Glück haben als ein KI-Gegner.

Verwenden Sie eine Verschiebungsvorspannung

Der Basisgenerator verwendet eine gleichmäßige Verteilung zwischen $0$ und $1$ generieren $r$. Stellen Sie zunächst einen Bias-Wert ein.$b$zu $0$.

Die Gesamtverteilung wird durch die folgende Formel verzerrt:

$r^{\exp (-b)}$

Der Effekt hier ist der wenn $b$ positiv ist, wird die resultierende Zahl in Richtung voreingenommen $1$. Wann$b$ negativ ist, wird die resultierende Zahl in Richtung voreingenommen $0$.

Nehmen Sie diese Zahl und skalieren Sie sie entsprechend auf den gewünschten Bereich.

Jedes Mal, wenn ein Spieler positiv würfelt, wird der Bias abgezogen. Jedes Mal, wenn der Spieler ungünstig würfelt, erhöhen Sie die Tendenz. Der Betrag, um den sich die Rolle ändert, kann skaliert werden, je nachdem, wie (ungünstig) die Rolle ist, oder es kann sich um einen Pauschalbetrag (oder eine Kombination) handeln. Sie müssen bestimmte Werte anpassen, um sie an das gewünschte Gefühl anzupassen.