This is the second of three articles discussing common dice-using mechanics used in tabletop RPGs (aka "narrative" or "pencil-and-paper" RPGs). This articles covers the different types of schemes for designing dice mechanics, and compares their general features.

<<- Previous | Next ->> |

A fixed-die mechanic simply means that the same number and type of dice are always rolled, regardless of the character's stats or the task's difficulty. There are two basic choices here: linear roll vs bell-curve, and roll-under vs roll-and-add. There is also other options: including open-ending, autosuccess/autofailure, and blackjack degree-of-success.

Linear rolls are produced by rolling a single die or percentile dice. Bell-curve rolls are generally produced by rolling several dice and adding them together (i.e. 3d6). The difference between these can be seen in the following chart which compares a 1d20 roll (used in D&D) and a 3d6 roll (used in GURPS). I compare both the percentage chance and the odds of rolling a given number or less.

1d20 | 3d6 | |||
---|---|---|---|---|

Pct | Odds | Pct | Odds | |

1 | 5% | 19.0 : 1 | - | - |

2 | 10% | 9 : 1 | - | - |

3 | 15% | 5.7 : 1 | 0.5% | 215 : 1 |

4 | 20% | 4 : 1 | 1.9% | 53 : 1 |

5 | 25% | 3 : 1 | 4.6% | 20.6 : 1 |

6 | 30% | 2.3 : 1 | 9.3% | 9.8 : 1 |

7 | 35% | 1.8 : 1 | 16.2% | 5.2 : 1 |

8 | 40% | 1.5 : 1 | 25.9% | 2.9 : 1 |

9 | 45% | 1.2 : 1 | 37.5% | 1.7 : 1 |

10 | 50% | 1 : 1 | 50.0% | 1 : 1 |

11 | 55% | 1 : 1.2 | 62.5% | 1 : 1.7 |

12 | 60% | 1 : 1.5 | 74.1% | 1 : 2.9 |

13 | 65% | 1 : 1.8 | 83.8% | 1 : 5.2 |

14 | 70% | 1 : 2.3 | 90.7% | 1 : 9.8 |

15 | 75% | 1 : 3 | 95.4% | 1 : 20.6 |

16 | 80% | 1 : 4 | 98.1% | 1 : 53 |

17 | 85% | 1 : 5.7 | 99.5% | 1 : 215 |

18 | 90% | 1 : 9 | 100% | 1 : inf |

19 | 95% | 1 : 19 | - | - |

20 | 100% | 1 : inf | - | - |

Although it has the same average and a similar range, the 3d6 roll has a lower variance than the 1d20 roll. This can be expressed in the RMS (or Root-Mean-Square). The 3d6 roll has RMS=3.0, while 1d20 has RMS=5.8, nearly double.

The important thing to note is the behavior. The 1d20 roll always has a difference of 5% for each +-1. However, the difference in odds changes dramatically. Around the center odds change by x1.2 or so, but at the edge they go to x2. In contrast, the 3d6 roll tends to roughly double the odds of success or failure with each +-1. The percentage change varies from large at the center (12%) to less than 1% at the edge.

What does this mean for RPG play? Well, a linear roll is going to have a lot more rolls at fair odds. Half of the 1d20 rolls are between 3:1 and 1:3 odds. By comparison, a bell-curve roll will tend to have more "almost-sure-things" and "long-shot" rolls.

The other question is how to compare the roll, the stat, and the difficulty. Some games have roll the dice and see if the total of the dice is less than the stat ("roll-under"). Here the difficulty is a modifier added to the roll or stat, which defaults to +-0. Other games add the stat and the roll and see if the sum is greater than the difficulty ("roll-and-add").

These are mathematically equivalent, but there are psychological differences. In "roll-under" systems, the stat is expressed as a chance of success. This makes it faster in the case of difficulty zero, but it creates a bias which encourages difficulty zero. The GM sets the difficulty of a roll in relation to the standard zero difficulty (i.e. "this is a harder task than normal: -3" or "this is an easier task than normal: +2"). However, for many rolls a standard is difficult to define. For example, a percentile system might have a character who has 25% Cryptography skill. At a simplistic level, this seems easy to understand: she has a 25% chance to crack a code. But what is a standard code-cracking?

In "roll-and-add" systems, the difficulties are rated on the same number scale as the skills. Having skill equal to difficulty tends to mean either 100% chance or 50% chance. Thus, instead of setting difficulties relative to a standard, the GM tends to set difficulties relative to skill (i.e. "this would be 50-50 for a starting professional").

There are miscellaneous mechanics which can be used with fixed-die rolls which modify the usual behavior. These are just comments on possible options and their effects:

- Automatic Success/Failure
- This is a rule where the minimum and maximum rolls (or close to them) are an "automatic" success or failure. This simplifies handling those rolls and adds a bit of spice when they come up. The problem with this is that there is an ill-defined line where the "automatic" should be disallowed. i.e. An expert marksman should be able to hit the broad side of barn from arms length, regardless of the roll.
- Open-ended Rolls
- In the typical open-ended roll, if you roll the maximum (or very near the maximum), then you can roll again and add your second roll to your first roll. Similarly if you roll the minimum you roll again and subtract that from the first roll. This is similar to the above, but it defines better how to handle cases. This also creates an effect similar to a bell-curve, making more long-shots and near-sure-things.
- Blackjack Degree-of-Success
- Degree-of-success is normally determined by how far your roll was
from a failure. i.e. If you needed an 10 and you rolled 16,
then your degree-of-success is 6. The blackjack method is used
with "roll-under" mechanics, and says that instead the number
rolled is the degree of success. Thus, if your stat plus
difficulty modifier is 14, then rolling 1 is the least success
(D-o-S 1) and rolling 14 is the best success (D-o-S 14).

