### Fiddly Bits: Game University

## FID 223: Analysis of die-roll methods

**by Torben Mogensen**

Jun 18,2002

# FID 223: Analysis of die-roll methods

In this lecture, I will in detail analyse some die-roll methods used in popular games. First, I will show some examples where lack of sufficient analysis has lead to mistaken assumptions about probability or, in my opinion, a flawed design in a published game. The first is an example that shows that players that rely on intuition may be far off in their estimates of probabilities. The second is an example where the designers of a game haven't sufficiently analysed their die-roll methods, so the first published version of the rules contained a flaw, which had to be corrected in later editions. These examples aren't meant to ridicule the people in question, but to show that it is easy to make mistakes about probability unless you do an actual analysis based on the laws of probability. Since we can't expect all players or game designers to have sufficient mathematical background to perform such an analysis, I offer a tool for these people: A program that can calculate probabilities of various die-roll methods. This lecture will show a few examples of how the program is used. Later lectures will occasionally use the tool to analyse specific die-roll methods, but there will be no tutorial as such for the program. For that, I refer to the tool package itself (see below).

### Example 1: How many times do you need to roll?

Quoted from an old rec.games.frp posting: "Need a 20 to hit? Attack 20 times". The meaning of this statement must be that you have a very good chance of succeeding if you do that. Also, D&D 3E has rule for "taking a 20" that says that you can ensure a result of 20 by taking (roughly) 20 times as long on the task. This rule seems to follow the same line of reasoning. Let us see how true it is. . .

The easiest way to figure out the probability of getting a 20 in 20
rolls of a d20 is to calculate the chance of *not* rolling a 20,
and then subtract that from 1. The chance of not rolling a 20 in one
roll is 19/20, so doing so 20 times is (19/20)^20 = 0.36, so the
chance of getting at least one 20 in 20 rolls is 1-0.36 = 0.64, or
less than two-thirds. This is hardly enough to justify a statement
that implies near-certainty, nor a rule that gives absolute
certainty.

We can use the same method to calculate the chance of getting at least one d20 when rolling different numbers of dice:

Number of rolls | Probability of 20 |

5 | 0.23 |

10 | 0.40 |

15 | 0.54 |

20 | 0.64 |

25 | 0.72 |

30 | 0.78 |

35 | 0.83 |

40 | 0.87 |

45 | 0.90 |

This shows that you need to roll 45 times or more to get at least 90% chance of getting a 20. Obviously, you can never achieve absolute certainty.

In conclusion: As there is no certainty when rolling dice, an advice for rolling a number of times to get a desired result should always be qualifed by the probability this gives of getting the result. Otherwise, the advice is at best misleading and at worst meaningless. The "taking a 20" rule is, probably, not intended to represent 20 quick attempts, but rather a single careful attempt. Hence, the amount of extra time used has no obvious relationship to the improvement in success chance. All we can really conclude is that the requirement of using 20 times as long is no more natural or obvious than, say, using 10 times as long.

### Example 2: Botching in the Storyteller system

The Storyteller system used by White Wolf's games (Vampire, etc.) has been revised because of a problem with the system for determining botches. We will look at the problem in the original system, how it was fixed in the revised rules and show that the problem hasn't gone away completely in spite of the revision that was intended to fix it.

The Storyteller system uses a dice-pool mechanics, where you roll a number of d10's equal to your ability (which is skill+attribute) and count the number of dice that meet or exceed the difficulty level of the task (this is called the number of successes). To make things more interesting, any 1 rolled subtracts 1 from the success count. In the original system, you would get a botch if the resulting sum was negative. Let us look at how the chance of botch changes when your ability increases, i.e., with an increasing number of dice.

If you roll one die, the chance of botching is 10% (the chance or rolling a 1 on a d10), regardless of difficulty. If you roll two dice, you botch either if you roll two ones (a chance of 0.01) or roll one one and one non-success (a result between 2 and L-1, where L is the difficulty level). This totals to 0.01+2*0.1*(L-2)/10 = (0.02*L-0.03). If L is 7 or more, this is more than 10%. In other words, for difficulties of 7 or more, the risk of botching increases if your ability increases from 1 to 2. For 3 dice, you botch if you roll one 1 and no dice above the treshold or if you roll two or three ones. The first case happens with chance 3*(0.1*((L-2)/10)^2) = 0.003*(L-2)^2. The second case happens with chance 3*0.9*0.1^2+0.1^3 = 0.028. If we insert different values for L, we get:

