You have X charges left. Rolling a d6 equal or over the number of charges left depletes a charge. How many uses do you get out of a starting X charges?
e.g. 1 charge, 1 use left. 2 charges, rolling 2 or more depletes a charge.
[RPG] Modelling “rolling d6 >= charges left expends a charge” mechanics with anydice
anydicestatistics
Related Solutions
{2..4}@6d6
"... Teach a man to fish, ..."
In the documentation, section Introspection, the @ operator is described as the "access" operator:
you can retrieve individual numbers stored inside a value. You can either provide the position of a single value to retrieve, or a sequence of positions, in which case the retrieved values are summed.
6d6 is a "collection of dice", and in that subsection it says:
When accessing collection of dice, the dice will be order from highest value to lowest value. So 1@3d6 will select the highest rolled value, while 3@3d6 will select the lowest rolled value. {1,2}@3d6 will sum the highest two of the rolled values, discarding the lowest rolled value.
That means to achieve what you have described, you can write {2,3,4}@6d6, which means: "drop the highest result, sum the 2nd, 3rd and 4th highest values and discard the rest."
However...
... doing this and comparing it with {1,2,3}@4d6 (4d6 drop lowest), you will find that the average result is a good bit lower, while being only marginally tighter:
Here, use this code:
set "position order" to "lowest first"
function: roll R:s reroll N {
A: 0
loop I over {1..N}{
if I@R = -1 {
A: A + 1 + d{-1, 0, 1}
}
}
result: R + A
}
output [roll 4d{-1, 0, 1} reroll 1]
This code creates a function where the initial fudge dice are turned into a sequence. This means every possible roll is evaluated. For any one roll we check the N lower dice and if it's a -1 we "reroll" it. The hack to emulate the reroll is to add 1 cancling the old value, then adding d{-1, 0, 1}. This hack value is added to A which is added at the end.
Best Answer
Here's an alternative, more "procedural" AnyDice solution:
It relies on the same recurrence as Hypergardens' answer, i.e. that $$N_k - N_{k-1} = 1 + X_k,$$ where the random variable \$N_k\$ denotes the number of uses with \$k\$ charges left, and \$X_k\$ is a (zero-based) geometrically distributed random variable with parameter \$p = \frac{k-1}6\$ (approximated in AnyDice with
[explode d6 < K]) denoting the number of uses before the current charge will be expended. The difference is that, whereas Hypergardens' solution computes \$N_k\$ on demand for any given \$k\$ using a recursive function, my code starts with with \$N_0 = 0\$ and iteratively computes \$N_k\$ for successive values of \$k\$.Which program is better? Honestly, that's mostly a matter of taste. My solution is likely to be slightly faster, at least if you want to compute \$N_k\$ for all values of \$k\$ in one run, but in practice both are more than fast enough, and Hypergardens' recursive solution is arguably more flexible. In any case, the both give the same results (at least if you use the same explode depth and output cutoff).