## Never Stop Blowing Up's Dice System

So I decided to do some math & coding this morning. I was curious on the distribution of numbers for the exploding dice system used in Dropout's new actual play series: Never Stop Blowing Up

They are using a system built on the Kids on Bikes system, modified to serve the game's theming. The main difference (based on what we've seen) is the dice rolling system.

For Kids on Bikes, you roll the same die when it explodes. For Never Stop, you start with a D4, then on a max roll, you roll again on the next sized dice (D4->D6->D8->D10->D12->D20) adding the combined values of rolls. Roll 1, 2, 3 that's what you get, on a 4, you add 1d6, etc

There's a few more details to what Never Stop is doing, like that it makes it quasi-leveling for the players. Once you explode to a d6, that is now your starting dice roll on that stat, etc. I'm not taking that into consideration for this morning's exploration on the math.

So, looking at every roll beginning with a D4, you have a 25% chance on rolling 1, 2 or 3. Then the remaining 25% chance gets distributed across exploding rolls.

% | Range |
---|---|

25% | 1-3 |

4.17% | 5-9 |

0.52% | 11-17 |

0.05% | 19-27 |

0.04% | 29-39 |

0.002% | 41-60 |

You can never roll a 4, 10 (4+6), 18 (4+6+8), 28 (4+6+8+10), 40 (4...12) because those are the threshold numbers an you always add at least 1 to those numbers. This essentially means that everything after these thresholds uses that slot's percentage.

So with 1d4, you have a 25% chance of getting a 4. But since there is no 4, the remaining range of numbers all occupy that 25%. Adding the 1d6 means that you have 25%/6 on each possible roll, except on a 6, that is the percentile chance of the 1d8, etc.

So that's the part I logicked through the math of without any code or simulation. I decided to code a Python script to do large number simulations to see how many times I would roll each number.

```
from random import randint
dice = [4, 6, 8, 10, 12, 20]
def roll(sides):
r = randint(1,sides)
if r == sides and r < 20:
n = dice.index(sides) + 1
return r + roll(dice[n])
return r
def batchroll():
rolls = []
for i in range(10000):
rolls.append(roll(4))
out = ""
for i in range(1,61):
out = out + str(rolls.count(i)) + "\t"
out = out + "\n"
with open("rolls.txt", "a") as text_file:
text_file.write(out)
for x in range(10000):
batchroll()
```

(Don't judge the code, I'm sure it could be improved.)

First off, after running it - I was glad to see that I had logicked it all out correctly and the rolls matched expectations. Secondly, seeing actual distribution of numbers was useful for perspective. It's one thing to see them as abstract percentiles, but it's another to see actual numbers of instances.

Out of nearly 100 million simulated rolls, I only rolled on the d20 ~4,300 times. Meaning that with 100,000,000 rolls; I rolled the max of "60" (4+6+...+20) just 203 times. Here's the results of the simulated rolls on a Google Sheet.

Interesting stuff mathematically. A fun morning exercise for the ol' noggin.