# What dice mechanic gives a bell curve distribution that narrows and increases mean as skill increases?

I'm looking for a dice mechanic that produces a bell curve at all skill levels. I also want it to increase accuracy and precision as a character's skill increases — this basically means better average and smaller standard deviation. The simpler the system is, the better, of course.

• Skill + 2d6 increases accuracy as attribute/skill increases but precision remains the same.

• Count 4+ in (Skill)d6 increases accuracy with skill but precision decreases as skill increases.

• (Attribute)d(Skill) keep 2 where skill is 12, 10, 8, 6, 4 increases accuracy and precision as skill improves (gets smaller) but means there are only 5 steps for a given skill (or possibly attribute). It's also a system that requires a bunch of dice in each size. And has the "issue" of lower rolls being better. And that an increase in skill means a smaller dice while an increase in attribute means more dice.

• (3 + Skill)d6 keep 3 increases both accuracy and precision but stops being a bell curve around 9+ dice (skill of 6) so provides few gradations in skill.

• Skill + d20 is not a bell curve at all.

What dice mechanic would give me the distribution I need for this system?

(Note that this mechanic isn't important enough to me to want to add a lookup table to achieve the desired distribution.)

• What are the qualities you want the distribution to have? A normal distribution is a continuous one, so you probably don't want that. In particular, is it important that the distribution is reasonably symmetrical with respect to its expectation? – Thanuir Dec 5 '16 at 17:40
• @Thanuir I'd like a roughly bell curve distribution - so normal in the 3d6 sense, not the mathematical sense. Yes, I'd like it to be reasonably symmetrical around its expectation, but some amount of skewing is fine - like 4, 5, ... d6 keep 3. – oconnor0 Dec 5 '16 at 17:53
• Many of the systems suggested have a higher mean, but the maximum possible is always the same. Is that desirable? Or irrelevant? Or would you prefer maximum to increase as well? – Kieran Mullen Sep 13 '18 at 22:18
• @KieranMullen Though I didn't include it in the original question, I had preferred the maximum stay the same, but am open to other, nice solutions. – oconnor0 Sep 15 '18 at 19:34

## (SKILL+CONSTANT) dX, keep highest CONSTANT

I don't know exactly the behavior you're going for, so there'll be a few arbitrary numbers in my example:

• skills can be ranked from 0 to 5
• dice rolled are d12 ('cause I think they don't get enough love)
• we're going to keep highest 3 dice.

In this case we're looking at rolling (3+SKILL) d12, keep highest 3. It gets you the following features:

• increasing mean
• rate of increase of mean tails off at high skill levels (which is a feature I like in skill systems)
• variance drops with level
• only requires one type of die (for simplicity)
• skewed distribution, which you said would be okay
• pretty simple execution of the method--no crazy amount of table-time spent on it

Here's an image of the sort of distributions that result. (Click to get to and play with AnyDice program.)

As an alternative, @Ilmari Karonin points out you can get pretty-similar looking results from d6: check out this anydice program which used d6 and a constant of 4, rather than my d12s with a constant of 3. For the "cost" of adding one more die you can use a much-more widely held die-size.

(Ilmari is one of the very fine mathematical minds on RPGSE--you should read his stuff. It's worth your time.)

Now let's be clear: you mentioned something like this in your original post, and say it "provides few gradations of skill" before not being enough of a bell curve. But in a comment you say "if it's necessary, only a smaller number of skill gradations may be supported if it simplifies things." Not sure how to balance those, so I ignored them.

I'm throwing this out there with graphics and a program you and readers can play with. You've given an underconstrained and loosely-defined problem; I think this tool and this method might get you what you want.

• This is a good answer except it violates the "bell curve" distribution increasingly with level in a fashion which make extremely low rolls proportionately more likely as levels increase. – Lexible Feb 12 at 17:55

Mathematically we can increase precision and accuracy by removing dice and increasing static numbers. Making dice smaller has a similar effect, but has limited applicability unless one uses digital dice (which can have any number of sides).

This is easiest to achieve in a skill system with a definite ceiling: Say, we have a skill with a ceiling of 10 points. At 0 points in the skill, we roll 12 equally sided dice (10+2 to maintain a curve at all levels) - say 12d6. Every skill point we get we take away one of the dice and add a static value to represent the maximum outcome of that die. So, at 7 points we'd have 7×6+(12-7)d6 dice, or 42+5d6.

Other solutions are possible, but this is probably most accurate to your request. This does of course become problematic with arbitrarily high skill ceilings, in which case a tiered approach may be preferred.

If using this system, I suggest using d10s as the results will become more intuitive and the math involved easier.

• I really like the results of this approach, but fear that some readers might not immediately intuit the results of your scheme. So I went ahead and edited in a picture of the resulting distributions and linked it to an AnyDice program. If you don't like it please feel free to revert the edit (by clicking on "edited $TIME$ ago"). Also, I only ran up to rank 8 because ranks 9 and 10 get visually jumbled with the legend. – nitsua60 Dec 7 '16 at 15:42
• @nitsua60 It is a very welcome addition, actually. If I had known how to do it as quickly myself, I would have. – Weckar E. Dec 7 '16 at 15:45

I will first address the meaning of your request, just to be super positive we are on the same page. Disclaimer: there is no single way to get your desired mechanic (as I understand it), so my answer will describe some different approaches.

• Increasing mean of rolls with level: This seems a straightforward translation of higher levels result in higher average rolls.

• Requiring a bell shaped distribution: This seems to imply that you want most of the rolls to be clustered unimodally about the mean, with a strong tapering off of the probabilities of extreme values.

• Decreasing variance of rolls with level: This seems to imply that higher levels result in more precise rolls.

I will now address mechanics for each of these desiderata in turn, and then show how they can be put together.

How to increase the mean of rolls with level: This is easily accomplished by common mechanics such as:

• Adding some constant to the roll, with the value of that constant increasing as level increases. Suppose you have some number of dice of some number of sides. Taken together, these dice will have some mean value. Adding a constant to the die roll will shift the mean value by that amount. Variance is constant for this mechanic!

• Similarly, multiplying the roll by some constant greater than 1 works, given that the constant increases as level increases. Multiplying your dice roll by a factor greater than 1 will increase its mean value by that factor (e.g., for a factor of 10, 10×1d6 has a mean of 10 × 3.5 = 35). However, this also increases variance.

• Likewise, raising a roll to some power greater than 1 works, given that the constant increases as level increases. However, raising the dice roll by a power greater than 1 increases the mean value of the sum of of the average of each die's values raised to that power (e.g, for a power of 2, 2d6^2 has a mean of [(1 + 4 + 9 + 16 +25 + 36) ÷ 6] + [(1 + 4 + 9 + 16 +25 + 36) ÷ 6] = 30.3). This increases variance.

• Increasing the number of dice will increase the mean value for a dice roll by the mean value of each die added (where the mean value of a die is simply the average of all the values the die can take, so for 1d6 (1 + 2 + 3 + 4 + 5 + 6) ÷ 6 = 3.5, for a first 6 primes cube (2 + 3 + 5 + 7 + 11 + 13) ÷ 6 = 6.83, etc.).

How to ensure a bell curve at all skill levels: Central Limit Theorem to the rescue! The sampling distribution of the mean value of a bunch of independent random variables approximates the normal distribution as the number of those independent variables increases. Translation: the more dice (any size) you use, the closer your dice roll's distribution will be to a normal, and the closer it's distribution will get to a smooth bell-like curve. With three dice, you start to get pretty bell-like, so depending on how smooth you want your distribution, decide on how many dice to use. Caveat emptor: having players roll 30 dice may not be everyone's cup of tea.

How to decrease the variance of rolls with level: This is accomplished mechanically without too many difficulties:

• Dividing the roll by some constant greater than 1 will decrease the variance, if the constant increases as level increases. However, this will also (1) decrease the mean value of the dice roll by the same divisor, and (2) require calculators, and possibly (3) rounding rules for fractional values.

• If you want the variance to take a specific value at each level, then you need to divide the roll by the square root of the variance of the distribution of your roll (let me know in comments if you want this... it will be mathy, but it is doable). This quotient (roll ÷ square-root of variance of distribution of roll) will have a variance equal to exactly 1 no matter what. So if you then want variance to be X at such and such level, you simply multiply the quotient by X.

• Gonna leave n-th roots out of this for the sake of simplicity. :)

• Reducing the size of the dice you are rolling works, if die reductions decrease as level increases. However, this will also decrease the mean value of the dice roll. If you are using non-digital dice, the number of die sizes may also present difficulties (e.g., if your game requires 20 levels, and you want the die-size to change each level). One way around this is by allow different sizes of dice in the same roll (e.g., at level 1 there's a pool of d10s, but at level 2 there's 1d8 plus one less number of d10s as at level 2, and so forth).

Putting these mechanics all together

Increasing the mean value with level is not a problem. However, increasing the mean value while simultaneously decreasing the variance as noted above requires an adjustment to the mean to compensate for the variance adjustment. For example:

• Using a constant increase in mean, say Z (increases by 1 each level e.g., 1, 2, 3, etc.), with an incrementing factor, say X (increases by 1 each level e.g., 1, 2, 3, etc.) to decrease variability (assume that 4 dice give a bell-enough shape for you). Then you might use: 4d6÷X + (4×3.5)÷X + Z.

• Too much math! Let's use die-sizes! Using a constant increase in mean, say Z (increases by 1 each level e.g., 1, 2, 3, etc.) and decreasing die sizes to decrease variability (assume that 4 dice give a bell-enough shape for you). Then you might use: 4d10 + Z at first level, and at each level decrease one of the dice by 2 (e.g. 1d8 + 3d10 at 2nd, 1d6 + 3d10 at 3rd, etc.—incidentally 2d8+2d10 has the same mean as 1d6+3d10). But wait! We still have to account for the mean value of the dice roll decreasing when we decrease a die size: therefore DICE + Z + Y, where DICE decrease size with level as just described, Z is your constant improvement with level, and Y is the number of die decrements.

• There are other creative ways to do this, depending on your needs.

How granular do you need the system to be? It can be achieved by reducing the size of dice rolled and adding a constant.

Unskilled: 3d12
Skill 1: 3d10+6
Skill 2: 3d8+12
Skill 3: 3d6+18
Skill 4: 3d4+24
Skill 5: 3d3+27
Skill 6: 3d2+30

This produces a pseudo-bell shaped distribution, an increasing mean, and a decreasing variance without requiring large numbers of dice or complicated manipulations but it limited in the number of skill steps it allows.

(Any dice demonstration)

The means of rolling dice should have two distinct properties:

1. Expectation increases as skill increases.
2. Variance decreases as skill increases.

Further, the distribution should resemble a bell curve; it is not quite clear what this precisely means.

It is easiest to implement conditions 1 and 2 separately; condition number 1 is satisfied by using a system such as skill + something random (with, say, fixed expectation).

The easiest way to satisfy condition number two is to discard some dice - take highest, take lowest, take median, etc. The resulting distribution is not a bell curve in the sense that it probably does not converge to the normal distribution (even after the necessary scaling), but it does have several similar properties.

Example: (1 + 2 times [skill])d10 + skill, but ignore an equal number of lowest and highest results so that you only sum three dice.

With skill 3: Roll 7d10, ignore 2 highest and 2 lowest. Add 3 (the skill) to the total.

This distribution probably does not converge to the normal distribution (though I haven't checked), but it gives greater weight to average than to extreme results, is symmetric with respect to the average, the variance decreases with skill and the expectation increases. The die size is arbitrary; use d6 or d20 if you will.

For smaller number of dice but the same idea: Use skill + random part. Random part is taking the three middle results, as above, but the number of dice is the largest odd number smaller than or equal to the skill.

So: with 1 or 2 skill, only roll one die. (Or give a minimum of 3 dice.) With 3 or 4 skill, roll 3 dice. With 5 or 6 skill, roll 5 dice, ignore the highest and the lowest, sum others. With 7 or 8 skill, roll 7 dice, ignore the two highest and the two lowest.

If desired, you can go with even a smaller number of dice by modifying the skill by halving, taking a square root (or use any other increasing function) and then capping the number of dice to the next odd number. Better to create a look-up table for the number of dice if you use something complicated.

The square root version, for example: With skill less than 1-24, use 3 dice. With skill 25-48, use 5 dice, ignore highest and lowest. With skill 49-80, use 7 dice, ignore two highest and two lowest.

This is likely to be too extreme, as the random factor is quickly overwhelmed by the constant, but I hope it serves as an illustration of a nonlinear scaling.

If you want to pretty much use the answer given by Jack Aidley but want more levels of skill possible, you can add more skill gradations by changing out one die at a time rather than the whole set:

• Unskilled: 3d12 (range 3-36, average 19.5)
• Skill 1: 2d12+d10+2 (range 5-36, average 20.5)
• Skill 2: 1d12+2d10+4 (range 7-36, average 21.5)
• Skill 3: 3d10+6 (range 9-36, average 22.5)
• Skill 4: 2d10+d8+8 (range 11-36, average 23.5)
• ...
• Skill 18: 3d2+30 (range 33-36, average 34.5)
• Skill 19: 2d2+32 (range 34-36, average 35)
• Skill 20: d2+34 (range 35-36, average 35.5)
• Skill 21: 36 (range 36-36, average 36)

At the early levels, make a die two smaller and add two (thus increasing minimum by 2 and average by one), and at the late levels make a die one smaller (from d4->d3 or d3->d2) and add one (thus increasing minimum by 1 and average by 0.5) to get 19 levels of skill. You can also extend a bit further by eventually removing a d2 and adding 2 (which you can think of as changing a d2 to a d1+1, where a d1 is a one sided die that always just rolls a one), giving you 22 effective skill levels (if you don't mind that maxed out folks always just roll 36); if your game wants even more skill levels and you are using a die-rolling program rather than physical dice, start it off with d14 or d16 or d18 or d20s, or if you want to keep physical dice start with 6d12, and when that has gotten to 6d6+36 you have a few levels of replacing 2d6 (2-12 average 7) with d10+2 (3-12 average 7.5) (which is not quite the same range and average change as the levels before and after it but is fairly close); at that point you should have plenty of available skill levels for most games.

You could change the size and number of dice as skill increases. Unfortunately, it's not going to give you a nice and smooth change, as well as giving you a horrendous amount of dice, as skill increases.

If we take "the common dice" to be d2 (can be simulated by any dice), d3 (simulated by d6 or d12), d4, d5 (simulated by d10 or d20), d6, d8, d10, d12 and d20, the least common multiplier is 120, so we could go from 6d20 at the lowest skill level to 60d2 at the highest.

• All in all, I am not convinced this is a practical way of doing it, but it does provide an answer and looking at the result curves gives a rather vicious narrowing of the variance, as well as an increasing mean. – Vatine Dec 6 '16 at 10:14

If you really need a high middle and smaller variation with each sequential increase you can take the middle results of a odd number of die rolls. This procedure lets you achieve roughly the same mean and a small variation:

Formula: middle KEEP of ((SKILL*2)+KEEP)d10] named "Rank [SKILL]"

Result:

http://anydice.com/program/a0a5

And if you want to increase the mean you can then add the Skill value to the result, shifting the graph to one side.

Formula: [middle KEEP of ((SKILL*2)+KEEP)d10]+ SKILL named "Rank [SKILL]"

Result:

http://anydice.com/program/a0a4

I've used the D12 (to make @nitsua60 happy) d10 to allow a minimum number of Ranks in AnyDice (blocks execution bigger than 5 sec), and with a limited number of dice you will have similar results with different ranges.

In my system we use d20 with two variations of this method, the values of which I'll show in the example at end. These variations are based on success count and difficulty range, they're based in the d20 to allow a large range of probabilities, allowing lower level and high level characters to have chance to win or lose, only varying the frequency.

Basically the formulas are [with the constants i used]:

Define a base number: 3

Roll a number of dice equal: Base + (Skill * 2)

Take away Skill number of highest die: [when Skill = 2 take two highest]

Take away Skill number of lowest die: [when Skill = 2 take two lowest]

You will end with the Base Number again: [in this case 3d12]

Add the skill value to the result (to cause shifting): [when Skill = 2] 3d12+2

Example Case: middle KEEP of ((SKILL*2)+KEEP)d10]
Dice Type: d10
Base Dice Number [KEEP]: 3
Skill Level: 2

Roll -> (Skill * 2) + KEEP
-> (2 * 2) + 3 = 7 Dice
Take Away -> Highest SKILL Number of Dices
-> Highest 2 Dices
Take Away -> Lowest SKILL Number of Dices
-> Lowest 2 Dices
Calculates the Result -> 3 Dices


Sample: Rolls 7d10 [ 2, 3, 5, 6, 6, 7, 8 ]

Result: 5 + 6 + 6 = 17;

Using the SHIFTING variance:

Sample: Rolls 7d10 [ 2, 3, 5, 6, 6, 7, 8 ] + SKILL

Result: [5 + 6 + 6] + 2 = 17 + 2 = 19;

I enjoyed looking at this in the most efficient manner possible. Noob to gaming here, but not to solving problems, and this one was fun. Another user (@Lexible) mentioned using decreasing die sides. With some tweaking, this definitely works, and with amazing results. I wrote an AnyDice program (https://anydice.com/program/11795) to exemplify the below.

As a summary, the below is an example of one of the methods Lexible was mentioning.

• Level 1: 4d20
• Level 2: 3d20+1d12+constant
• Level 3: 2d20+2d12+constant
• ...

This constant shown above to make up for the difference in maximum values with smaller die, this is to keep the mean constant while increasing the precision of each roll. It is equal to (bigger die - smaller die)/2 + prev_level_constant. This can be seen in the below image:

By starting with 4d20s down through 4d2s (simulated w/ a d4) you can get a set of 25 levels. Starting with 3d10s down through 3d4s, you can get a set of 10 levels (shown below):

You can add a simple skill modifier that will increase the mean in a consistent manner, as shown below:

The AnyDice code, for the curious, is below as well, in the event we need another site, the logic is here:

DIE_SIZES: {10, 8, 6, 4}\set this to desired level\
NUM_DIE: 3\combines with this to make desired number of levels\
ADD: 0\initializer, don't change\
SKILL: 5\skill simulator, used to increase mean\

\black box, don't change\
loop N over {1..#DIE_SIZES}{
loop M over {0..NUM_DIE-1}{
if N!=#DIE_SIZES{
output (NUM_DIE-M)d(N@DIE_SIZES) + Md((N+1)@DIE_SIZES) + ADD named "Lvl N"
}
if N=#DIE_SIZES & M=0{
}
}
}


