Je suis actuellement confronté à un système de combat multijoueur où les dégâts infligés par les joueurs sont toujours multipliés par un facteur aléatoire entre 0,8 et 1,2.

En théorie, un RNG vraiment aléatoire peut éventuellement donner plusieurs fois le même nombre (voir le dilemme Tetris ). Cela pourrait entraîner un match où le joueur fait toujours des dégâts très élevés tandis que l'autre fait toujours des dégâts très faibles.

Que puis-je faire pour m'assurer que cela ne se produise pas? Certains RNG sont-ils meilleurs que d'autres pour éviter la répétition?

Vous pouvez le résoudre de la même manière que Tetris, en créant une liste prédéfinie de résultats de dégâts et en mélangeant.

Disons que vous savez que le joueur va infliger des dégâts de 0,8 à 1,2 fois avec une distribution linéaire. Prenez la liste [0.8, 0.9, 1.0, 1.1, 1.2]. Mélangez-le au hasard , vous obtenez donc par exemple [1.2, 1.0, 0.8, 0.9, 1.1].

La première fois que le joueur inflige des dégâts, il inflige 1,2x. Puis 1x. Ensuite, etc, à 1.1x. Ce n'est que lorsque le tableau est vide que vous devez générer et mélanger un nouveau tableau.

En pratique, vous voudrez probablement faire cela sur 4+ tableaux à la fois (par exemple commencer par [0.8,0.8,0.8,0.8,0.9,0.9,0.9,0.9, ...]). Sinon, la période de la séquence est suffisamment basse pour que les joueurs puissent déterminer si leur prochain coup est "bon" ou non. (Bien que cela puisse également ajouter plus de stratégie au combat, comme dans le tableau Hoimi de Dragon Quest IX , que les gens ont compris comment sonder en regardant les nombres de soins et peaufiner jusqu'à ce que vous soyez assuré d'une goutte rare.)

J'ai en fait écrit du code pour le faire . L'essentiel est d'utiliser des statistiques pour corriger les séquences malchanceuses. Pour ce faire, vous pouvez suivre le nombre de fois où l'événement s'est produit et l'utiliser pour biaiser le nombre généré par le PRNG.

Premièrement, comment pouvons-nous suivre le pourcentage d'événements? La manière naïve de le faire serait de conserver tous les nombres jamais générés en mémoire et de les faire la moyenne: ce qui fonctionnerait mais est horriblement inefficace. Après un peu de réflexion, j'ai trouvé ce qui suit (qui est essentiellement une moyenne mobile cumulative ).

Prenez les échantillons PRNG suivants (où nous procédons si l'échantillon est> = 0,5):

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

Notez que chaque valeur contribue à 1/5 du résultat final. Regardons les choses autrement:

Values: 0.1, 0.5
Events: 0  , 1

Notez que le 0contribue à 50% de la valeur et le 1contribue à 50% de la valeur. Un peu plus loin:

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

Maintenant, les premières valeurs contribuent à 66% de la valeur et les 33 derniers%. Nous pouvons essentiellement résumer cela jusqu'au processus suivant:

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

Maintenant, nous devons biaiser le résultat de la valeur échantillonnée à partir du PRNG, parce que nous allons chercher un pourcentage de chance ici, les choses sont beaucoup plus faciles (contre, disons, des quantités aléatoires de dommages dans un RTS). Cela va être difficile à expliquer parce que cela vient de «me venir à l'esprit». Si la moyenne est inférieure, cela signifie que nous devons augmenter les chances que l'événement se produise et vice-versa. Donc, quelques exemples

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%

Maintenant, ce qui m'est venu à l'esprit, c'est que dans le premier exemple, 83% n'était que "0,5 sur 0,6" (en d'autres termes "0,5 sur 0,5 plus 0,1"). En termes d'événements aléatoires, cela signifie soit:

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

Donc, pour générer un événement, vous utiliseriez essentiellement le code suivant:

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

Et donc vous obtenez le code que j'ai mis dans l'essentiel. Je suis presque sûr que tout cela peut être utilisé dans le scénario de dommages aléatoires, mais je n'ai pas pris le temps de le comprendre.

Avertissement: Ce sont toutes des statistiques locales, je n'ai aucune formation dans le domaine. Mes tests unitaires réussissent cependant.

Ce que vous demandez est en fait l'opposé de la plupart des PRNG, une distribution non linéaire. Mettez simplement une sorte de logique de rendements décroissants dans vos règles, en supposant que tout ce qui dépasse 1,0x est un "coup critique" quelconque, dites simplement qu'à chaque tour, vos chances d'obtenir un critique augmentent de X, jusqu'à ce que vous en obteniez un à quel point ils sont réinitialisés à Y. Vous effectuez ensuite deux lancers à chaque tour, un pour déterminer le niveau critique ou non, puis un autre pour la grandeur réelle.

Sid Meier a fait un excellent discours sur GDC 2010 sur ce sujet et les jeux de civilisation. J'essaierai de trouver et de coller le lien plus tard. Essentiellement - le caractère aléatoire perçu n'est pas le même que le vrai caractère aléatoire. Pour que les choses se sentent bien, vous devez analyser les résultats précédents et faire attention à la psychologie des joueurs.

Évitez les séquences de malchance à tout prix (si les deux tours précédents n'ont pas été chanceux, le prochain devrait être garanti d'avoir de la chance). Le joueur doit toujours être plus chanceux que l'adversaire IA.

Utilisez un biais de décalage

$0$$1$$r$$b$$0$

La distribution globale sera biaisée par la formule suivante:

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

$b$$1$$b$$0$

Prenez ce nombre et adaptez-le de manière appropriée à la plage souhaitée.

Chaque fois qu'un joueur roule favorablement, soustrayez du biais. Chaque fois que le joueur roule défavorablement, ajoutez au biais. Le montant modifié peut être ajusté en fonction du degré (défavorable) favorable du rouleau ou peut être un montant fixe (ou une combinaison). Vous devrez ajuster des valeurs spécifiques pour s'adapter à la sensation que vous recherchez.