Comment faire correspondre un seul d20 à un certain nombre de coups (cas d'utilisation : Animer des objets) ?

Question

Le problème

Supposons qu'un personnage utilise Animate Objects (D&D 5e) pour animer 10 objets minuscules et qu'il attaque le même ennemi avec tous ces objets. Selon RAW, vous feriez un jet d'attaque séparé pour chacun des objets - donc 10 jets d'attaque, et un jet de dégâts pour chaque objet qui touche. C'est beaucoup, et ce serait bien s'il y avait un moyen de réduire le nombre de jets d'attaque.

Stratégie triviale
Rouler une fois pour toutes. Un seul rouleau : très bien ! Mais alors, soit tous les objets frappent, soit aucun ne frappe, ce qui, ensemble, est littéralement l'issue la moins probable. Ce n'est donc pas très représentatif de ce que l'on obtiendrait en lançant chaque attaque individuellement.

Stratégie de regroupement
Répartissez les objets en groupes et lancez une attaque pour chaque groupe. Il s'agit simplement d'un moyen terme entre les jets individuels et le jet unique pour tous, et d'un compromis entre la vitesse et la précision de la représentation. Moins de groupes = plus de vitesse et une moins bonne représentation ; plus de groupes = meilleure représentation et moins de vitesse.

Associer un d20 à un nombre de coups ?
Mon intuition me dit qu'il devrait y avoir un moyen de lancer un seul d20 et, en se basant sur le résultat (et en tenant compte du +touche et de la CA), de déterminer un nombre parmi les 10 objets qui ont touché, qui soit correctement représentatif du degré de chance du jet. Ma question est la suivante : comment pouvons-nous faire cela ?

(Je suis conscient qu'il existe des de nombreux autres moyens efficaces et créatifs de traiter ce problème Mais pour cette question, je suis particulièrement intéressé par la création de la cartographie décrite).

Exigences

1. Pour que je sois satisfait de l'utilisation de cette méthode dans un jeu, la condition la plus importante est que le personnage qui l'utilise ne soit ni avantagé ni désavantagé par son utilisation. Plus précisément, si tous les résultats possibles d'un jet d'attaque individuel étaient énumérés et comparés à tous les résultats possibles de l'utilisation de cette méthode, le nombre de succès, de ratés et de crits devrait correspondre entre les deux.

2. Comme l'implique la première condition, cette méthode doit préserver le nombre de résultats qui représentent des coups critiques. Les "coups critiques manqués" doivent également être pris en compte de la même manière, dans la mesure où ils représentent un coup manqué contre n'importe quelle classe d'armure.

3. La méthode doit éviter de générer des résultats remarquables à une fréquence supérieure à celle des attaques individuelles. ("Remarquable" = les joueurs froncent les sourcils autour de la table ; si cela se produisait deux fois, il y aurait des accusations plaisantes (ou sérieuses) de dés pondérés, etc.)

4. La méthode doit préserver le paradigme intuitif selon lequel il est préférable de rouler plus haut. Un résultat de 20 représenterait le plus grand nombre de succès ; un résultat de 1 représenterait le plus petit ; et aucun résultat X ne pourrait être considéré comme meilleur que Y si X est inférieur à Y.

5. Enfin, la méthode doit, dans la mesure du possible et tout en respectant les autres contraintes, représenter correctement la distribution des touches que l'on peut s'attendre à obtenir en lançant les attaques individuellement.

Travaux en cours

Je suis actuellement en train d'essayer de résoudre ce problème moi-même, et je vais (bientôt, je l'espère) publier ma meilleure tentative de réponse ici. Je pense que la solution passe par la mise en place d'une sorte de tableau générique des # de hits et # de crits pour chacun des résultats d'un d20 contre une AC de base arbitraire, couplé à une formule qui modifie ces résultats en fonction du + to hit de l'attaque et de l'AC réelle de la cible.

Mais je n'ai pas l'habitude de calculer les probabilités des dés, et la solution que j'envisage repose en partie sur des sauts intuitifs que je ne suis pas sûr de pouvoir justifier. J'espère donc que des joueurs expérimentés ont déjà tenté quelque chose de similaire ou savent comment manipuler ce genre de probabilités. De toute façon, je trouve que ce problème est un défi très intéressant, et pourquoi devrais-je avoir tout le plaisir ? Merci de votre aide et de vos conseils !

Answer 1

Convertir simplement le quantile de d20 en quantile de succès

TL;DR : convertir le quantile des résultats des d20 en quantile des résultats réels. Tableaux à la fin...

Si vous cherchez seulement nombre d'occurrences (en ignorant les Crits), le résultat est une somme de tirages à pile ou face indépendants (biaisés en fonction de la CA et du bonus d'attaque) - c'est-à-dire qu'un Distribution binomiale con n=10 (nombre d'attaquants = nombre de tirages à pile ou face) et p (probabilité de réussite individuelle = probabilité de pile ou face individuelle) déterminée en fonction de la CA et du bonus d'attaque.

Qu'est-ce que p_hit ?

Nous pouvons calculer p comme suit (exemples en Python)

def get_p_hit(ac:int, bonus:int) -> float:
    # 1 is a definite miss, 20 is a definite hit, while [2,20) check vs ac
    return (sum([0 if i+bonus < ac else 1 for i in range(2,20)])+1) / 20.

(Cela correspond à peu près à (21 + bonus - ac) / 20 à l'exception de la garantie de succès ou d'échec sur 20 ou 1)

À ce stade, nous disposons d'une distribution de probabilité entièrement définie sur le nombre de résultats.

Conversion des d20 en résultats

Le résultat d'un d20 est également une distribution de probabilité entièrement définie. Il est toujours possible d'effectuer une conversion approximative entre les distributions de probabilités à l'aide de la fonction quantile .

Dans ce cas, nous cartographions un rouleau de 1 à un résultat dans le pire des cas 1/20th des résultats, une 2 à un résultat dans le deuxième pire 1/20th des résultats, jusqu'à 20 que nous faisons correspondre à un résultat dans la meilleure 1/20th de résultats[^hitch].

def get_q_from_r(r:int) -> float:
    '''
    r should be a d20 roll expressed as an integer from 1 to 20 inclusive
    '''
    return (r - .5) / 20

[^hitch] : Il y a un petit problème : il peut y avoir plusieurs résultats appartenant à ce pire/second pire/.../meilleur. 1/20th des résultats. Il semble raisonnable de choisir le résultat intermédiaire parmi ceux-ci, ce que fait mon code, en soustrayant .5 du rouleau avant de le diviser.

Passer du quantile au résultat des hits

Avec notre distribution binomiale en main et un quantile de résultat, il existe de nombreuses façons de calculer un résultat. La plus simple (et la plus généralisable) est probablement de reconnaître qu'avec des quantiles de résultats raisonnablement grands, il est possible d'obtenir un quantile de résultat. n (10 est suffisant à cette fin) Un binôme est étroitement rapprochée d'une distribution normale avec la même moyenne et le même écart-type. Il nous suffit donc de calculer la moyenne et l'écart-type de notre binôme à l'aide des formules standard, puis d'utiliser un quantile normal.

Voici un exemple utilisant certaines bibliothèques Python, mais la plupart des langages ont des paquets numériques qui font la même chose

import numpy as np
import scipy.stats
from typing import Tuple

def get_mean_std(p_hit:float, n_attackers:int) -> Tuple[float, float]:
    mean = n_attackers * p_hit
    std = np.sqrt(mean * (1-p_hit))
    return mean, std

def get_hit_count_normal_approx(mean:float, std:float, q:float) -> int:
    return round(mean + std * scipy.stats.norm.ppf(q))

Dans notre cas particulier (si p_hit est très faible ou très élevé, les valeurs très marginales peuvent être invalides en raison de l'approximation normale - nous devons donc les tronquer pour être sûrs) :

def get_hits_for_attackers(ac:int, bonus:int, n_attackers:int, r:int) -> int:
    '''
    r should be a d20 roll expressed as an integer from 1 to 20 inclusive
    '''
    p_hit = get_p_hit(ac, bonus)
    mean, std = get_mean_std(p_hit, n_attackers)
    q = get_q_from_r(r)
    return max(0, min(n_attackers, get_hit_count_normal_approx(mean, std, q)))

Nous pouvons facilement exécuter cette fonction autant de fois que nécessaire et calculer un tableau pour une consultation plus rapide au moment de la lecture.

Discussion bonus sur les crits

Malheureusement, tout ce qui précède ne tient pas compte des coups critiques ! Cette approche est cependant agréable et modulaire : nous pouvons penser aux coups critiques Nombre d'occurrences comme une autre somme de résultats aléatoires - un autre binôme !

Cette fois-ci, le n est le nombre de succès (qui peuvent ou non se transformer en crits), et la valeur p est la probabilité qu'un succès soit un crit, étant donné qu'il s'agit d'un succès ! c'est-à-dire que si j'ai obtenu un résultat suffisamment élevé pour toucher, quelle proportion de ces résultats était un 20 ?

def get_p_crit_given_hit(p_hit:float) -> float:
    return 1/20 / p_hit

Avec cette probabilité en main, nous pouvons "convertir" un nombre aléatoire de hits en crits, si nous sommes prêts et capables de lancer un autre d20. C'est exactement la même approche, sauf que cette fois nous avons besoin d'une variable plutôt que de coder en dur 10 .

def get_crits_for_hits(ac:int, bonus:int, n_hits:int, r:int) -> int:
    '''
    r should be a d20 roll expressed as an integer from 1 to 20 inclusive
    '''
    p_hit = get_p_hit(ac, bonus)
    p_crit_given_hit = get_p_crit_given_hit(p_hit)
    mean, std = get_mean_std(p_hit=p_crit_given_hit, n_attackers=n_hits)
    q = get_q_from_r(r)
    return max(0, min(n_hits, get_hit_count_normal_approx(mean, std, q)))

Observation sur l'utilité des tableaux

Il est évident qu'il serait fastidieux de disposer d'un tableau pour chaque combinaison de ac y bonus ! Mais heureusement, ces deux variables peuvent être encapsulées pour nos besoins en p_hit . p_hit peut prendre exactement 19 valeurs (de 0,05 à 0,95), ce qui signifie que vous n'avez besoin que de 19 tables de résultats de d20.

Malheureusement, la variance/déviation des résultats réels dépend du nombre d'attaquants, de sorte qu'il n'est pas possible d'échapper à la nécessité d'un nouveau tableau par nombre d'attaquants. Mais le code ici présent peut facilement le générer.

En fait, pour exactement 10 attaquants, vous pouvez avoir un grand tableau comme celui-ci, avec p_hit le long de la partie supérieure et du jet de d20 r en sélectionnant la ligne :

p_hit

0.05

0.1

0.15

0.2

0.25

0.3

0.35

0.4

0.45

0.5

0.55

0.6

0.65

0.7

0.75

0.8

0.85

0.9

0.95

1 :

0

0

0

0

0

0

1

1

1

2

2

3

4

4

5

6

6

7

8

2 :

0

0

0

0

1

1

1

2

2

3

3

4

4

5

6

6

7

8

9

3 :

0

0

0

1

1

1

2

2

3

3

4

4

5

5

6

7

7

8

9

4 :

0

0

0

1

1

2

2

3

3

4

4

5

5

6

6

7

7

8

9

5 :

0

0

1

1

1

2

2

3

3

4

4

5

5

6

6

7

8

8

9

6 :

0

0

1

1

2

2

3

3

4

4

5

5

6

6

7

7

8

8

9

7 :

0

1

1

1

2

2

3

3

4

4

5

5

6

6

7

7

8

9

9

8 :

0

1

1

2

2

3

3

4

4

4

5

6

6

7

7

8

8

9

9

9 :

0

1

1

2

2

3

3

4

4

5

5

6

6

7

7

8

8

9

9

10 :

0

1

1

2

2

3

3

4

4

5

5

6

6

7

7

8

8

9

9

11 :

1

1

2

2

3

3

4

4

5

5

6

6

7

7

8

8

9

9

10

12 :

1

1

2

2

3

3

4

4

5

5

6

6

7

7

8

8

9

9

10

13 :

1

1

2

2

3

3

4

4

5

6

6

6

7

7

8

8

9

9

10

14 :

1

1

2

3

3

4

4

5

5

6

6

7

7

8

8

9

9

9

10

15 :

1

2

2

3

3

4

4

5

5

6

6

7

7

8

8

9

9

10

10

16 :

1

2

2

3

4

4

5

5

6

6

7

7

8

8

9

9

9

10

10

17 :

1

2

3

3

4

4

5

5

6

6

7

7

8

8

9

9

10

10

10

18 :

1

2

3

3

4

5

5

6

6

7

7

8

8

9

9

9

10

10

10

19 :

1

2

3

4

4

5

6

6

7

7

8

8

9

9

9

10

10

10

10

20 :

2

3

4

4

5

6

6

7

8

8

9

9

9

10

10

10

10

10

10

Par ailleurs, si vous ne voulez pas calculer p_hit vous pouvez utiliser le même tableau avec (ac - bonus) à la place de l'en-tête (puisque cela détermine la valeur de l'en-tête p_hit )

(ac - bonus)

20 ou plus

19

18

17

16

15

14

13

12

11

10

9

8

7

6

5

4

3

2 ou moins

1 :

0

0

0

0

0

0

1

1

1

2

2

3

4

4

5

6

6

7

8

etc.

Si nous voulons utiliser la méthode du bonus pour obtenir des crits, nous aurons besoin d'un tableau pour chaque "nombre d'attaquants" de 1 à 10. D'autres réponses tentent de mélanger les résultats des coups critiques en un seul jet, ce qui pourrait être préférable.

Answer 2

Nous pouvons calculer la distribution des coups possibles et les associer à des dés. Tout d'abord, nous utilisons le bonus d'attaque (+8) et la CA (17) pour calculer la précision (55%). Ensuite, pour chacun des 20 jets de dé possibles représentant le résultat avec les chances 2,5%, 7,5%, 12,5%.... 92,5%, 97,5%, on calcule le nombre de touches.

Il s'avère que cette opération est délicate à réaliser en une seule étape, et qu'il est donc plus facile de la réaliser en deux étapes. Tout d'abord, pour chaque nombre d'occurrences, quelle est la probabilité qu'au moins ce nombre d'occurrences se produise ? Cette probabilité peut être calculée dans Google sheets à l'aide de l'équation suivante BINOMDIST(NumberOfHits,NumberOfAttackRolls,HitChance,true) Pour un bonus d'attaque de +8 contre une CA de 17, et 10 attaques, cela donne ce tableau

Nombre de succès

Cotes

0

0.01%

1

0.17%

2

1.23%

3

5.48%

4

16.62%

5

36.69%

6

61.77%

7

83.27%

8

95.36%

9

99.40%

10

100.00%

Et puisque chaque face du dé représente une fourchette de 5 %, nous pouvons faire correspondre chaque face du dé à une fourchette de probabilité, et donc au nombre de succès correspondant. Par exemple, nous voulons qu'un résultat de 7 représente l'intervalle de probabilité 37,5-42,5 %. Dans la FCD, cette plage de probabilités est comprise entre 36,69 et 61,77 %, ce qui correspond à 6 succès. Un résultat de 6 représente la plage de probabilité 32,5-37,5 %. La FCD m'indique qu'il s'agit généralement de 5... et éventuellement de 6 succès. Pour éviter toute ambiguïté, nous placerons chaque jet de dé au centre de sa fourchette. Ainsi, un résultat de 1 correspond aux 2,5 % et un résultat de 20 correspond aux 97,5 % de chances.

L'équation est la suivante VLookup((DiceRoll-0.5)/20,AttackOddsTable,DieRollIndex,true) .

Rouleau

Nombre de succès

1

2

2

3

3

3

4

4

5

4

6

4

7

4

8

5

9

5

10

5

11

5

12

5

13

6

14

6

15

6

16

6

17

6

18

7

19

7

20

8

Il convient de noter que ces valeurs, bien que "précises", sont un peu décevantes ou inattendues autour de 1 et 20. Personnellement, je modifierais manuellement 1 pour rater toutes les attaques et 20 pour toucher toutes les attaques.
Nous pouvons également calculer le nombre attendu de crits avec la même formule, avec "5% de chances de toucher".

J'ai fait cette feuille de calcul pour calculer tout cela, ainsi que les dégâts moyens. Si vous ne voulez pas avoir une feuille ouverte pour ajuster la CA de chaque cible, vous pouvez envisager de sauvegarder les résultats pour chaque CA possible.

Answer 3

Moyenne avec bruit

Il y a 10 monstres. Disons que vous devez obtenir un résultat de 13 pour toucher. En moyenne, 8/20 des monstres touchent, ce qui, multiplié par 10, donne 4 succès. On peut donc dire qu'il y a toujours 4 touches.

Ou alors, il est possible d'appliquer la règle des 4 plus un nombre aléatoire moyen de zéro d'entre eux. Par exemple, lancez un d6 et obtenez 4+n touches pour n=-2,-1,0,0,1,2 selon que vous obtenez respectivement 1,2,3,4,5,6.

Oh, et inflige des dégâts moyens par coup.

Answer 4

J'aime Réponse de Eddymage . C'est sur cette base que le projet a été élaboré. Si j'en avais le droit, j'ajouterais ce commentaire comme une suggestion d'amélioration à cette réponse.

Si vous voulez que le résultat de la table DMG soit basé sur un jet d'attaque, vous devez le retourner et soustraire 10 comme suit : 20 -> 1 -> -9, 18 -> 3 -> -7, 10 -> 11 -> 1, etc.

Différence par rapport à l'objectif

Attaquants nécessaires pour 1 coup

-9

20

-8

10

De -7 à -6

5

-5 à -4

4

De -3 à -2

3

-1 à +5

2

+6 à +10

1

Lancez 1d20 pour toucher comme d'habitude, avec tous les modificateurs. Comparez votre résultat à la CA de la cible. Par exemple, si vous obtenez un résultat exact, un de vos serviteurs sur deux est touché. Si vous obtenez un résultat inférieur de 4 à la CA, un de vos serviteurs sur quatre est touché. Si vous obtenez un résultat supérieur de 8 à la CA, tous vos serviteurs ont touché.

Personnellement, je préférerais utiliser le tableau plus précis mathématiquement qu'Eddymage a calculé :

Différence par rapport à l'objectif

Attaquants nécessaires pour 1 coup

De -9 à -8

20

-7

10

-6

7

-5

5

-4

4

-3 à -1

3

0 à +4

2

+5 à +10

1

Je ne sais pas exactement comment cela se traduirait sur le plan statistique par rapport à un tirage au sort pour tout. Cela ne préserve pas les crits, mais vous pouvez en ajouter par la même occasion :

• Avoir un 20 sur le dé génère un critérium
• chaque X coups produit un critérium
• Un nombre suffisant de touches "partielles" accompagnées d'au moins une touche réussie (c'est-à-dire que 1/4 des 7 serviteurs produit 1 et 3/4 touches) entraîne le critérium d'une seule touche.
• une combinaison de ce qui précède