L | Botch risk with 2d10 | Botch risk with 3d10 |

6 | 0.09 | 0.076 |

7 | 0.11 | 0.103 |

8 | 0.13 | 0.136 |

9 | 0.15 | 0.175 |

10 | 0.17 | 0.22 |

We see that the chance of botching also increases when going from ability 2 to ability 3 if the difficulty is 8 or more. For difficulty levels 8 and 9, the chance of botching further increases for a while, and then drops again. When the difficulty is 10, the botch chance continues to increase towards 50% when ability increases towards infinity.

It is hardly a desireable property of the die-roll system that the chance of botching a roll increases with ability (even if the success chance also increases). The lesson is that a game designer should be careful to examine the probabilities of his die-roll system to see if there is any undesired behaviour, and modify the system to avoid these if they occur, preferably before the game is published.

White Wolf, as mentioned, *did* revise the rules. In the
second version, botching occurs only if there are *no* successes
and at least one 1. That, however, doesn't change the above
calculation for two dice, so the botch chance still increases when the
ability increases from 1 to 2. For all difficulty levels less than
10, it declines again already at 3 dice, though. If the difficulty
level is 10, the botch chance continues to increase to nearly 27% at
six dice before it slowly falls again. Even White Wolf's game
*Trinity*, which fixes the difficulty level to 7, has the problem
to a small degree. If 6 was chosen as the fixed treshold, the problem
could have been avoided altogether so, in my opinion, that would have
been a better choice.

### A tool for die-roll probabilities

As promised, I will present a tool for calculating probabilities for non-trivial die-roll methods. The tool consists of a notation for describing die-rolls and a program that calculates the probabilities for a die-roll described in that notation. For reasons of space, the following is not a complete description of the tool. Interested readers can download the tool, including a complete manual, from http://www.diku.dk/~torbenm/Dice.zip.

The notation is derived from the informal notation used in many
games, so "`d10+1`

" means what you expect it to mean. We
will elaborate:

Writing "`d`

" specifies rolling an
*N**N*-sided die. You can combine this with arithmetic operators and
constants, e.g., writing "`d10+3*d6`

" to get the result of
ading a d10 to three times the value of a d6. Note that
"

" does *N**d6*not* specify rolling *N*
d6's. To roll *N* d6's, you must write
"

", and that will just give you a collection
of *N*#d6*N* dice, not their sum. To get that, you write "```
sum
```

". This is a bit more elaborate than just writing
"*N*#d6*N*d6", as we are used to, but the more verbose notation allows
us to do other things to collections of dice than just adding them up.
For example, we can count the number of dice that are above a
threshold, e.g., "`count >7 5#d10`

" to count the number
of dice that exceed seven in a collection of five d10's. Giving this
description to the program yields the following output:

Value | Probability for = | Probability for < |

0 : | 0.16807 | 0.0 |

1 : | 0.36015 | 0.16807 |

2 : | 0.3087 | 0.52822 |

3 : | 0.1323 | 0.83692 |

4 : | 0.02835 | 0.96922 |

5 : | 0.00243 | 0.99757 |

Average | = 1.5 | Std. Deviation = 1.0246950766 |

The column "Probability for =" column shows the probability of rolling the exact value. The "Probability for <" column shows the possibility of rolling strictly less than the value. To get the chance of getting at least $N$ successes, subtract the "Probability for <" from 1. It is easy to modify the above description to use a different number of dice or a different threshold.