This makes it easier to read degree-of-success, but it puts maximal success right beside failure, which means that a minor math mistake can have big consequences. Normally +-1 would just be the difference between a minimal success and minimal failure, which should be very close.

A dice pool mechanic means that the number of dice rolls varies
depending on the character's stat and/or the difficulty of the task.
The term "dice pool" is from FASA's __Shadowrun__ RPG (1989).
Compared to fixed-die, dice pool mechanics can be a little easier by
having less addition/subtraction. They also benefit from having
physical counters on the table. However, all dice pool mechanics
have a problem with scaling. In a fixed-die scheme, you can always
have a higher stat or a lower stat. In a dice-pool scheme, you can't
have less than zero dice, and very large numbers of dice become
unplayable. How much of a problem this is depends on your parameters.

With dice pools, you can change the number of dice or the number those dice are compared to. With fixed-dice mechanics, you can vary only the average roll, not the variance. Thus, modifiers to stat and modifiers to difficulty mean exactly the same thing in fixed-die mechanics, but they need not in dice pools. In theory, this can be used to better represent different probability distributions. However, in practice the complexity is such that either the designers or the GM (or more likely both) do not understand the probabilities well enough for this to work. Instead, it ends up being fairly arbitrary which number is changed.

Within dice pool mechanics, there are three basic types: additive, target-number, and highest-die. There are also many variations possible, like adding the N highest dice out of M.

An additive dice pool simply adds together all of the numbers rolled.
This type of mechanic is used in West End Games' __Star Wars__ RPG
and its other D6 System games. Each skill is rated in terms of a
number of dice. To attempt an action, you simply roll that number of
dice and compare the total to a difficulty number.

The advantage is that it is very simple in principle. Just roll and add. Modifiers can change either the number of dice rolled or the difficulty they are compared to, but there is a fixed ratio which is easily learned (i.e. a -1d6 penalty is equivalent to -3.5). A disadvantage is that it is rather laborious to add up more than a few dice.

The "binary" variant addresses this problem by making each die count
only as 1 or 0. West End Games' "D6 Prime" system has special
six-sided dice where 2 faces are fail and the other 4 are success.
You roll a number of dice, count up the number of successes, and
compare these to the difficulty. A similar approach is used by White
Wolf's __Trinity__, where d10's are rolled and each 7 - 10 is a
success. This makes the addition much easier, but it has a much more
coarsely-grained scale of difficulty and degree-of-success.

This approach adds up the number of dice which are equal to or greater
than some target number (i.e. the number of d10's which are 7 or
greater, say) -- where the target number changes with stat and/or
difficulty. Thus, you might roll 6d10, and look for how many dice are
4 to 10 for an easy task, or 8 to 10 for a hard task. This approach
was popularized by FASA's __Shadowrun__, and later by White Wolf's
Storyteller series of RPGs.

Compared to additive dice pools, this has more complexities. Modifiers can now act in three ways: (a) change the number of dice thrown, (b) change the target number they must exceed, or (c) change the number of successful rolls required. Each of these has a different effect which aren't easily comparable.

This approach rolls a number of dice and takes the highest number
rolled. This is used in Task Force Games' __Prime Directive__,
Last Unicorn Games' __ICON__ system (for Star Trek and Dune) and
Dream Pod 9's __Silhouette__ system. A raw use of this mechanic
has a fairly narrow set of results. After the third die, the average
gets close to the maximum and each die after that makes less and less
difference. Thus, this mechanic is usually combined with some other
mechanic: such as open-ended rolls or additional bonuses.

There are a number of other possible variations in dice pools, but the above choices cover the major RPGs. I will cover the more obscure ones later.

These are mechanics where you change the type of die you are rolling
(i.e. number of sides) based on the stat and/or difficulty. For
example, a low-stat character might roll 1d4 while a high-stat
character rolls 1d12 or even 1d20. This was pioneered by the
__EarthDawn__ RPG, and used by several since then. This has
two main features compared to fixed-die schemes:

- There is a built-in granularity and scaling limits based on the types of dice you have available. A typical progression is 1d4, 1d6, 1d8, 1d10, 1d12, 1d20.
- As the dice get larger, the variance increases with the average.
- Each player requires one of each die type for smooth running.
- The player is usually only rolling one or two dice, which is faster to process than most dice pools. It is similar to fixed-die mechanics in speed, depending on the details.

The latter is worth examining. If high rolls are good, then in a step-die system experts have much more random results than beginners do (i.e. larger variance). If low rolls are good, then experts have less random results than beginners -- which is usually considered more sensible.

John H. Kim <jhkim-at-darkshire-dot-net> Last modified: Fri Dec 21 00:45:55 2001