Hopefully this is a good answer, I had a heck of a time determining what the best way to reduce the die by but still maintain the mean, and always have a decreasing deviation was. Thank you for the challenge, and please let me know if you have questions!

start off with 5D10

for each skill level you get an improvement point.

For 1 point you are allowed to replace one dice with a d8+2. Spend as many points this way as you want.

For two skill points you replace a d10 with d6+4.

With three you can replace a d10 with a d4+6.

With four you can replace a d10 with a d2+8.

Obviously, you can vary the number of initial dice as you see fit depending on how important reducing adding versus having a bell-curve is to you.

Are you looking for something that can be applied at tabletop scenario? Adding up lots of numbers is not really practical. 5d6 could be fine - couple times - but it quickly gets annoying. This question would be relevant, and I'll take 3d6 as a maximum we should not exceed.

If you indeed want to get your bells narrower then adding dice is pretty much the way to go. However, you can not add dice past 3d6, and limiting yourself to 1 dice, 2 dice and 3 dice (d20, 2d10, 3d6?) looks pretty limiting. As an alternative, you can ditch adding up numbers and use either FUDGE-like dice (d3, +1 0 -1) or coins (or some other fancy way of getting a d2).

If you do this, using more dice with higher skill is not really a problem - instead of counting dots on couple d6's, players would count green dots on the table with a maximum of 1 dot per dice. You can easily use several times more than 3 dice in this setup.

