Variable target numbers

[jllancaster]

Hi there, wondering if I might be able to get some help here. I am trying to figure out how to code up a mechanic with variable target numbers for the dice pool, but my feeble brain could use some tips on getting started.

1. Roll a pool of 2d6, and a pool of 6d6.
2. Drop lowest or highest from 2d6 pool.
3. Every result in the 6d6 pool that is greater than or equal to the remaining die in the 2d6 pool is considered a success; however, 1s always count as zero successes, and 6s always count as 2 successes.

Thank you very much!

I've made it this far:

from icepool import d6

# drop highest (advantage)
target = d6.pool(2)[-1:]

# Remember, since we are dealing with multisets here, the `>=` operator means `issuperset`.
@multiset_function
def var_target(a):
    return a >= target

print(var_target(d6.pool(6)))

[HighDiceRoller]

Happy to get your message! In this case it's easiest to use the @map_function decorator, which runs a function over all outcomes of dice and all tuples-of-outcomes of pools.

from icepool import d6, map_function

@map_function
def var_target(pool, target):
    target = max(target, 2)
    return sum(x >= target for x in pool) + pool.count(6)

output(var_target(d6.pool(6), d6.highest(2, 1)))

You can try this in your browser here.

[jllancaster]

Thank you so much! That is a much-much faster solution than what I posted. Really appreciate it.

[HighDiceRoller]

Ah right, the efficiency aspect. The @map_function interface is relatively easy to use, but since it expands pools into all possible sorted sequences, it is often not the most efficient approach. An even faster but slightly more complex alternative would be to only map one variable at a time, and furthermore compute the result of a single pool die and use the @ operator rather than doing a full pool expansion:

from icepool import d6

def var_target(pool_size, target):
    def inner(target):
        pool_die = d6.map(lambda x: (x == 6) + (x >= max(2, target)))
        return pool_size @ pool_die
    return target.map(inner)

output(var_target(6, d6.highest(2, 1)))

[jllancaster]

Hi there, I am wondering how I might capture the number of successes from var_target(), and use that for the number of dice rolled for the opposed roll?

from icepool import d6, map_function

@map_function
def var_target(pool, target):
    target = max(target, 2)
    return sum(x >= target for x in pool) + pool.count(6)

# If opposition only gets one success on a 6.
output(var_target(d6.pool(6), d6) - 6 @ (d6 >= 3))

Thanks!

[HighDiceRoller]

var_target(d6.pool(6), d6) is the number of initial hits; in this case, the opponent has a chance to block each such hit with a 3+ (or whatever), similar to armour saves in Warhammer. We can use the @ operator again, which means "roll the left side, then roll that many of the right side and sum". For the right side we can use chance of not saving each hit:

from icepool import d6, map_function

@map_function
def var_target(pool, target):
    target = max(target, 2)
    return sum(x >= target for x in pool) + pool.count(6)

output(var_target(d6.pool(6), d6) @ (d6 < 3))

[jllancaster]

That is pretty slick, thank you so much!