D10 Additive Dicepool Vs DIe Target Number DIce Tallying Mechanic Icepool help.

[wmrobmuadib]

Hello, I have a dice mechanic with many moving parts I am looking for help in handling via the icepool library.

the basic app I have
AdditiveD10DicepoolVsDTNBonusDIce-ManualEvaluation-MistralSmall.md

here is the lengthy and dense writeup of how it all fits together and works.
DIceMechanicSpecificiations.txt

WHat I am hoping to get help on is using icepool to generate cumulative odds and also make the determinaton of the boosts/.spoiled dicepool and dice results much more efficient. Also to include the results of the match pair for postive/negative matches, and boons and banes.

It is complicated, so if you are able I would truly appreicate your help, I am still a python novice. so I didn't grok your icepool writeups very well.

Thanks for your time and any assistance you can offer.

[HighDiceRoller]

I may be able to help with the probability part. First, some questions:

• If a Burst is rolled on a d20, does it produce a d10 or a d20?
• Are bonus dice from Burst counted towards matches?
• Do you need the joint distribution of check totals and matches, or just the marginal distributions of each?
• How large are dice pools anticipated to get?

[wmrobmuadib]

Bonus dice from a burst are always a D10, regardless of source. SO a D20 spawns a d10 bonus die as well.
Bonus dice from bursts are counted for matches. Only boost/spoiler dice are removed the dicepool. without spawning any bonus dice. ONly after the dicepool is fixed do yuo evaluate for burst.
Marginal DIstributions shoudl be fine.
THe largest possible dicepool would be 15 D10 with up to 10 boost/spoiler dice.

[HighDiceRoller]

In terms of the total, here's one way to do it:

from icepool import d, vectorize, Die

def make_initial_die(x, dtn):
    number = x if x <= dtn else 0
    bonus = (x == dtn)
    return vectorize(number, bonus)

def compute_initial(dtn, stat, boost):
    if stat % 2:
        return Die([compute_initial(dtn, stat + 1, boost),
                    compute_initial(dtn, stat - 1, boost)])
    n = stat // 2
    die = d(10).map(make_initial_die, dtn)
    if boost > 0:
        initial = die.highest(n + boost, keep=n)
    else:
        initial = die.lowest(n - boost, keep=n)
    return initial

def compute_final(total, bonus, dtn):
    bonus_die = d(10).map(lambda x: x if x <= dtn else 0).explode(depth=1)
    return total + bonus @ bonus_die

def compute_all(dtn, stat, boost):
    return compute_initial(dtn, stat, boost).map(compute_final, dtn)

output(compute_all(6, 10, 1))

You can try this in your browser here.

Here compute_initial determines the total of the rolls not resulting from bonus dice and the number of bonus dice to roll, and compute_final determines the final total. Spoiler is represented by negative boost.

Here I treated the d20 as 50% chance of rolling 1-10 (and thus conditionally equivalent to a d10) and 50% chance of rolling 11-20 (which above is treated as not existing at all). But this brings up a question: if we roll 11-20 on the d20, and we also have boost, does the d20 still consume a boost die removal -- and thus we get to keep one more of the d10s -- so the presence of the d20 matters even if it rolls 11-20?

Another question: if we have boost, how do we choose which bust dice to remove if there are more busts than boosts? This can slightly affect the distribution (though not mean) of matches. For example, suppose we need to remove one of 7, 7, and 8. If we remove the 8 then we are relatively more likely to get 0 or 2 matches. If we remove one of the 7s, then we are relatively more likely to get 1 match.

[wmrobmuadib]

Good questions on the D20 and remove 8s. The D20 definitely counts as one of your dice for boost removal. So it will preserve a D10. WHich makes a match more likely. I would say to remove descending order when choosing bust dice. Highest BUst dice first, or tied for highest), then next highest, etc. Down to DTN+1. This is reverse of the SPoiler dice, which removes dice in ascending order., DTN+1 up to Max on die.