However, there comes a problem that bell got relatively narrower, but in absolute numbers it's actually wider. Here, you can normalize - divide number of successes by number of dice rolled and you have something that is fixed between 0 and 1, with stddev diminishing with skill.

## So, skill + 12 * (skill d2/skill). That is, roll number of d2s equal to skill, divide by total number of dice rolled, multiply that by 12 and add to skill.

Examples:

• Alice has skill of 2. Her roll will be 2 + 12 * (2d2 / 2), so 2/8/12 with chances 1:2:1, so 8 half of the time.
• Bob has skill of 4. His roll will be 4 + 12 * (4d2 / 4), so 4/7/10/13/16 with chances 1:4:6:4:1, so between 7 or 13 88% of the time.
• Carol has skill of 8. Her roll will be 8 + 12 * (8d2 / 8), so 8/10/11/13/14/16/17/19/20 with chances 0.4:3:11:22:27:22:11:3:0.4, so between, say, 13 and 17 82% of the time.
• Dolan has skill of 12. His roll will be 12 + 12d2, so between 28-23 85% of the time, between 17 and 19 61% of the time.

here's the AnyDice demo. Forbidden values (you can not roll a 24 with a skill of 9) drive their graphs crazy though.

That's using plain d2. Another option with d6 having, say, only 2 sides painted as 'success' could give better results.

