Using the formulas I give further down we can compare the odds of hitting using opposed rolls to normal attack rolls across a wide range of *Attack – (AC – 10)* values:

For most attack bonus and AC combinations, both methods give very similar results (within 5% of each other). At the extremes, the difference between both methods grows to 6-10%, with one particular combination (e.g. attack +8 vs 10 AC) producing a difference of 11.5%

However, these extreme cases should be rare. Attack bonuses for players usually range from +3 (2 prof bonus + 1 ability mod) to +13 (6 prof bonus + 5 ability mod + magic weapon or fighting style bonuses). For monsters, attack bonuses usually range from +3 at CR 0 to +10 at CR 20 (*Dungeon Master’s Guide* p.275).

Player AC usually ranges from 10 (no armor, 0 Dex mod) to 20 (full plate + shield) and monster AC from 13 to 19 (*ibid.*) All the creatures in the Monster Manual with an AC higher than 20 also have CR higher than 20, and even the CR 30 Tarrasque maxes out at 25 AC.

By the time characters have attack bonuses as high as +8, they’re probably not fighting 10 AC monsters with any regularity. Additionally, players with extremely high attack bonuses will probably invest in Great Weapon Fighting or Sharpshooter for extra damage, which brings their attack bonus back down.

Likewise, it’s unlikely that a monster will have much higher attack bonuses than player AC because monsters don’t have as many ways of boosting their attack rolls and players tend to invest into AC at least a little.

The red line in the graph can also be shifted up slightly by using *AC – 11* instead of *AC – 10*.

**On the topic of randomness…**

Since dice rolls are independent events, using two dice instead of one has no effect on the outcome of future attacks. Additionally, since there’s only two possible outcomes to an attack roll (hit or miss), it doesn’t matter how many dice are used to determine the result as long as the probability of hitting stays the same, or close enough for your purposes.

For example, suppose you were betting on the outcome of a coin toss; there’s only two possibilities and each is equally likely, so you have a 50% chance of winning.

Now suppose the game is changed to flipping two coins, and you bet on whether both coins will land same side up. There’s 4 possible outcomes, each equally likely: HH, HT, TH, and TT. However, you can win with 2 of those 4 outcomes, so your chance of winning is still 50%, just like when you were flipping one coin.

If you only knew the result (win or lose), someone could change from using 1 coin to 2 coins and you wouldn’t be able to notice, because your chances of winning stayed the same.

Every method of resolving attack rolls, regardless of how many dice you use, will boil down to producing hits with certain a probability. Any two methods that produce hits with the same (or close enough) probability are interchangeable. If the differences are small, it would take meticulous tracking of results across multiple game sessions for players to notice a difference.

## Probability for single rolls:

The odds of a *d20 + Bonus* being greater than or equal to *AC* is

begin{equation}

P = frac{21 + Bonus – AC}{20}

end{equation}

**Proof:**

Since every number on the die is equally likely, we can get the probability of hitting by counting the number of rolls that can hit and dividing that by the number of possible rolls (20).

Since the highest total we can roll is *20 + Bonus*, subtracting the highest total that can miss (*AC – 1*) will leave us with the number of rolls that can hit: *20 + Bonus – (AC – 1) = 21 + Bonus – AC*

*Example*: With an attack bonus of +2 and an AC of 20, there’s only three rolls that result in a total of 20 or higher: 18, 19, or 20. The formula correctly gives *(21 + 2 – 20)/20 = 3/20 = 0.15*, or *15%*.

## Probability for opposed rolls:

If the attacker has a roll modifier of *X* and the defender has a roll modifier of *Y*, the odds of the attacker rolling higher is:

begin{equation}

P = begin{cases}

(20 + X – Y)(21 + X – Y)/800 & text{if X $leq$ Y}

\ 1 – (19 + Y – X)(20 + Y – X)/800 & text{otherwise}

end{cases}

end{equation}

**Proof**:

Since each number on one die is equally likely to come up, every combination of numbers is equally likely when rolling two dice. Figuring out the number of combinations that result in a hit is tricky, but looking at the table of possible outcomes (taken from this answer in Mathematics Stack Exchange) gives us some insight:

begin{array}

{c|cccccc}

&1&2&3&4&5&6 \ hline \

1&=&<&<&<&<&< \

2&>&=&<&<&<&< \

3&>&>&=&<&<&< \

4&>&>&>&=&<&< \

5&>&>&>&>&=&< \

6&>&>&>&>&>&= \

end{array}

(This table is for a d6, but it’s not hard to see that the pattern would be the same for a d20.) When both sides have the same modifiers, the combinations that result in a hit (the *>* and *=* signs) form a triangle whose sides are as long as the table (20 rows and columns).

If the attacker’s modifier is *x* points lower than the defender’s modifier, the triangle shrinks by *x* units:

begin{array}

{c|cccccc}

&2&3&4&5&6&7 \ hline \

0&<&<&<&<&<&< \

1&<&<&<&<&<&< \

2&=&<&<&<&<&< \

3&>&=&<&<&<&< \

4&>&>&=&<&<&< \

5&>&>&>&=&<&< \

end{array}

So when *X â‰¤ Y* the sides of the triangle have length *20 + X – Y*. Fortunately there’s a handy formula for counting the number of characters in this triangle: *n(n + 1)/2*, where *n* is the length of the triangle’s sides. Replacing *n* with *20 + X – Y* gives *(20 + X – Y)(21 + X – Y)/2*. Dividing that the total number of possibilities (*20 * 20 = 400*) gives us the first part of our function.

If the attacker’s modifier becomes positive, we get a similar table:

begin{array}

{c|cccccc}

&0&1&2&3&4&5 \ hline \

2&>&>&=&<&<&< \

3&>&>&>&=&<&< \

4&>&>&>&>&=&< \

5&>&>&>&>&>&= \

6&>&>&>&>&>&> \

7&>&>&>&>&>&> \

end{array}

The *>* and *=* signs no longer form a triangle, but we can count the number of *<* signs (i.e. the roll combinations that miss) and subtract the result from 100% instead. The formula is the same except the triangle length starts at 19 instead of 20 since we’re no longer including the *=* signs.