# Is there any known limit for how many dice RPG players are comfortable adding up?

After reading a few RPG systems that use successes and others that use dice whose shown number are totalled, I came to the conclusion that personally I prefer adding up a maximum of 3–4 numbers and don't like having to add up more than that — while with counting successes I had no such preference on a limit.

Now what I'm wondering is, if there are any known studies from the gaming industry (or if there is any known census there) that shows a practical limit at which the average player says "ok that is too many dice to add up" and thus loses interest?

(To clarify, adding up 3d6 in this context means adding up the face values to get somewhere between 3–18 as a sum.)

• Reminder: comments are for clarifying content, not posting small or incomplete answers. Prior comments containing answers have been removed. – SevenSidedDie Nov 7 '16 at 15:33
• We're looking for answers that have evidence from actual studies (as the question asks). An answer that does not cite published research might be OK if it instead cites extremely convincing personal experience and justifies its lack of published research citations. We are not looking for personal impressions. – SevenSidedDie Nov 7 '16 at 15:37

So, I am a freelance game designer and I’ve worked on a couple of systems and with a couple of design teams, but I am a “professional” only in the strictest sense (I have been paid for my game design work). I still have a day job; I do not spend all day, day in and day out, working on game design, and that matters.

But this isn’t the concern that game designers I have worked with have had. Players will, particularly in the right moment, be perfectly willing to add up large numbers of dice (some players even especially like doing so). The real concern is what sorts of mental mathematics you can rely on players to perform reliably, quickly, and accurately. You are quite constrained in what you can do before one or more of these starts to suffer, and they are all important to keeping the game moving and ensuring your game functions as you intended it to. If you ever do reach some limit where people just don’t want to sum that many numbers, then you are way, way past the point where speed, accuracy, and reliability are all solid, so that’s what you should be concerned about.

The other advantage here is that people’s ability to perform mental math quickly, reliably, and accurately is 1. quite objective, and 2. of considerable interest outside the RPG scope. This means that there is research you can leverage to answer this question. A study of what RPG players are, on average, comfortable with, would have to be very large to be valid, and would be of minimal interest outside the RPG industry. I am not aware of any such study, and truly doubt it exists or ever will. (And if it ever does, that kind of market research is often not made public, but rather produced specifically for the publisher that funded it and kept as a trade secret.)

The rules of thumb that I have kept to include:

• Not doing any math is always much, much better than doing math, no matter how trivial. Reading a number off a die is much faster than any arithmetic, and can be assumed to be perfectly reliable and accurate. This could be a reason, for example, to prefer a d20 over a 3d6: the more-normal distribution of the 3d6 may be nice, but the speed at which a d20 can be used over 3d6 could be a big advantage.

There is actually an inverse relationship between these: if you are going to be rolling very often, the speed benefit of the d20 is bigger. At the same time, the normality of the 3d6 is also less significant, because the more-frequent rolling implies that any individual roll is less important and it is the accumulation of rolls over the course of the encounter that are more important (see goblin dice). That means that rolls will “normalize” over the course of several separate rolls, so that benefit of the 3d6 over the d20 is reduced.

The flip side is also true: if you roll less often, that implies that any single roll is more important. The more-normal distribution of a 3d6 may be very desirable, and the small-but-significant speed, reliability, and accuracy losses for using them instead of a d20 will be mitigated by the fact that you don’t need to do it as often.

• There is a big, big difference between a pre-calculated value written down on a character sheet, and a value that has to be calculated in the middle of the game. The former has drastically reduced need for speed, which results in much, much higher accuracy as people take the time to get the number right, and those are not what we are talking about. Ultimately, the following rules of thumb are extremely restrictive because we are talking about calculations that have to be performed often and quickly. Even low rates of error become badly exacerbated under these conditions, which means we need to stick to things that are almost impossible to get wrong.

• It probably goes without saying, but stick to whole numbers. Decimal values cause some trouble, and fractions can cause a lot of trouble.

• As much as possible, stick to single-digit numbers. Human brains actually process basic arithmetic on small numbers differently than they do large numbers, because we actually have parts of brain dedicated to small numbers and can manipulate them “intuitively” whereas larger numbers forces us to track them symbolically. Moving past these throws a significant delay into things, and drops accuracy rates some.

• If a large number comes up in an exceptional circumstance, or is accumulated over time, pen and paper are useful tools that drastically improve accuracy and reliability. They come at a heavy cost for speed, however, and thus tend to not be used—even when they should be, for accuracy’s sake—if these sorts of calculations have to be performed frequently.

• Addition is pretty much the only really safe operation. Even subtraction has significant reductions in accuracy rates. Multiplication is worse than that, and division is just right out.