• Yes, something that is practical on the tabletop. – oconnor0 Dec 5 '16 at 23:31
• Can't you make a d2 with six sided dice by checking odd/even? – KorvinStarmast Feb 12 at 14:49

Another, very simple, solution is one that I am using in my future game creation. It is similar to many of those above with one change: you want to roll low.

So, there is an "Experience/Luck" die, Attribute dice, and Skill dice, that range from d12 to d4 (the lower the die type the better) . And when you make any skill check, you roll the Skill Die + it's "ruling" Attribute Die + the Experience/Luck Die. This makes a very nice bell curve and everyone has a chance to roll a 3, though much less likely for 3d12, for instance. It also allows for a large range of upgrading (between the Attributes and Skills). And, as the characters gain experience they can either automatically lower their Experience Die.

Now, other conditions and things give you "advantage" or "disadvantage" up to 3 in any direction. If you have one disadvantage, for instance, you roll your experience die twice and take the higher, then, your attribute die + skill die. If you have two disadvantages you roll experience die and attribute die twice keep the higher of those dice, each, and then roll your skill die, etc.

Here is an image of just the numbers going from 3d12 to 3d4 (there will obviously be varying combinations in between).

• You might want to add explicitly that a lower result is better in this system. – Erik Sep 6 '18 at 5:12

