Comment modéliser le style de combat du guerrier, la compétence de Grande Maîtrise avec les armes, dans Anydice?

Question

Je cherchais à créer une fonction AnyDice pour modéliser le style de combat Great Weapon Fighting (qui vous permet de relancer les 1 et les 2), mais je n'arrivais pas à le faire fonctionner sur n'importe quel dé arbitraire.

J'ai trouvé celui-ci :

function: reroll R:n under N:n {
   if R < N { result: d12 } else {result: R}
}
output [reroll 1d12 under 3] named "combat d'arme greataxe"

Et ça fonctionne bien. Mais je ne sais pas comment rendre la fonction générique pour ne pas avoir à changer le d12 à chaque fois que je veux relancer un dé différent.

J'ai essayé

function: reroll R:n under N:n {
   if R < N { result: d{1..R} } else {result: R}
}
output [reroll 1d12 under 3] named "combat d'arme greataxe"

mais cela ne donne pas les bonnes probabilités. Peut-être que si je pouvais récupérer la taille du dé à l'intérieur de la fonction...

Answer 1

C'est une erreur courante avec anydice de chercher une solution procédurale - anydice modélise des dés. Par conséquent, posez votre problème comme "À quoi ressemblent les dés qui donnent la réponse?"

Pensez à comment fonctionne la Grande Maîtrise des Armes avec un d8. Nous lançons potentiellement 2 dés à 8 faces donc notre dé de résultat a 8x8=64 faces. Il y a 2 façons d'obtenir un 1 (ou 2) - en lançant un 1 ou 2 suivi d'un 1 (ou 2) donc nos dés ont 2 1 et 2 2. Cela laisse 60 faces qui sont également divisées entre les nombres 3 à 8, donc 10 de chaque. Donc dans anydice nos dés ressemblent à :

HUIT: {{1..2}:2, {3..8}:10}

De manière plus générale, pour un dé à N faces:

DGW: {{1..2}:2, {3..N}:N+2}

Pour un dé avec un nombre pair de faces (c'est-à-dire tous), cela peut être simplifié en divisant le nombre de faces par 2:

DGW: {{1..2}, {3..N}:N/2+1}

Vous pouvez utiliser cette séquence comme n'importe quel autre dé donc une grande épée peut être modélisée comme:

2d{{1..2}, {3..6}:4}

Answer 2

Il semble que vous demandiez quelque chose comme la fonction intégrée [explode DIE] dans AnyDice, sauf pour relancer le dé (une seule fois) si le jet original est en dessous d'une certaine limite.

Si vous regardez la bibliothèque de fonctions AnyDice (dans le menu de gauche) et cliquez sur l'entrée explode, vous verrez en fait une section "Faites-le vous-même" pratique qui montre comment réimplémenter la fonction intégrée explode vous-même. Le truc pour rendre la syntaxe propre et claire est d'utiliser deux fonctions : une fonction enveloppe qui prend le dé non roulé en paramètre et appelle une fonction auxiliaire pour chaque résultat possible du jet (c'est-à-dire passer le même dé à la fonction auxiliaire, qui s'attend à un nombre).

Nous pouvons utiliser le même truc ici:

function: reroll DIE:d if under LIMIT:n {
  result: [reroll DIE as DIE if under LIMIT]
}
function: reroll ROLL:n as DIE:d if under LIMIT:n {
  if ROLL < LIMIT { result: DIE }
  else { result: ROLL }
}

loop SIDES over {4,6,8,12,20} {
  output [reroll dSIDES if under 3] named "d[SIDES] avec GWF"
}

Ici, [reroll DIE if under LIMIT] est la fonction enveloppe, qui appelle simplement la fonction interne [reroll ROLL as DIE if under LIMIT] pour chaque jet possible du dé. La fonction interne vérifie ensuite simplement si le jet est en dessous de la limite, et si c'est le cas, renvoie le dé "relancé" au lieu du jet d'origine.

Vous pourriez bien sûr aussi appeler la fonction interne directement, comme ceci :

loop SIDES over {4,6,8,12,20} {
  output [reroll dSIDES as dSIDES if under 3] named "d[SIDES] avec GWF"
}

et obtenir les mêmes résultats. Mais parfois, il est agréable d'éviter de répéter un paramètre comme ça. En fait, si nous sommes seulement intéressés par la modélisation des relances dues à la Grande Maîtrise d'Arme, nous pourrions aussi laisser de côté le paramètre constant LIMITE, et simplifier notre fonction enveloppe en :

function: gwf DIE:d {
  result: [reroll DIE as DIE if under 3]
}

Bonus : La sortie de la ou des fonctions données ci-dessus est elle-même un dé (c'est-à-dire une distribution de probabilité sur les entiers), et peut donc être attribuée à un dé personnalisé qui "se relance automatiquement". Vous pouvez ensuite lancer autant de ces dés personnalisés que vous le souhaitez, ou même les mélanger avec d'autres dés.

Par exemple, pour obtenir les résultats de lancer 2dX avec la Grande Maîtrise d'Arme, vous pourriez faire :

loop SIDES over {4,6,8,12,20} {
  GWF: [gwf dSIDES]
  output 2dGWF named "2d[SIDES] avec GWF"
}

ou, alternativement, simplement :

loop SIDES over {4,6,8,12,20} {
  output 2d[gwf dSIDES] named "2d[SIDES] avec GWF"
}

Answer 3

J'ai rencontré un problème similaire et j'ai pu le résoudre assez proprement avec une paire de fonctions.

function: reroll D:d sous N:n{
   result: [rerollcore D dé D sous N]
}

function: rerollcore R:n dé D:d sous N:n{
   if R < N { result: D } else {result: R}
}

output [reroll d12 sous 3]

La fonction de reroll existe uniquement pour capturer le dé lancé, tandis que la fonction rerollcore existe pour effectuer le lancer / reroll réel.

Answer 4

Après avoir examiné toutes les réponses, j'ai trouvé que plusieurs d'entre elles ont des erreurs subtiles. Si vous lancez 2 dés, tout semble bien se passer, mais dès que vous ajoutez 3 dés à l'équation, vous verrez que les calculs sont incorrects.

Cela fait une différence lorsque vous obtenez un coup critique car vous lancerez chacun des dés de dégâts deux fois, et chacun peut être relancé si vous avez la compétence Grande Maîtrise des Armes et obtenez un 1 ou un 2 sur l'un des dés.

Voici ce que j'ai créé, et que je crois être correct, basé sur les comparaisons que j'ai pu faire avec d'autres distributions de percentile :

function: roll gwf damage with SIDES_ON_DMG_DIE:n sided die {
    \ créer un dé qui simule le fait de relancer les premiers 1 ou 2 en séquence \
    GWF_DIE: {{1..2}:2, {3..SIDES_ON_DMG_DIE}:SIDES_ON_DMG_DIE+2}
    result: dGWF_DIE
}

output 2d[lancer des dégâts gwf avec un dé à 6 faces] 

Cela vous permet de spécifier le nombre de faces ainsi que de les lancer. Il crée dynamiquement la séquence de nombres à partir de laquelle sélectionner un nombre aléatoire. (merci à @Dale-M pour cette partie).

Answer 5

J'ai pu créer une fonction très maladroite qui utilise la valeur maximale du dé comme troisième entrée :

function: reroll R:n max XX:n under N:n {
   if R < N { result: d{1..XX} } else {result: R}
}
output [reroll d12 max 12 under 3] nommé "relancer les 1 et 2 une fois"