Ironsworn rencontre la mécanique de dés de BitD (avec une touche)

Question

J'aimerais connaître les probabilités d'une mécanique inspirée principalement d'Ironsworn.

Le principe de base est assez simple et j'ai un programme anydice qui fonctionne et qui me donne les bons résultats, mais il y a une règle supplémentaire que je n'arrive pas à mettre en place.

Le mécanisme est le suivant

1. Vous roulez x d6 et prendre le résultat le plus élevé

2. Vous comparez votre résultat le plus élevé à deux d6 "défi" qui servent d'objectifs à atteindre, si vous obtenez un résultat supérieur, c'est une réussite, si vous obtenez un résultat inférieur ou égal, c'est un échec (cela génère un résultat de 0, 1 ou 2 réussites).

3. (la règle supplémentaire que je ne sais pas programmer) En cas d'égalité, si votre résultat le plus élevé a plus de matchs que d'égalités contre les dés de défi, vous générez autant de succès.

Exemples

6, 6 vs 6, 6=0 succès

6, 6, 6 vs 6, 6=1 succès

6, 6, 6, 6 vs 6, 6=2 succès

6, 6 vs 1, 6=2 succès (6 bat 1 et les 2 6 battent 1 défi 6)

J'envisageais d'utiliser la même mécanique pour un système de critères, où le fait d'avoir le plus grand nombre de dés génère des succès supplémentaires (après qu'ils aient été utilisés pour départager les ex-aequo). Il s'agirait d'ajouter un résultat supplémentaire pour un jet de 3+ si quelqu'un veut aider à cela.

Answer 1

Mon AnyDice Fu est insuffisant, c'est donc une dyce ¹, mais je crois qu'elle répond directement et qu'elle reflète ma compréhension du mécanisme, même si je ne suis pas sûr d'avoir tout compris.

from dyce import P
from dyce.p import RollT

def ironsworn_bitd(action_roll: RollT, challenge_roll: RollT) -> int:
    max_action = max(action.roll, default=0)
    max_challenge = max(challenge.roll, default=0)
    if max_action == 0 and max_challenge == 0:
        return 0
    basic_successes = sum(1 for c in challenge_roll if c < max_action)
    num_action_matches = sum(1 for a in action_roll if a == max_action) - 1
    if max_action < max_challenge:
        match_successes = 0
    elif max_action > max_challenge:
        match_successes = num_action_matches
    else:  # max_challenge == max_action:
        num_challenge_matches = sum(1 for c in challenge_roll if c == max_action) - 1
        # Offset the number of action matches by the number of challenge matches up to
        # the number of action matches
        match_successes = max(0, num_action_matches - num_challenge_matches)
    return basic_successes + match_successes

h = P.foreach(ironsworn_bitd, action_roll=4@P(6), challenge_roll=2@P(6))
print(h.format(scaled=True))

Sortie :

avg |    1.66
std |    0.92
var |    0.85
  0 |  10.95% |############
  1 |  29.67% |#################################
  2 |  43.74% |##################################################
  3 |  13.53% |###############
  4 |   1.99% |##
  5 |   0.12% |

Vous pouvez jouer avec une version plus générale dans votre navigateur : [ source ]

Ce qui précède favorise la lisibilité et la cohérence avec le sentiment original. Il peut certainement être simplifié. Pour limiter le nombre de succès à 3, modifiez l'énoncé return basic_successes + match_successes a return min(3, basic_successes + match_successes) et le réexécuter.

Bien qu'il s'agisse d'une question de goût, je trouve que anydyce Les graphiques en "rafale" de s² sont bien adaptés à la visualisation des distributions. (Capture d'écran de certains scénarios ci-dessous).

---

¹ dyce est ma bibliothèque de probabilités de dés en Python.

² anydyce est ma couche de visualisation pour dyce est un substitut approximatif d'AnyDice.

---

Answer 2

Donc, si je comprends bien votre mécanicien :

1. Vous roulez X d6. Le résultat le plus élevé de ce jet est M et que le nombre de fois où ce résultat apparaît dans le rouleau soit N . (Ainsi, nous avons toujours 1 ≤ M ≤ 6 et 1 ≤ N ≤ X .)

   Exemples (avec le rouleau le plus élevé et ses correspondances dans audacieux ) :

   Rouleau

   Résultats

   M

   N

   3d6

   1, 2, 3

   3

   1

   3d6

   1, 3 , 3

   3

   2

   3d6

   3 , 3 , 3

   3

   3

   3d6

   3, 3, 4

   4

   1

   3d6

   2, 3, 4

   4

   1

   6d6

   1, 2, 3, 4, 5, 6

   6

   1

   6d6

   6 , 6 , 6 , 6 , 6 , 6

   6

   6

2. Vous lancez ensuite deux dés de défi (tous deux d6). Soit le résultat le plus bas obtenu avec ces dés L et le plus élevé H . (Ainsi, nous avons toujours 1 ≤ L ≤ H ≤ 6.)

3. Vous comptez les succès comme suit :

   • Si M > L , comptez un succès.
   • Si M > H Le succès s'ajoute au premier.
   • Si M \= H \= L y N > 2, ajouter un supplément N - 2 succès (un pour chacun des N correspondance des dés H moins les deux utilisés pour "annuler" H y L ).
   • Si M \= H > L y N > 1, ajouter un supplément N - 1 succès (un pour chacun des N correspondance des dés H moins celle utilisée pour "annuler" H ).

   (Ces deux derniers cas étant la "règle supplémentaire" que vous ne savez pas comment mettre en œuvre dans AnyDice).

---

Une fois tout cela écrit, nous pouvons le traduire assez directement en code AnyDice :

function: roll ROLL:s vs CHALLENGE:s {
  M: 1@ROLL
  N: M = ROLL
  H: 1@CHALLENGE
  L: 2@CHALLENGE

  S: (M > L) + (M > H)
  if M = H & H = L & N > 2 { S: S + N - 2 }
  if M = H & H > L & N > 1 { S: S + N - 1 }
  result: S
}

loop X over {1..6} {
  output [roll Xd6 vs 2d6] named "[X]d6"
}

En résultat de ce programme ressemble à ceci (en mode graphique) :

---

Ps. Voici une version un peu plus générale de la fonction ci-dessus qui prend en charge un nombre arbitraire de dés de défi au lieu de deux seulement :

function: roll ROLL:s vs CHALLENGE:s {
  MAX: 1@ROLL
  S: MAX > CHALLENGE
  if MAX = 1@CHALLENGE {
    S: S + [highest of 0 and (MAX = ROLL) - (MAX = CHALLENGE)]
  }
  result: S
}

Ici, MAX > CHALLENGE compte les succès de la mécanique "de base" (c'est-à-dire un succès pour chaque dé de défi inférieur à votre plus haut jet), tandis que le code à l'intérieur de l'élément if met en œuvre votre "règle supplémentaire" qui ajoute des succès supplémentaires si votre plus haut jet correspond au plus haut dé de défi et apparaît plus de fois dans vos jets que dans le dé de défi.

(Le [highest of 0 and ...] est utilisée pour s'assurer que nous n'ajoutons jamais de succès négatifs si, par exemple, vous obtenez 1, 2, 6 contre un défi de 6, 6 !)

Par exemple, Voici à quoi ressemble la sortie avec trois dés de défi au lieu de deux :