• Doubling and halving, rather than arbitrary multiplication and division, are fairly safe, though. Again, doubling much more so than halving—doubling is actually just addition anyway, add the number to itself. Quadrupling and quartering (doubling or halving twice) are probably safe—but slow. Tripling can be OK, but I would not use “thirding” (which, tellingly, isn’t even a word).

• Multiplying and dividing by ten are entirely safe, because you don’t perform any multiplication or division at all, you just pad with zeroes or remove digits off the end, respectively. They tend not to come up terribly often because they result in larger numbers (undesirable) or decimals (undesirable), but the operations themselves are probably safer even than addition.

• Division by multi-digit divisors, as well as any form of exponentiation or roots, are “safe” only because players will tend to just give up and use a calculator. Most players would prefer to avoid them, however, and will not use them unless they “have to”—which is why these operations that force them to do so are actually “safer” than those that they can do in their heads (because even though they can, errors tend to creep in when you have to do it fast and frequently).

You can do a lot more research into this, though. These rules of thumb are just things I have picked up from working on things with game developers I respect, as well as some things I remember from my undergraduate psychology courses. That’s good enough for me, and I suggest that these are issues you want to stay well inside the lines, rather than toeing them on, but ultimately, you can definitely find more information out there about what sorts of things do and don’t work.

• – KRyan Nov 6 '16 at 16:48

From observing a lot of players since 1979, adding smaller numbers is significantly easier than adding big ones.

• 3d6 is OK for most players, although it is about the upper limit.
• 2d6 isn't all that much easier.
• 2d10 will likely produce about as many mistakes as 3d6.
• 1d20, or any other direct-reading die roll, is easiest.

Mechanics that have been produced to avoid arithmetic, such as Storyteller's pools of d10s, or the sorting involved in One Roll Engine, have just as much potential for mistakes, although they may be easier for people who have convinced themselves they have a problem with arithmetic.

All of this is for dice rolls during play. More complicated rolls during character generation, or downtime, are possible if the GM will be available to help with the process and there won't be time pressure.

• Thank you for the comment on dice pools et al., as I have also observed a lot of issues from these “mathless” approaches that seem to eliminate any advantage they have from avoiding arithmetic. (In particular, dice pools produce very nice distributions, but personally I find them horrid to run in practice.) – KRyan Nov 6 '16 at 16:24

It depends on several things, how many dice are comfortable. One of the most relevant points on the pool size is: Do you need to roll at least a specific sum with the dice pool or does each die above a certain number count towards a success? Let's type these two systems A and B, take into account the odd "Roll & Keep" as C and add an Excursus on exploding dice.

# A - Sum vs. Difficulty to Success

This is somewhat the D&D and GURPS way. Roll a specific pool, add a modifier, compare the sum to some "difficulty" to determine success or failure.

Clearly, pools that sum up to success have to be limited to be handleable, and KRyan made an excellent analysis on how the numbers play for or against each other here, though I would like to add some tiny bits:

• d100 is virtually a 1d10*10+1d10, and as long as players keep the two apart correctly is a very safe way to determine something. However, d100 or d% often appear clumsy or problematic in other areas than dice rolling.
• 2d6 is a pretty easy thing, the sums are 2 to 12 and can very easily be done without thinking. There are only so many combinations and some players will internalize them in a way that no math is involved but a glance on the dice will tell them the sum. Any die more though appears to make calculating mandatory, rendering anything more than 3d6 slow.
• complex algorithms like "4d6 drop lowest" do favor one side of the bell curve, but they are extremely clumsy, and players will want to avoid those at best they can. Save those for determining relatively static things!
• While static modifiers are reasonably safe, they can result in a "guaranteed success" without rolling. 1d20+30 will always be above a 31, so any 'difficulty' lower than that doesn't need to be rolled unless there is a "guaranteed failiure" event inherent in the dice evaluation (like rolling a natural 1). *Likewise, achieving a 31 with only 1d20 and a bonus of 10 is impossible, making the roll moot in the other way round. *Take a good look at the EXCURSUS and think if you really need exploding dice: One exploding d10 is faster to evaluate than 3d6, but slower than 2d6 or 1d20.

# B - Dice above X are (partial) Successes

An entirely different way to achieve a solution is yet untouched. We encounter such a system in games like Shadowrun, Exalted, the WoD/CoD and others:

There is some way to determine a pool size (often either some sum of statistics on the sheet), modifiers usually change the pool size. Then all the dice are rolled (possibly using exploding dice mechanics) and any die to show more than the difficulty (which can be dynamic or static) is a (partial) success.