We can extend the above to use the Storyteller mechanism, where
ones subtract from the count. It would be incorrect to write the
plausible definition "```
(count >7 5#d10)-(count =1
5#d10)
```

", as the two occurrences of "`5#d10`

" would
refer to *different* rolls of five d10's. To use the same
collection of dice for both counts, we must save the roll in a
variable and use that variable twice, i.e., "```
let c=5#d10 in
(count >7 c)-(count =1 c)
```

", which yields:

Value | Probability for = | Probability for < |

-5 : | 1E-5 | 0.0 |

-4 : | 0.0003 | 1E-5 |

-3 : | 0.00375 | 0.00031 |

-2 : | 0.0252 | 0.00406 |

-1 : | 0.0981 | 0.02926 |

0 : | 0.22356 | 0.12736 |

1 : | 0.2943 | 0.35092 |

2 : | 0.2268 | 0.64522 |

3 : | 0.10125 | 0.87202 |

4 : | 0.0243 | 0.97327 |

5 : | 0.00243 | 0.99757 |

Average | = 1.0 | Std. Deviation = 1.3416407865 |

Using the original Storyteller rules, the chance of a botch is the chance of rolling less than 0, which can be seen in the second column. Note that the average and standard deviation values are meaningless in this case, as the table goes down to -5 while there is no graduation of botches in the actual game.

In the revised Storyteller rules, not all negative results are botches, so the above can't be used to find the botch chance in thes rules. At some cost in complexity, the die-roll description can, however, be modified to handle botches according to the revised Storyteller rules:

`let c=5#d10 in`

let succs = count >7 c in

let ones = count =1 c in

if >0 succs then largest 1 (0 @ succs-ones)

else if >0 ones then -1 else 0

Explanation: We first count the number of successes and ones separately. If there is at least one success, the result is the number of successes minus the number of ones, though at least 0 as there can't be a botch. If there are no successes, the result is -1 (botch) if there is at least one 1 and 0 (normal failure) otherwise. The description is, admittedly, complex, but that is because the die-roll mechanism is complex to begin with.

Running the description through the program yields the following result:

Value | Probability for = | Probability for < |

-1 : | 0.09031 | 0.0 |

0 : | 0.26061 | 0.09031 |

1 : | 0.2943 | 0.35092 |

2 : | 0.2268 | 0.64522 |

3 : | 0.10125 | 0.87202 |

4 : | 0.0243 | 0.97327 |

5 : | 0.00243 | 0.99757 |

Average | = 1.07069 | Std. Deviation = 1.22728681403 |

Hence, the chance of botching is a bit over 9%, while a normal failure happens in about 26% of the rolls. The combined failure chance is slightly over 35%, unchanged from the old die-roll method.

I have touched only the surface of what the tool can handle. Other features include selecting the least or largest dice from a collection (this was used in the last example) and a mechanism for handling repeated rerolls (as in Rolemaster). I will show examples of these other features in later articles when I discuss more complicated die-roll mechanisms.

Follow the link above to get the complete description and implementation.

TQo0~^DҒt< ek&Ǿ$\۵ZFȃuwݝIŃU QYir2HR2.u3MFoعq]4#A`pP5(b&)b)ⰾp7(i<[-2gL#5[f g?*rVGf8*)s'+20ϟ̑F}KB<7wSL\gbvm9WiRބYŜvdy0'p2I_Fc2>#oA )VL[Qk?3`)<У[(*W.JH ?tXCt谙 X:@ \0w~LqĤE-rFkYj4q 5AQ6[AxG [>w|?( fХθY䝛$c=_qNĦoǸ>O_|&/_Mi7"宥CЧk0dӷLh;TmuCGU-!Ul{ h<\bQX.~"O2*yPcz!Gg### What do you think?

Go to forum!\n"; $file = "http://www.rpg.net/$subdir/list2.php?f=$num"; if (readfile($file) == 0) { echo "(0 messages so far)"; } ?>

### All *Fiddly Bits* columns by Larry D. Hols

### Other columns at RPGnet

TQo0~^DҒt< ek&Ǿ$\۵ZFȃuwݝIŃU QYir2HR2.u3MFoعq]4#A`pP5(b&)b)ⰾp7(i<[-2gL#5[f g?*rVGf8*)s'+20ϟ̑F}KB<7wSL\gbvm9WiRބYŜvdy0'p2I_Fc2>#oA )VL[Qk?3`)<У[(*W.JH ?tXCt谙 X:@ \0w~LqĤE-rFkYj4q 5AQ6[AxG [>w|?( fХθY䝛$c=_qNĦoǸ>O_|&/_Mi7"宥CЧk0dӷLh;TmuCGU-!Ul{ h<\bQX.~"O2*yPcz!Gg