Alternate approach make low good and high bad.

Now roll a number of dice equal to X minus the skill level.

Or make the sides of the dice 12-2*skill level.

Or do a mixture of the two.

The fact that low is good removes a lot of the fiddliness involved in compensating for smaller numbers of sides on the dice.

# 2*skill + (20-skill)d2

Number of differnt dice is pretty limited, so you'd have to use different numbers of dice too, which gets impractical after around 3d6. Thus, with common dice you won't get finer control over distribution.

Instead, you could use bunch of d2s - to replace adding up numbers with counting successes. You just throw a bunch of red-green coloured tokens (or whatever colours you prefer) and count the good ones.

You can think of that as if task was giving the character many opportunities to screw up, but the more skilled the character is, the more pitfalls he would evade automatically.

Here's how it looks for skills 1-15:

AnyDice demo

• Is this not basically a variation of my suggestion that uses a different die? – Weckar E. Dec 8 '16 at 17:15
• @WeckarE. I've realised that formula in my other answer looks pretty intimidating and have came up with another one, that looks better but still uses lots of d2's. If anything, your answer is a variation of my other, which was posted before. Also, you almost definitely should not use stuff like 10d10 regularly. – Daerdemandt Dec 8 '16 at 18:54

# Your best bet is a system that uses Dicepools

