Il es Il est possible de calculer ces résultats de manière efficace en utilisant AnyDice. Ce n'est tout simplement pas très facile ou intuitif.
Tout d'abord, cette version optimisée de Code de Carcer fonctionne bien jusqu'à 5d6 contre 5d6, mais ne fonctionne pas pour des pools plus importants :
function: neon city overdrive ACTION:s DANGER:s {
BOON: (ACTION = 6) - (DANGER = 6)
if BOON > 0 { result: 5 + BOON }
loop N over {5,4,3,2,1} {
if (ACTION = N) > (DANGER = N) { result: N }
}
result: 0
}
output [neon city overdrive 5d6 5d6]
Tout ce que j'ai fait pour accélérer le code de Carcer, c'est de remplacer les appels à la fonction intégrée [count N in SEQ] avec la fonction (SEQ = N) qui fait la même chose mais un peu plus rapidement. Il est certainement possible de micro-optimiser davantage le code par exemple en déroulant la boucle et en revenant plus tôt si le jet d'action le plus élevé n'est pas annulé, mais aucune de ces optimisations n'aide à franchir la barrière 5d6 contre 5d6. Avec plus de 10 dés au total, il y a trop de combinaisons pour les énumérer.
En général, la meilleure façon de faire en sorte que le code d'AnyDice gère plus rapidement les grands ensembles de dés est de ré-étiqueter les dés pour fusionner les faces équivalentes, afin qu'AnyDice ne perde pas de temps à tester un trop grand nombre de jets équivalents possibles. Par exemple, si vous voulez calculer le nombre de jets atteignant ou dépassant un certain seuil 1 T 6 en N d6, puis Nd(d6 >= T) est un lot plus rapide que [count {T..6} in Nd6] . En général, ce type d'optimisation fonctionne très bien dans toutes les situations où, si l'on lance un dé physiquement, on divise les dés obtenus en quelques groupes grossiers (comme "au moins T "et "en dessous T ") et comptez le nombre de dés dans chaque groupe, ou mettez de côté certains des dés lancés comme "ceux-là n'ont pas d'importance". Mais il n'y a pas de moyen évident d'appliquer ce type d'optimisation ici, puisque tous les jets de dés potentiellement si tous les autres sont annulés.
ou existe-t-il ?
N'oubliez pas que les petits jets n'ont d'importance que dans le cadre de ce mécanisme si tous les jets de dé d'action supérieure ont été annulés. Imaginons donc que nous lancions les dés et que nous les comptions pas à pas, comme suit :
-
Divisez les dés roulés en deux groupes : "six" et "tout ce qui est inférieur à six". Si le groupe "six" contient plus de dés d'action que de dés de danger, arrêtez : le résultat est de 6 (plus des points d'orgue égaux au nombre de six non annulés moins un).
-
Sinon, mettez de côté tous les six et divisez le reste des dés en deux groupes : "cinq" et "tout ce qui est inférieur à cinq". Si le groupe "cinq" contient plus de dés d'action que de dés de danger, arrêtez : le résultat est 5.
-
Sinon, mettez de côté tous les cinq et divisez le reste des dés en deux groupes : "quatre" et "tout ce qui est inférieur à quatre". Si le groupe "quatre" contient plus de dés d'action que de dés de danger, arrêtez : le résultat est 4.
et ainsi de suite jusqu'à ce que, finalement, si tous les dés ayant obtenu un résultat de 2 ou plus ont été annulés, nous finissons par comparer simplement le nombre de dés d'action et de dés de danger restants pour déterminer si le résultat est 1 ou 0.
La caractéristique importante de ce processus est la suivante, à chaque étape les nombres réels lancés sur les dés dans le "tout ci-dessous N "n'ont pas d'importance - ils sont tous équivalents. En fait, nous pourrions relancer tous les dés du groupe "tout ce qui est inférieur à". N "après chaque étape (en s'assurant que tous les rerolls sont toujours inférieurs à la valeur de N ) et la répartition des résultats ne changerait pas.
Ou, si nous voulions vraiment être bizarres, nous pourrions commencer par lancer un tas de dés à six faces personnalisés avec toutes les faces sauf 6 vierges .
Ensuite, après la première étape ci-dessus, nous pourrions remplacer tous les rouleaux vierges par des rouleaux personnalisés. à cinq côtés un dé, dont toutes les faces sauf 5 sont vierges, lancez ce dé et passez à la deuxième étape.
Et si la deuxième étape ne donnait pas non plus de résultat, nous pourrions remplacer les rouleaux vierges par des rouleaux personnalisés. quadruple face un dé, dont toutes les faces sauf 4 sont vierges, lancez ce dé, et ainsi de suite
Évidemment, ce serait une façon vraiment bizarre et inefficace de lancer les dés à la table. Mais c'est une façon très efficace de le faire dans AnyDice, puisque cela signifie que, par exemple, pour les jets qui contiennent un ou plusieurs six non annulés, nous n'avons pas besoin de considérer toutes les combinaisons possibles de jets inférieurs.
Il suffit de écrire une fonction d'aide qui s'appelle elle-même récursivement :
function: nco helper N:n AMAX:n DMAX:n AROLL:n DROLL:n {
if AROLL > DROLL {
if N = 6 { result: 5 + AROLL - DROLL }
result: N
}
A: AMAX - AROLL
D: DMAX - DROLL
if N = 2 { result: A > D }
X: d(N-1) = N-1
result: [nco helper N-1 A D AdX DdX]
}
function: nco A:n D:n {
X: d6 = 6
result: [nco helper 6 A D AdX DdX]
}
loop A over {6} {
loop D over {0..6} {
output [nco A D] named "action [A]d6, danger [D]d6"
}
}
Dans le code ci-dessus, N est le résultat le plus élevé possible à l'étape actuelle (initialement 6), et donc aussi le nombre que nous retournerons comme résultat si nous trouvons un jet d'action non annulé à cette étape (avec le nombre de boons ajoutés au résultat si N = 6 ). AMAX y DMAX sont les nombres totaux de dés d'action et de dés de danger restants à cette étape, respectivement, tandis que AROLL y DROLL sont les numéros des dés qui ont été lancés N .
La fonction d'aide compare d'abord AROLL y DROLL Si le premier est plus grand, nous avons trouvé un jet d'action non annulé et nous nous arrêtons. Sinon, il calcule le nombre de jets d'action et de danger restants, A y B et construit un N-1 matrice à deux faces X avec un côté hors de N numéroté 1 et le reste numéroté 0. Cela donne AdX correspondent à la distribution du nombre de N-1 roule dans une piscine de A dés avec N-1 de chaque côté, et de la même manière pour DdX ; ces rouleaux sont ensuite transmis de manière récursive à une autre instance de la fonction d'aide en tant que AROLL y DROLL AnyDice évalue alors l'appel récursif pour chaque combinaison possible de ces jets.
Les boucles situées en bas du code appellent la fonction [nco A D] pour des nombres variables de dés d'action et de dés de danger, et affiche les résultats. Par défaut, le code utilise 6 dés d'action et une plage de dés de danger de 0 à 6, mais vous pouvez bien sûr modifier les plages de boucles comme vous le souhaitez. Le résultat par défaut, représenté sous forme de graphique, ressemble à ceci :
![AnyDice screenshot]()
Au fait, à quel point cette solution récursive est-elle plus rapide ? Eh bien, d'après quelques tests, elle fonctionne bien jusqu'à 7d6 contre 7d6, mais s'arrête pour 8d6 contre 8d6. Ce qui n'est pas si mal, étant donné que le nombre de combinaisons possibles augmente exponentiellement avec le nombre de dés. (Cela pourrait être rendu beaucoup plus rapide si AnyDice supportait mémorisation mais hélas, ce n'est pas le cas). En tout cas, c'est au moins plus que suffisant pour répondre à l'exigence de l'OP de "jusqu'à 5 ou 6 dés dans chaque pool".
