Help with custom success-based task resolution system, d12r[8,9], successes => 10, critical success and explosion on 12, triples if three matching numbers

[Punished-Steak]

I'm trying to calculate the odds for a homebrew roleplaying system that I made. It uses a success-based resolution system. A d12 is rolled, any eights or nines are rerolled, and any twelves explode. Tens and elevens each count as one success, while twelves count as two. If the dice pool has any 3 of the same number, the amount of successes is tripled at the end of rolling.

I have made my main roller, equivalent to roll20's syntax of d12r8r9!s>9c=12:

def combined(h: H, limit=5) -> H:
    @expandable(sentinel=h)
    def _expand(h_result: HResult):
        if h_result.outcome == max(h_result.h):
            return _expand(h_result.h) + 2
        elif h_result.outcome in [8,9]:
            return _expand(h_result.h)
        elif h_result.outcome in [10,11]:
            return 1
        else:
            return 0
    return _expand(h, limit=limit)

>>> (3@(combined(H(12)))).format(width=0)

CONSOLE: '{avg: 1.35, 0: 34.29%, 1: 29.39%, 2: 18.65%, 3:  9.59%, 4:  4.53%, 5:  1.98%, 6:  0.82%, 7:  0.34%, 8:  0.14%, 9:  0.06%, 10:  0.04%, 11:  0.03%, 12:  0.03%, 13:  0.02%, 14:  0.02%, 15:  0.02%, 16:  0.02%, 17:  0.01%, 18:  0.01%, etc....}'

And I have made my function that checks dice pools for triples.

critical = False      #built in this variable but not sure what to actually do with it.
def triplets(result: PResult):
    #n = 3
    for i in range(2,len(result.roll)):
        if result.roll[i] == result.roll[i-1] == result.roll[i-2]:
            #print("crit") this was for debugging, but it blasted through my screen with a gorillion prints because idk what im doing lol
            critical = True
            return True
            #n -= 1
        else:
            #print("not crit")
            critical = False
            return False

>>> r_3d12 = foreach(triplets, result=3@P(12))
>>> r_3d12

CONSOLE: H({False: 143, True: 1})

However, I cannot figure out how to combine these, so that a number of dice are rolled via the first function "combined()," and the results be checked by the second function "triplets()". If anyone has any advice, I'd appreciate it.

[posita]

This should be quite doable, but I have a question first: Are all 8s and 9s re-rolled, even when there are three (or more) of them?

[Punished-Steak]

Yes, 8s and 9s are always re-rolled. They never actually show.

[posita]

UPDATE: I made some minor tweaks/corrections to this after posting it.

Brilliant! If we're always re-rolling eights and nines, what we're effectively doing is pretending they don't exist. This is easy to capture at the outset by creating a die without those outcomes. We can do that manually at creation time (e.g., d = H((1, 2, 3, 4, 5, 6, 7, 10, 11, 12))). Alternatively (as of dyce~=0.6.2), we can use the H.draw convenience method to strip them out of a d12 (e.g., d = H(12).draw((8, 9)). This is closer to what's intended, because @expandable only allows for an approximation for infinitesimally small probabilities (as you can see by 8 and 9 continuing to appear in your results). Not only that, but careful die construction also allows us to simplify the mechanic code somewhat.

The rest is a little trickier, since (based on my understanding) you've got exploding dice whose re-rolls then contribute to the overall pool. In other words, successes aren't truly countable until you've finished exploding (and re-exploding) your eligible outcomes. For example, consider an initial roll of (2, 2, 12). So far, we've got two successes, but we're not done yet. Let's say on re-rolling that twelve, we get another twelve. We now have four successes and still aren't done. Let's say we re-roll that second twelve and get a two. We now have three twos which triples our success tally (i.e., a "final" roll of something that amounts to (2, 2, 2, 12, 12)).