In Storytelling system, which used in Vampire: The Masquerade, Werewolf: The Apocalypse and other White Wolf settings each time you need to roll, the Storyteller (=gamemaster) announces the Difficulty of the action and skills involved. For example, trying to shoot someone with a pistol is Firearms+Dexterity, Difficulty is 6. It means that the player sums up Firearms of his character (let's say, 3) and Dexterity (let's say, 4): it is his Dicepool for the given check, 7 in this case. If he would try to heal someone, might be Intelligence+Medicine.

He then rolls this amount of D10, and each result that equals Difficulty or is higher is a Success result, each result that is less than Difficulty is a Fail, and each "1" on a die is a Botch. If Difficulty is 6, it doesn't matter if you roll 6, 7 or 10, anything is a Success, and both 3 and 5 are equal Fails.

If there are any successes, you count them, and deduct the amount of botches. That is your amount of success for this roll. If at least one is left, you succeed in the action. Based on how many successes did you get, you may succeed better or worse.

If there are no success dice at all and no "1" dice", the roll result if a Fail. Nothing happens. You missed and didn't hit the target, you failed to repair the car, etc.

But if there are no success dice and at least "1" at the same moment, it is a Botch. Not only did your pistol misfire, but it also jam. Not only did you fail to repair the car, seems like you also broke something beyond the ability to repair it. Not only did you not heal the patient, you also made the wound worse, etc.

