Fonction AnyDice pour utiliser un dé comme basculement haut/bas et critique

Question

J'ai développé un système fait maison qui utilise 3d12 et j'aimerais obtenir les probabilités affichées pour pouvoir, premièrement, voir si un tel système serait viable et, deuxièmement, pouvoir déterminer comment les compétences et les attributs fonctionneraient. Le but du 3d12 est purement thématique, car presque tout tourne autour du traitement du "3" comme d'un nombre sacré dans le jeu.

Je suis encore en train d'apprendre à utiliser AnyDice. J'avais emprunté une fonction que j'avais trouvée en ligne et qui était initialement conçue pour lancer 2d6 puis un lancer de pièce, le résultat de ce lancer étant soit de prendre le plus élevé soit le plus bas.

J'ai essayé de l'imiter, mais pour mes besoins, j'essaie de créer une fonction qui lancera 3d12, mais l'un des d12 sera un dé décideur similaire à la pièce. Si le dé décideur est impair, vous prenez le plus bas des deux autres d12. S'il est pair, vous prenez le plus élevé.

Une particularité du problème est la façon dont je gère les critiques. Si les deux dés principaux sont égaux (doubles), alors ils sont additionnés au lieu de choisir le plus élevé ou le plus bas. Et si le dé décideur correspond également (triples), cela compte comme un "critique" et le troisième dé est également ajouté.

Voici la "frankenfonction" que j'ai essayé de rassembler à partir de ce que j'ai trouvé en ligne et dans la documentation, mais clairement je suis idiot car elle résolvait réellement à un moment donné; j'ai maintenant d'une certaine manière réussi à provoquer une erreur de syntaxe :

function: well of DICE:d flip COIN:n
{
 if (COIN = 1, 3, 5, 7, 9, 11)
  {
   result: [lowest 1 of DICE]
  }
 result: [highest 1 of DICE]
}

loop N sur {2..5}
{
 output [well of Nd12 flip d12] named "[N]d12"
}

output [well of 2d12 flip d12] named "2d12 biased"

Answer 1

L'erreur de syntaxe vient du fait que AnyDice ne (contrairement aux langages de la famille C) enveloppe pas les conditions if entre parenthèses. En fait, sa syntaxe de surface est trompeuse ; elle partage très peu de choses avec ces langages. De plus, pour comparer à une liste, vous devez la transformer en une séquence avec {}.

Vous alliez avoir besoin d'une fonction enveloppe également, pour concrétiser les lancers individuels. (Contrairement à la plupart des langages, AnyDice peut facilement avoir des variables dans une fonction qui ne peuvent être gérées utilement qu'en les passant à une autre fonction.) Voici comment je l'ai fait avec quelques ajustements suggérés par Ilmari Karonen.

function: H:n ou L:n par COIN:n {
  if COIN = (COIN/2)*2 {
    R: H
  }
  else {
    R: L
  }
  if L = H {
    \ Doubles signifie garder les deux \
    R: L + H
    if L = COIN {
      \ Les triples ajoutent également le dé cideur \
      R: R + COIN
    }
  }
  result: R
}

function: bien de DICE:s lancer COIN:n
{
  result: [1@DICE ou 2@DICE par COIN]
}

output [bien de 2d12 lancer d12] nommé "2d12 biaisé"
output [bien de 2d12 lancer 1] nommé "2d12 toujours le plus bas"
output [bien de 2d12 lancer 2] nommé "2d12 toujours le plus haut"

Les courbes graphiques sont, bien sûr, plutôt particulières, mais je pense que c'est correct. Il y a des creux et des bosses correspondantes où les doubles déplacent les occurrences vers le haut.

Answer 2

Voici une manière plus simple de mettre en œuvre ce mécanisme dans AnyDice :

function: combiner A:n et B:n en utilisant C:n {
  if A = B & B = C { result: A+B+C }
  if A = B { result: A+B }
  if C = 2*(C/2) { result: [le plus élevé de A et B] }
  else { result: [le plus bas de A et B] }
}

output [combiner d12 et d12 en utilisant d12]

Le code devrait être assez explicite, même s'il repose sur deux détails légèrement obscurs (mais assez importants) concernant le fonctionnement des fonctions AnyDice :

1. assigner quoi que ce soit à result termine immédiatement la fonction, et
2. si une fonction attend un ou plusieurs nombres en paramètres (comme indiqué par le :n après le nom du paramètre) est appelée avec des dés en tant que paramètres, la fonction sera évaluée pour chaque combinaison possible des dés, et les résultats seront pondérés (donnant ainsi un nouveau dé biaisé) selon la probabilité de chaque combinaison.

C'est donc le truc général pour évaluer les résultats d'un lancer de dés de manière inhabituelle dans AnyDice : il suffit de passer des dés dans une fonction qui attend un nombre (ou une séquence) en paramètre, et de déterminer le résultat du lancer à l'intérieur de la fonction.

(Le C = 2*(C/2) pourrait également nécessiter un peu d'explication. AnyDice n'a pas d'opérateur de reste/modulo comme % en C, mais il a un opérateur de division entière / qui arrondit à la baisse le résultat. Ainsi, une manière facile de vérifier si un nombre est pair est de le diviser par 2, en arrondissant à la baisse, puis de le multiplier par 2 à nouveau et de vérifier si le résultat égale le nombre original.)

---

Quoi qu'il en soit, si vous regardez le graphique des résultats, vous remarquerez que la distribution résultante est très proche d'un simple lancer de d12, à l'exception du fait qu'il y a une petite chance que le résultat soit doublé, et une chance encore plus petite qu'il soit triplé.

En fait, il s'avère que la formule suivante génère exactement la même distribution :

output d12 * d{3, 2:11, 1:(11*12)}

La chose d{3, 2:11, 1:(11*12)} est un dé biaisé qui lance un trois avec une probabilité de 1/144, un deux avec une probabilité de 11/144, et un un avec une probabilité de 132/144. Ce sont exactement les probabilités d'obtenir un "critique triplé", un "critique normal" et un lancer non critique dans votre système.

Ainsi, le mécanisme "le plus élevé s'il est pair, le plus bas s'il est impair" ne fait pratiquement aucune différence ; seuls les critiques distinguent votre système d'un simple lancer de d12. En fait, si vous supprimez les deux premières déclarations if de la fonction combiner A:n et B:n en utilisant C:n que j'ai donnée ci-dessus, vous verrez que les résultats seront identiques à un simple lancer de 1d12.