Assuming I haven't screwed things up horribly, this is definitely doable, but requires a bit of nuance. The reason for this is that we have to construct our mechanic to accumulate the entire (fully exploded) roll before we can make a call on the final tally. dyce's current built-in recursion mechanisms assume a return of either a value or a histogram (i.e., an H object), but not a roll (typically a sequence of outcomes), so we have to get a little creative, at least for now. (As an aside, I'm wrestling with how dyce can be more flexible in the future.)

Here's one solution:

from dyce import H, P
from dyce.evaluation import LimitT, PResult, expandable
from numerary import RealLike
from collections import Counter
from fractions import Fraction

# These are probably more flexible that what you need, but make tweaking the die type
# easier, if that's desirable
d12_ish = H(12).draw((8, 9)).lowest_terms()
d12_ish_these_explode: set[RealLike] = {12}
d12_ish_outcomes_to_successes_map: dict[RealLike, int] = {10: 1, 11: 1, 12: 2}

def tally_successes(
    final_roll: tuple[RealLike, ...],
    outcomes_to_successes_map: dict[RealLike, int],
    multiple_triples: bool = False,
):
    r"""
    Returns the number of successes found in *final_roll*. This implementation does
    ***not*** require *final_roll* to be sorted. *outcomes_to_successes_map* is a
    mapping of outcomes to scalars used to compute the success tally. For example if
    *outcomes_to_successes_map* is ``{3: 1, 6: 3}``, each ``3`` in *final_roll* would
    count as one success, and each ``6`` would count as three successes.

    *multiple_triples* defaults to ``False``, which means only a single tripling is
    possible. If it is ``True``, each distinct group of three similar outcomes will
    triple the result. For example, if *final_roll* is ``(2, 2, 2, 2, 2, 2, 2, 3, 3, 3,
    3, 10)``, there are three triples (one for the first three ``2``s, another for the
    second three ``2``s, and a third for the three ``3``s). (The left-over ``2`` and
    ``3`` have no effect.)
    """
    counts = Counter(final_roll)
    if multiple_triples:
        exponent = sum(count // 3 for count in counts.values())
    else:
        exponent = any(count >= 3 for count in counts.values())
    # If we care about floating point outcomes, we would likely have to refactor this to
    # use math.isclose for determining whether our roll's outcomes appear in
    # outcomes_to_successes_map
    return (
        sum(
            counts[outcome] * scalar
            for outcome, scalar in outcomes_to_successes_map.items()
        )
        * 3**exponent
    )

def homebrew(
    pool_size: int,
    pool_die: H = d12_ish,
    these_explode: set[RealLike] = d12_ish_these_explode,
    outcomes_to_successes_map: dict[RealLike, int] = d12_ish_outcomes_to_successes_map,
    multiple_triples: bool = False,
    explode_limit: LimitT = Fraction(1, 1_000_000),
) -> H:
    r"""
    Expresses our homebrew mechanic and computes outcomes. *pool_size* and *pool_die*
    are used to construct a homogeneous pool for use with the mechanic. *these_explode*
    are used to indicate which outcomes should explode if re-rolled. It's possible we
    could modify this to support heterogeneous pools (e.g., a d6, d8, and d12), but we
    would likely need to revisit how we track and explode rolls and how we compute
    successes from different die types.

    *outcomes_to_successes_map* and *multiple_triples* are passed to ``tally_successes``
    once a final roll is achieved. *explode_limit* is passed to our recursive function.
    """
    p = pool_size @ P(pool_die)
    exploding_cut_short_sentinel = H({})

    def _wrapper(p: P, roll_so_far: tuple[RealLike, ...]) -> H:
        r"""
        This wrapper is here solely to allow us to pass down *roll_so_far* to
        *_explode_then_tally*.
        """

        @expandable(sentinel=exploding_cut_short_sentinel)
        def _explode_then_tally(new_result: PResult) -> Union[H, int]:
            r"""
            Our real mechanic implementation.
            """
            more_explosions = sum(
                1 for outcome in new_result.roll if outcome in these_explode
            )
            updated_roll_so_far = roll_so_far + new_result.roll
            if more_explosions:
                # Update our roll so far and keep going
                res = _wrapper(more_explosions @ P(pool_die), updated_roll_so_far)
                if res != exploding_cut_short_sentinel:
                    # We got a final tally from somewhere below, so just pass that up
                    return res
            # We can be here either if we had nothing more to explode, or if we hit our
            # explosion limit, so treat the newly assembled roll as the final one, and
            # compute and return the number of successes
            return tally_successes(
                updated_roll_so_far,
                outcomes_to_successes_map,
                multiple_triples=multiple_triples,
            )

        return _explode_then_tally(p, limit=explode_limit)

    return _wrapper(p, ())

☝️ That may appear like a lot, but if we strip the commentary away, the actual code is pretty tight. Now we get:

>>> print(homebrew(3).format(scaled=True))
avg |    1.48
std |    2.33
var |    5.45
  0 |  34.30% |##################################################
  1 |  29.40% |##########################################
  2 |  18.48% |##########################
  3 |   9.42% |#############
  4 |   4.54% |######
  5 |   1.94% |##
  6 |   0.71% |#
  7 |   0.04% |
  9 |   0.20% |
 12 |   0.04% |
 15 |   0.06% |
 18 |   0.34% |
 21 |   0.31% |
 24 |   0.14% |
 27 |   0.05% |
 30 |   0.02% |
 33 |   0.01% |
 36 |   0.00% |
 39 |   0.00% |
 42 |   0.00% |
 45 |   0.00% |

☝️ That passes the sniff test with respect to the zero successes count, since it should effectively be the same as rolling three d10s and counting eights and higher as successes:

>>> h = 3 @ H(10).ge(8)
>>> print(h.format(scaled=True))
avg |    0.90
std |    0.79
var |    0.63
  0 |  34.30% |######################################
  1 |  44.10% |##################################################
  2 |  18.90% |#####################
  3 |   2.70% |###

I introduced a concept above of allowing for more than one tripling of successes if more than one group of three similar outcomes appeared. However, in my testing with small pools, this doesn't make any significant difference, so any code above that deals with multiple_triples can likely be safely ignored or removed.

The above implementation allows for arbitrary exploding values (via the these_explode parameter). However, that may be unnecessarily flexible. If you're committed to only exploding on the max value of the die, we might be able to do something like your original approach and compute the exploded die first, then use some math tricks to figure out successes after-the-fact. Note, this optimization only works if our die's outcomes are all positive and we're exploding the max outcome. (As I alluded to in my comment in tally_successes above, one also has to be a little careful when using floating point values for die outcomes, but that likely doesn't apply to you.)

from dyce.evaluation import explode, foreach
from typing import Iterator

def optimized_homebrew(
    pool_size: int,
    pool_die: H = d12_ish,
    outcomes_to_successes_map: dict[RealLike, int] = d12_ish_outcomes_to_successes_map,
    explode_limit: LimitT = Fraction(1, 100),
) -> H:
    assert min(pool_die) >= 1  # this only works for dice with positive outcomes
    exploded_die = explode(pool_die, limit=explode_limit)
    p = pool_size @ P(exploded_die)

    def _infer_actual_roll_gen(roll: tuple[RealLike, ...]) -> Iterator[RealLike]:
        max_val = max(pool_die)
        for outcome in roll:
            if outcome > max_val:  # this outcome has exploded at some point
                total_explosions = outcome // max_val
                any_leftover_outcome = outcome % max_val
                yield from (max_val,) * total_explosions
                if any_leftover_outcome:
                    yield any_leftover_outcome
            else:
                yield outcome

    def _infer_actual_roll_and_tally(result: PResult) -> int:
        actual_roll = tuple(_infer_actual_roll_gen(result.roll))
        return tally_successes(actual_roll, outcomes_to_successes_map)

    return foreach(_infer_actual_roll_and_tally, p)

For reasons that deal with dyce's internal implementation details, explode_limit doesn't mean quite the same thing across those implementations. However, they can be compared with carefully selected values for that parameter:

>>> explode_limit = 4
>>> homebrew(3, explode_limit=explode_limit + 1) == optimized_homebrew(3, explode_limit=explode_limit)
True
>>> explode_limit = 1
>>> homebrew(5, explode_limit=explode_limit + 1) == optimized_homebrew(5, explode_limit=explode_limit)
True

While still geometric, optimized_homebrew is computationally less intensive than our first attempt.

In [2]: %timeit homebrew(3, explode_limit=4)
93.3 ms ± 1.66 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [3]: %timeit optimized_homebrew(3, explode_limit=3)
69.2 ms ± 2.01 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [4]: %timeit homebrew(5, explode_limit=3)
5.33 s ± 285 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [5]: %timeit optimized_homebrew(5, explode_limit=2)
1.64 s ± 29.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Regarding my observation above about the similarity between a d10 and our d12 with eights and nines stripped out, we can verify that your mechanic is equivalent to using d10s without any re-rolling, and treating eights and nines as one success and tens as two (which might help if your players have more d10s than d12s):

>>> d10 = H(10)
>>> homebrew(3) == homebrew(3, d10, these_explode={10}, outcomes_to_successes_map={8: 1, 9: 1, 10: 2})
True
>>> optimized_homebrew(3) == optimized_homebrew(3, d10, outcomes_to_successes_map={8: 1, 9: 1, 10: 2})
True

I hope that helps! Please let me know if I misconstrued anything. I'll try and clean all this up, add some tests, and produce an interactive notebook soon.

[posita]

I packaged up a version of the above into a Jupyter notebook you can play around with here:

Please let me know if I missed anything or if you have questions! 😊