Thinking about Mechanics: Attack Rolls

     Wow, it has been quite a bit since my last post. My new schedule is pretty hectic and the posts I really want to make are going to take more time than I seem to have, so instead I will write this apparently simple post instead.

    I recently came across a post on Delta's D&D Hotspot that I found very interesting. I will quickly summarize the post for anyone who doesn't feel like reading it (I recommend reading it). In short, the formula OD&D uses for determining if someone hits someone else in combat can be written as:

d20 roll + mods >= 20 - level - AC

    From there, this can be trivially rearranged for a variety of different systems, including what 5e D&D uses:

d20 + level/bonus + mods >= (20 - AC)

    In this schema level is replaced with your appropriate bonuses and AC is the hidden THAC0 AC that still sort of underlies the system. (20-AC) is how you convert that THAC0 AC to be the modern ascending armor. For another fun example, here is how this could be rearranged for a roll-under system like the one used in GLOG:

d20 <= 10 + level + mods - AC

    All this is fun, but the post then goes on to lay out a few psychological traits about humans doing mental math:

1. Addition is easier than Subtraction
2. Round numbers (ie 10s) are easier to compare than odd numbers (ie 27)
1. Also, comparing digits that are far apart is easier (ie 2 & 9 vs 5 & 6)
3. Smaller numbers are easier to compare (ie 1 & 2 vs 8 & 9)

    Now from those traits, Delta does a nice and simple proof to show that the following equation for calculating attack rolls is the best since it best follows the above principles:

d20 + level + mods + AC >= 20

    Having gone through this proof, I do believe that this is a good result and the proof does hold together. However, I do not believe it is necessarily the optimal result. There are a few reasons for this that come to my mind:

1. This assumes the system uses Descending AC which is not necessarily as intuitive as Ascending AC
2. People remember the results of their math, at least to a degree, which will change how people interact with the equation
3. There are tables/DMs that do not like to share the AC of monsters with the players
4. This assumes that a roll-over system better than (or at least equal to) a roll-under system

    To me, the most important point is #2. It is easy for characters to bundle together levels, mods, and AC into a single number that they then add to the the d20 roll. In general, D&D combat is very homogenous in terms of AC. Against a lone monster, its AC doesn't tend to change. Groups of enemies also tend to share identical AC with only a couple exceptions for elite monsters or monsters with different armor or such. Basically, what this means, is that you can expect players to bundle together as many additions and subtractions as they can together so that they have to do the math less.

    When this bundling is possible, the equation Delta came up with looks something more like this:

d20 + bonuses >= 20

    Looking at this from the perspective of an algorithm this means that in most situations, players will roll their d20 add their temporarily memorized total bonuses and compare it to 20. This is still incredibly efficient based on the principles that Delta laid out, but it ignores a different method of optimizing these calculations: reducing the number that need to be made at all.

    Combat is almost never done in a single attack roll. It involves multiple rolls by a number of parties over the course of a few rounds. Delta has reduced the mental workload of any single calculation to its bare minimum, but I do not believe they have reduced the total workload as much as they could have. The reason for this is that only one part of this equation is not constant: the d20 roll. By virtue of how rolling dice work (and assuming bundling of math), there are three steps performed every time: roll, add, and compare.

    If, however, you assume bundling (either implicitly or by explicitly putting it in the rules) there is a more efficient method: moving all of the bonuses to the right side of the equation. By bundling all of the numbers into only one thing, making an attack roll only has two steps: roll and check. Rearranging Delta's equation, and showing things without bundling, we get:

d20 >= (20 - level - mods - AC)

    Obviously, as a single calculation this is objectively worse than Delta's equation; it is entirely subtraction. However, as an algorithm of just calculating this once and then comparing a single number, it might be more efficient in the long run. With Delta's equation, you could expect to do the calculation and then simple addition a few times, probably 3 or 4. As long as this calculation takes less time than the old one with a few more additions, it is better in the long run. Unfortunately, there really isn't a way to calculate that with any good amount of rigor. Instead, this equation can be worked on so that it includes a similar amount of work to the old one and then it will have to be more efficient, since it doesn't have any extra additions after the initial calculation.

    There are a few options available for this, but the most practical ones are to switch to Ascending AC or to switch to a roll under system. If we switch to an Ascending AC, the equation becomes:

d20 >= (10 + AAC - level - mods)

or

d20 >= (AAC - level - mods)

    The reason I wrote out two options is because there is some debate over whether Ascending AC should include the added 10 inside of itself already (basically is AC 5 or 15). This method either turns one subtraction into an addition or it entirely removes one calculation. Using the second equation, the question of efficiency basically comes down to: does doing 2 subtractions instead of 2 additions add more or less mental work than doing 3 or 4 additions. I suspect the answer is less, but I am also someone who is very comfortable with math. Others might disagree.

    That is why I believe a roll under system is the best option:

d20 <= (AC + level + mods)

    It turns the bundled calculation into only addition and actually is the exactly same calculation you would do with Delta's method, meaning it has to be more efficient, since doing things this way eliminates multiple other additions.

    As a bit of anecdotal evidence that something like this is how people like to do things, I have been in multiple games with people who have said "You need to roll at least a X to hit!" or some variation thereof. In 5e, this requires subtracting someone's bonuses from the target's AC which isn't the simplest math possible, but they did it because then people needed to only remember a single number to see if they hit or not. Perhaps this is an outlier and I play with weirdos. Totally possible.

As always, I would love to hear people's thoughts on the matter in the comments!