Obviously, such a system is different in evaluation time from the Type A or C "one pool, sum up, check against number". However, these systems can be faster to evaluate than summing up larger dice pools and they do allow having a higher pool while maintaining the same number that should show up on a roll to be a success for every roll: it is possible to get a six with 1d6 as well as with 6d6, however, the probability in the later case is better.

• One can only roll so many dice at once - at some point (ca 72d6 of the small variant or 20d10 for me) rolling becomes difficult to be done in one attempt without use of some help. However, rolling several times and just counting on is, of course, an option for having small hands or a limited dice supply. Physical capabilities have not been evaluated to my knowledge.
• At some point having enough/too few dice can make tasks trivially/impossible. See B1 for this.
• Keep the EXCURSUS in mind - exploding dice in pools will come up relatively often while they might in fact not be that useful, especially if the 'is this a success' edge ends on a multiple of the die size or one higher.

## B1 - Guaranteed Success/Failure

There is a point, when a dice pool against a fixed numeral almost guarantees at least one success (or rather a 98% Probability). Let's look at the old Exalted 2 in anydice. Any roll of 7 or greater is a success, 10s are two, 1s count as -1 success. Now, with a slight modification of it that only checks if there is at least one success. A pool of 6 dice does grant 95.33% of success, 7 dice 97.2% and 10 dice go to 99.4%. Any more dice and we skew heavily towards 99.9+%. Obviously, these tasks have become trivial for a character that can muster such a pool. For 2 successes needed, the point of >90% is at 11 dice (91.99%), which is also the very last result anydice can handle in 5s. Careful estimation of mine: for a >95% chance for 2 or more successes, one would need somewhere around 12-14 dice (double of 6/7).

• If implementing a pool & count successes system, think about the behavior of large pools if a single success is enough. Performing trivial rolls in unstressed situations takes up precious gametime.
• Likewise, needing X successes where X is larger than the pool renders rolling moot as you can’t achieve this number of successes. Performing impossible tests should not be necessary.

# C - Roll & Keep vs. Difficulty

This type I have encountered to date only in one example: Legends of the 5 Rings. It is a dice system that in itself takes some of A, gets inspired by B and does its own thing.

In L5R you roll a number of d10 based upon two static values on the sheet (skill+something), then keep a number of those based upon one of those (often the skill) and sum those kept dice up. It is possible that after that you have to add some other static value to this number. The end result is compared to some difficulty, which usually is a multiple of 5.

The problematic of this system is evident easily: summing up many dice (L5R allows only up to r10k10) can become pretty slowsee below and everything that is true for the A part is true for this. Obviously one has to limit the dice pool to achieve any handleable results but this progression also does grant very interesting results: the more dice enter the pool, the more spiked a small keep becomes towards the high end, and keeping more does make it more bell-curvy and shifted towards the average sum of all dice rolled while the sum as a whole rises. How does this look like? Well, without any additional external modifiers... like this anydice - shifted bell curves all over! Or we look at the good article on the Roll & Keep.

# EXCURSUS - Exploding Dice

Exploding dice like SR2 & SR3 had them are somewhat awkward: You can get oddly high results, like rolling a pool of 2d6 and scoring a 23 and a 7, but if the number to beat with each die is rarely ever going to be that high, it is just a complication.

Also, think about what it does to probabilities: Any result of $\text{die-size}\times n+1$ has the exact same chance to occur as $\text{die-size}\times n$, which screws up the determination of difficulties a fair lot - or more exactly: $\text{die-size}\times n$ should not show up at all (as you have to explode and this add at least 1) unless there is a limit on how many times a die may explode or the explosion is somewhat modified. This is sometimes referred to as 6=7. There are some very interesting thoughts on this on Anydice.

While Exploding dice are clearly a mess, they do allow extreme results: even if a 35 on an exploding d6 is quite improbable, it can happen $(2.1\times 10{-5})$ - it grants the chance to do this once-in-a-lifetime, one-shot dragon-kill... At the price of considerably slowing the rolling process once it happens, as this example roll would need 6 explosions.

A different example of exploding dice can be found in Mekton. This system bases on a simple 1d10+derived value (from a skill and a basic statistic). The die explodes on a 10 and continiues to do so as long as 10s appear. On the other hand, if the first die is a 1, it explodes negatively once: you deduct that extra roll, but this one doesn’t explode on a 10. The resulting distribution is this, clearly favoring the 2-9 area, disallowing 1 and 10 (&20) as expected for exploding dice, and any really extreme results are very rare.