Here is my AnyDice program that you may use to view probability curves. It is well-commented, so shouldn't be hard to understand it. As you may see, the bigger dicepool you have (the better your character is supposed to be at doing something), the more is the average amount of succeess dice (better performance) and stability (becomes unlikely to have a Botch).

Of course, I am not forcing you to use Vampire, but a dicepool-based system seems to be what you need.

P.S. You basically mentioned a dicepool-based system in your question:

• Count 4+ in (Skill)d6 increases accuracy with skill but precision decreases as skill increases.

But that's actually not completely right. The more dice you have, the lower is your probability to fail the task. Yes, standard deviation increases, but far slower than mean does. Watch the Summary tab. If you change 4 for some other number, let's say, for 2, you may notice that deviation also decreases. Character performance in an easy task is more predictable than in a hard one.

Botch mechanics from Storytelling system also improve the situation. But that's another story.

• Right, I do not want increasing standard deviation. That is why my reference to a dicepool system rejected that version of it. – oconnor0 Dec 16 '16 at 19:01

Here's an off-the-cuff idea. I think it meets your requirements, but it comes at a cost: the traits you roll against become two-dimensional quantities, rather than one-dimensional numbers.

For a simple example, let's call these two dimensions "Power" and "Precision". Power is the number of dice you roll, and Precision is the type of dice. The range of Power might be one to six dice, and the possible values of Precision are d10, d8+2, d6+4, d4+6, d3+7, or d2+8.

Rolling with Power 4, your maximum value is always 40.

• With d10 Precision, your minimum is 4, and your mean is 22.
• With d8+2 Precision, your minimum is 12, and your mean is 26.
• With d6+4 Precision, your minimum is 20, and your mean is 30.
• With d4+6 Precision, your minimum is 28, and your mean is 34.
• With d3+7 Precision, your minimum is 32, and your mean is 36.
• With d2+8 Precision, your minimum is 36, and your mean is 38.

You could, of course, use a mixture of Precision dice in a single roll to tune mean and variance, but this might well be more complicated to add up than is worthwhile.

I've studied this very topic in a lot of depth, up to giving presentations on it at gaming conventions. Most of it is in German, but here's my write-up of a reasonably simple dice system that satisfies all the criteria:

### Summary (from the linked .pdf file)

To define "realism" in game-mechanical terms is fairly difficult, but a baseline can be summed up as:

• higher skill should always lead to higher success chances
• higher difficulty should always lead to lower success chances
• higher skill should lead to more reliable results (higher consistency of results, less spread)

{Example}:
* players roll 2-10 dice, based on their skill or whatever.
* the GM sets a difficulty level
* players sum up only the two highest dice rolled and compare it to the difficulty level to determine success or failure
* for opposed tests, instead compare the result of the two opponents directly * add various tweaks and complications as you like

Story Points / Karma

In Dragon Brigade they are called "Story Points." In other games, they are called Karma or Fate Points or something similar. Anyway, if the players have a kind of "thing" to turn things their way, then each point spent this way allows them to add the next-highest die. Spend one {Story / Karma / Fate, etc} Point and you can add the 3rd highest die to your total, etc.

Even with unlimited story dice (a) your skill level still limits you and (b) a total beginner still has a low chance to get great results!

Sorry for the external link. There are numerous graphs and tables in there that I can't insert easily into an answer. The above is one example showing how it works with 2d10.

There's also a bit of commentary on it here, with a link to a video of my presentation: http://indie-rpgs.com/adept/index.php?topic=1126.0

Building on Weckar's answer:

I have found a system that checks all boxes, including getting rid of the computational burden of adding too many dices.

## Some Motivation

I would like to add why I think this system is an improvement over other suggestions given here, including the accepted answer. Rolling a number of dice and keeping the two or three highest ones does result in bell curves with increasing means an decreasing variances. However, a major drawback of them is that the means do not increase linearly. This results in multiple challenges:

• The utility of taking a skill rank decreases with its progression. Let us say that the system in question is roll (2+skill) dice and keep the highest two. The value of taking the next skill rank decreases with the currently held rank, i.e. if skills range from 0 to 10, going from 0 to 1 provides a great improvement (as we now roll three and keep the highest two), while going from 9 to ten provides virtually no improvement, as we are almost guaranteed to roll the highest possible number twice in 11 as well as 12 rolls. This is well exemplified in the graphics in Tom's answer. We see that slope the curve of the mean decreases with skill level and saturates. This is, as mentioned, bad, since the utility of skill increase decreases with its progression.

• This makes it hard to balance the game for the GM, since encounters and the like need an (approximate) comparability of characters across various skill levels.

• This makes character progression intransparent to players, as it is kind of unintuitive what you are getting when you buy yourself a skill point.

This leads to the following

## Requirements

• mean of result scales linearly with skill rank
• variance of result decreases with skill rank. Ideally also linearly, but here it is not as important.
• The system is simple, intuitive and easy to use, including low computational burden on players, a reasonable amount of dice per roll. Also, rolling under and taking maxima is preferred to rolling over and taking minima (at least in my opinion).

# Example System

This system is applicable for any dice and any range of skills, but I first give an example an then the general system.

### Skill Ranks

skills range from 0 to 8, ranks 6-8 being (usually) unattainable for players (in order to keep some minimum variance).

## Die rolls

the player rolls (8-skill) d12 and counts the number of dice that came up 8 or higher. This is the (provisional) number of successes. Then he adds his skill rank to obtain the total the number of successes.

### Evaluation

this total number of successes needs to beat some overall difficulty, ranging from 1 to 8.

### Note

This system works well with WoD type character sheets where you would have 8 boxes, and you fill a number of boxes equal to your skill rank. Then you roll the empty boxes against 8 and add the filled boxes.

# General System

### parameters:

$$\s\$$: skill level

$$\c\$$: skill ceiling

$$\x\$$: type of dice

$$\dif\$$: difficulty for individual rolls

$$\s + \left[\left(c - s\right)\text{d}x \geq dif\right]\$$ is the number of successes, and the necessary number of successes is set by the GM.

You can freely chose all these parameters and calibrate difficulties to you liking.

• average number of successes proportional to skill level and is defined by the skill rank

• variance of number of successes antiproportional to skill level and is defined by the ratio between the type of die and the difficulty of individual rolls

• result is resolved in one roll with comparison and very simple addition - no computational burden on the player

• intuitive system with high rolls and high numbers of successes being good, and the converse being bad

• for each skill level there is a minimum number of autosuccesses, i.e. some tasks succeed automatically - some people might dislike that.

• low resolution of difficulties at very high skill levels. I mentioned that the last three skill ranks should not be attainable by players because the range of possible successes becomes rather small. This can be alleviated by altering the difficulties of individual rolls by the GM. However this would add additional complexity, albeit only on the GM's side, making the difficulties essentially two-dimensional (difficulty of individual rolls x the necessary number of successes). But for normal play the difficulty of individual rolls should stay fixed.

## Do Not Forget to Have Fun

This was a nice puzzle for me, and while I am very confident that this system could be successfully implemented in an RPG and fulfills all requirements, I have not playtested it. While other systems might have their imperfections, if they have been published, there is a good chance that they were heavily playtested beforehand. The main criterion in such a playtest would be how fun to play with the system is. And this is something that I can't say at this point. Maybe it turns out that the increasing consistency actually kills the fun players would be having with more "chaotic" dice mechanics. This, and not the statistics should ultimately decide whether a dice mechanic should be adapted or not. Even using this system, it needs to be carefully calibrated to fit the game that you want to play.

Some figures below:

• Welcome to RPG.SE! Take the tour if you haven't already, and check out the help center for more guidance. Good first answer! – V2Blast Feb 12 at 7:33
• Thx for editing! – ge0rg Feb 12 at 13:45

## protected by Oblivious SageFeb 11 at 21:20

Thank you for your interest in this question. Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10 reputation on this site (the association bonus does not count).

Would you like to answer one of these unanswered questions instead?