Thanks for your help on this, It is too heavy for Troll or anydice to work within the 25 second limit. The computation time is so short with icepool, it is amazing. a little over 2 seconds for stat of 30 (15 dice) with 10 boost dice on my machine.

[HighDiceRoller]

Alright, now we can look at the matches.

from icepool import d, multiset_function, Die

def compute_initial(dtn, matchn, stat, boost):
    if stat % 2:
        if boost > 0:
            return Die([compute_initial(dtn, matchn, stat + 1, boost),
                        compute_initial(dtn, matchn, stat + 1, boost - 1)])
        else:
            return Die([compute_initial(dtn, matchn, stat + 1, boost),
                        compute_initial(dtn, matchn, stat - 1, boost)])
    n = stat // 2
    die = d(10).map(lambda x: x if x <= dtn else -x)
    if boost >= 0:
        pool = die.pool(n + boost).highest(n)
    else:
        pool = die.pool(n - boost).lowest(n)
    @multiset_function
    def matches_and_burst(rolls):
        return rolls.keep_outcomes([matchn, -matchn]).count(), rolls.keep_outcomes([dtn]).count()
    return matches_and_burst(pool)

def compute_final(matches, bonus, dtn, matchn):
    if dtn == matchn:
        bonus_die = (d(10) == 1).explode(depth=1)
    else:
        bonus_die = (d(9) == 1)
    return matches + bonus @ bonus_die

def compute_all(dtn, stat, boost):
    def inner(matchn):
        return compute_initial(dtn, matchn, stat, boost).map(compute_final, dtn, matchn)
    return d(10).map(inner)

output(compute_all(6, 10, 1))

You can try this in your browser here.

We negate the bust numbers so that highest will remove them first and lowest last.

When not explicitly using Pools, some functions/methods such as highest and lowest implicitly take the sum of the selected dice. However, this time we're interested in the number of matches rather than the sum, so here we create a pool and feed it to an @multiset_function to compute the number of matches and bonus dice in the initial pool. Avoiding computing the sum saves quite a bit of computational cost.

As for the bonus dice, if the match number is not equal to DTN, each bonus die will eventually end on one of the non-DTN numbers uniformly at random, so there is a flat 1 in 9 chance of each landing on the match number. If the match number is equal to DTN then the number of matches is equal to the number of additional bonus dice generated, here limited to a depth of 1 to make things easier and not make the x-axis too long.

Finally we evaluate the whole thing for each possible match number.

---

@multiset_function could also be used to compute the distribution of the check total. Here's how that alternative implementation to summing Vectors could look like:

from icepool import d, multiset_function, Die

def compute_initial(dtn, stat, boost):
    if stat % 2:
        if boost > 0:
            return Die([compute_initial(dtn, stat + 1, boost),
                        compute_initial(dtn, stat + 1, boost - 1)])
        else:
            return Die([compute_initial(dtn, stat + 1, boost),
                        compute_initial(dtn, stat - 1, boost)])
    n = stat // 2
    die = d(10).map(lambda x: x if x <= dtn else 0)
    if boost >= 0:
        pool = die.pool(n + boost).highest(n)
    else:
        pool = die.pool(n - boost).lowest(n)
    @multiset_function
    def total_and_burst(rolls):
        return rolls.sum(), rolls.keep_outcomes([dtn]).count()
    return total_and_burst(pool)

def compute_final(total, bonus, dtn):
    bonus_die = d(10).map(lambda x: x if x <= dtn else 0).explode(depth=1)
    return total + bonus @ bonus_die

def compute_all(dtn, stat, boost):
    return compute_initial(dtn, stat, boost).map(compute_final, dtn)

output(compute_all(6, 10, 1))

In both cases of this post I've also adjusted for the d20-boost interaction discussed earlier.

[wmrobmuadib]

Thanks for your help. I appreciate it.