• Explodig Dice have a several-step evaluation process of rolling, checking for those dice to explode and finally re-rolling (exploding) and re-evaluation.
• Even a single exploding die, as seen in the Mekton example, can grant extreme results, though summing up the explosions behaves just like an A-type: Sum vs. Difficulty. Obviously, the evaluation is slower, as you need to roll it once after another.
• Sometimes explosions happen in contrary to common Sense due to either explosions happening when the result is already clear or due to the 6=7.
• Example: pools of d6, any roll of 6 is a success: No explosion would be necessary (as 6 is achieveable)
• Example 2: pools of d6, rolls of 7 are a success: No explosion would be necessary (as 7 is 6+1 and scoring at least a 1 would be guaranteed on an explosion roll)
• Example 3: pools of d6, rolls of 8 are a success: Explosions need to happen.
• the arguably easiest die to explode might be the d10, as the explosion roll just changes the last digit, unless it explodes again.
• There is a way to achieve a continuous distribution: any explosion-die gets a modifier of -1. This will look like this AnyDice. It does get rid of the "6=7" problem on the cost of involving math.

# Practical test

As these thoughts are by far not a proof, I did a practical survey in my college RPG club. This survey started with 2 (and a half) people going through it, so it does not qualify to be a statistically valid test as of now.

## Test procedure

Participants have 60 seconds to solve as many questions per column as they can. The columns are:

1. sums of 2d6. Participants need simply sum up all subcolumns.
2. sums of 3d6. As 1.
3. sums of 2d10. As 1.
4. sums of 3d10. As 1.
5. simulated 1d100 made from 2d10. Participants just need to write down the columns in the very same order and replace 0 0 with 100.
6. using the L5R system with a “roll 4 keep 2”. Participants have to decide which two of the four give the highest combination.
7. using the “highest 3 out of 4d6”. As 6, but summing up 3 for highest. Effectively this is the same as "roll 4 keep 3".
8. using exploding dice on the sum of 4d6. The explosion-rolls are simulated in the shape of 6 extra columns.
9. using exploding dice as in Shadowrun 3rdEd with a pool of 6d6. This column was tested twice:
• with difficulty 6 just the left block is actually needed. This is actually the same test as column 10 but with a pool 1 larger.
• with difficulty 8 using both blocks is mandatory.
10. using exploding dice in the Mekton system: 1d10 with 3 columns simulating the explosion
11. using pools: Shadowrun 4th with 5d6
12. using pools: cWoD: 5d10, difficulty 6, no speciality

The Test Sheets are arranged in columns with an empty line as a placeholder for the answers, the correct answers are calculated by the computer and provided in the very same print-size, allowing to quickly to check the answers against the correct results.

## Preliminary Results

Up to now, the number of participants is too low to grant fundamental results. However, there are first indicators for some points worth of notice:

• The time difference between summing up 2d6/2d10 and 3d6/3d10 is small.
• summing up d10 is slower than d6.
• Roll & Keep is slower than straight summing up.
• Roll & Keep is prone to an error deriving from mixing up the correct number to keep: 13 of the errors in column 7 come from this.
• The Mekton system is as fast as summing up 2d10 and the participants have been equally reliable.
• pool evaluation systems (column 11 & 12) for (partial) success with pools of 5 are equally fast to be parsed by players as they sum up 2d10 to 3d10. However, more errors happen in the process.
• Exploding dice systems (column 8, 9b) with more than 1dN are considerably slower than any other tested systems - even bordering twice the average time of a non-exploded roll of the same pool (9 vs. 9b: 1.15s vs 2.00s).
• Exploding dice are considerably prone to miscalculation or miscounts.

# TL;DR:

• Try to keep complex math to a minimum!
• Reduce the number of dice to be summed up to a minimum - 1 is easy, 2 is still good, 3 is somewhat ok,
• d% is a pretty good die: it is easy (as you don't really sum up... just append)
• Pool-Evaluation for (partial) success is (in the tested cases) not that much slower than summing up pools.
• Roll & Keep is somewhat problematic but has very interesting results - and while the test showed that it can be prone to error, it is timewise (for small pools) on par with evaluating pools of a roughly equal size.
• Exploding dice are tricky and slow down evaluation considerably (2s & 3.15s per test instead of times usually <0.8s)
• There is a point at which rolling might become a formality as success or failure are guaranteed (or at least have a chance of 99.4%).
• Since you highlight 2d6, it may be worth noting that many, many players will be familiar with it from traditional board games, which overwhelmingly use one or two d6s. Many will not only know what every combination sums to from rote memory, but will also know things about the distribution (7 being the most common, 2 and 12 being the least, etc.). Those are pretty potent advantages when 2d6 produces an acceptable and useful range and distribution. Also, I’ll note, as I did with John Dallman’s answer, that personally (and I lack real expertise in this area), I have found dice pools obnoxious. – KRyan Dec 3 '18 at 14:45