Attualmente mi sto occupando di un sistema di combattimento multiplayer in cui il danno inflitto dai giocatori viene sempre moltiplicato per un fattore casuale compreso tra 0,8 e 1,2.

In teoria, un RNG veramente casuale può eventualmente produrre lo stesso numero molte volte (vedi il dilemma di Tetris ). Ciò potrebbe tradursi in un match in cui il giocatore è sempre facendo molto alto danno, mentre l'altro fa sempre molto bassa danni.

Cosa posso fare per assicurarmi che ciò non accada? Alcuni RNG sono migliori di altri nell'evitare la ripetizione?

Puoi risolverlo allo stesso modo di Tetris, creando un elenco predefinito di risultati dei danni e mescolando.

Supponiamo che tu sappia che il giocatore infliggerà danni da 0,8 a 1,2 volte con una distribuzione lineare. Prendi l'elenco [0.8, 0.9, 1.0, 1.1, 1.2]. Mischialo in modo casuale , in modo da ottenere ad esempio [1.2, 1.0, 0.8, 0.9, 1.1].

La prima volta che il giocatore infligge danno, infliggono 1,2x. Quindi 1x. Quindi, ecc., A 1.1x. Solo quando l'array è vuoto è necessario generare e mescolare un nuovo array.

In pratica, probabilmente vorrai farlo in 4+ array contemporaneamente (es. Iniziare con [0.8.0.8,0.8,0.8,0.9,0.9,0.9,0,9, ...]). Altrimenti il ​​periodo della sequenza è abbastanza basso da consentire ai giocatori di capire se il loro prossimo colpo è "buono" oppure no. (Anche se questo può anche aggiungere più strategia al combattimento, come nel tavolo Hoimi di Dragon Quest IX , che le persone hanno capito come sondare guardando i numeri di cura e modificando fino a quando non ti viene garantito un calo raro.)

In realtà ho scritto del codice per farlo . L'essenza sta usando le statistiche per correggere le serie sfortunate. Il modo in cui puoi farlo è tenere traccia di quante volte si è verificato l'evento e usarlo per distorcere il numero generato dal PRNG.

Innanzitutto, come tenere traccia della percentuale di eventi? Il modo ingenuo di fare questo sarebbe quello di mantenere tutti i numeri mai generati in memoria e di farne una media: che funzionerebbe ma è terribilmente inefficiente. Dopo un po 'di riflessione mi è venuto in mente quanto segue (che è fondamentalmente una media mobile cumulativa ).

Prelevare i seguenti campioni PRNG (dove si procede se il campione è> = 0,5):

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

Si noti che ogni valore contribuisce a 1/5 del risultato finale. Diamo un'occhiata in un altro modo:

Values: 0.1, 0.5
Events: 0  , 1

Si noti che 0contribuisce al 50% del valore e 1contribuisce al 50% del valore. Preso leggermente oltre:

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

Ora i primi valori contribuiscono al 66% del valore e all'ultimo 33%. Fondamentalmente, possiamo distillare questo fino al seguente processo:

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

Ora dobbiamo distorcere il risultato del valore campionato dal PRNG, perché stiamo andando per una probabilità percentuale qui le cose sono molto più facili (contro, diciamo, quantità casuali di danno in un RTS). Questo sarà difficile da spiegare perché "mi è appena venuto in mente". Se la media è inferiore significa che dobbiamo aumentare la possibilità che si verifichi l'evento e viceversa. Quindi alcuni esempi

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%

Ora quello che mi è venuto in mente è che nel primo esempio l'83% era solo "0,5 su 0,6" (in altre parole "0,5 su 0,5 più 0,1"). In termini di eventi casuali ciò significa:

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

Quindi, al fine di generare un evento, useresti sostanzialmente il seguente codice:

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

E quindi ottieni il codice che ho inserito in sintesi. Sono abbastanza sicuro che tutto ciò possa essere usato nello scenario del caso di danno casuale, ma non ho avuto il tempo di capirlo.

Dichiarazione di non responsabilità: si tratta di statistiche nazionali, non ho alcuna istruzione in questo campo. I miei test unitari superano comunque.

Quello che stai chiedendo è in realtà l'opposto della maggior parte dei PRNG, una distribuzione non lineare. Inserisci semplicemente una sorta di logica dei rendimenti decrescenti nelle tue regole, Supponendo che tutto oltre 1.0x sia un "colpo critico" di qualche tipo, dì solo che ad ogni round le tue possibilità di ottenere un critico aumentano di X, fino a quando non ne ottieni uno a quale punto reimpostano su Y. Quindi fai due tiri per round, uno per determinare crit o no, e poi un altro per la grandezza effettiva.

Sid Meier ha tenuto un eccellente discorso su GDC 2010 proprio su questo argomento e sui giochi di Civilization. Proverò a trovare e incollare il link in seguito. In sostanza, la casualità percepita non è la stessa della casualità vera. Per rendere le cose giuste è necessario analizzare i risultati precedenti e prestare attenzione alla psicologia dei giocatori.

Evita le serie di sfortuna a tutti i costi (se i due turni precedenti sono stati sfortunati, il prossimo dovrebbe essere garantito per essere fortunato). Il giocatore dovrebbe essere sempre più fortunato dell'avversario AI.

Usa una propensione al cambiamento

Il generatore di base utilizza una distribuzione uniforme tra e per generare . Inizialmente impostare un valore di polarizzazione, , su .$0$$1$$r$$b$$0$

La distribuzione complessiva sarà distorta dalla seguente formula:

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

L'effetto qui è che quando è positivo, il numero risultante sarà distorto verso . Quando è negativo, il numero risultante sarà distorto verso .$b$$1$$b$$0$

Prendi questo numero e ridimensionalo in modo appropriato all'intervallo desiderato.

Ogni volta che un giocatore tira favorevolmente, sottrai dal pregiudizio. Ogni volta che il giocatore tira sfavorevolmente, aggiungi al bias. L'importo modificato potrebbe essere ridimensionato in base a quanto (non) favorevole il rotolo è o potrebbe essere un importo fisso (o una combinazione). Dovrai regolare valori specifici per adattarli all'atmosfera che stai cercando.