What is the Best Combat Algorithm?

Figure thinking with question mark

Throughout the history of D&D and RPG's (and more generally, any action/wargame), there have been a host of different algorithms to determining success in combat and other feats of skill and luck. For example: to-hit-tables, THACO, compare to increasing AC score, etc.

Within some very small tolerance for error (say +/-1 difference), all of these systems have been mathematically equivalent (i.e., result in "hits" for the same rolls of the d20 die). But which is the best algorithm? That is, treating the tabletop gamer's brain as a kind of natural "computer", which is easiest/ fastest/ most efficient/ least error prone? Is it one of the aforementioned algorithms, or something different?

First, let's establish the different components of the basic D&D "to hit" (or anything else) roll. They include: (1) a d20 die roll, (2) a basic attack proficiency, by class or hit dice, (3) the armor of the defender, (4) miscellaneous modifiers (positive bonuses being good for the attacker), and (5) the "baseline" chance to succeed at hitting, irrespective of other modifiers #2-4.

Let's look at one example, say, the THACO mechanic from 1E-2E. In the form of an inequality, the basic algorithm is:


* The THACO was itself determined (pre-game time) from tables in the core books. But in essence, for fighter and monster-types, this incorporated the "baseline" success chance (Normal Men need to roll ~20 vs. AC 0) and a +1 bonus per fighter/monster level. In other words, THACO = (~20 - level). Let's substitute and see all 5 terms plainly:

THACO ALGORITHM: d20 + mods ≥ 20 - level - AC

Now, if we proceed to search for other, variant algorithms, we can apply the basic algebraic "rebalancing" operations to make any of these terms appear on either side of the inequality that we wish. For example, we could add a "level" term to both sides (canceling it on the right and appearing as an addition to the left). Or, we could subtract the "mods" from both sides (thereby appearing as a subtraction on the right).

In fact, since there are 5 terms, and each can appear on either of the 2 sides of the inequality that we wish, there are in fact 2^5 = 32 different formats for this inequality (by the fundamental principle of counting) that we could consider. Here are just a few of those 32 possible variations:

TABLE ALGORITHM: d20 + mods ≥ (20 - level - AC)
[Encapsulated in table]

THACO ALGORITHM: d20 + mods ≥ (20 - level) - AC
[Encapsulated in THACO]

d20 SYSTEM ALGORITHM: d20 + mods + level ≥ (20 - AC)
[Defined as New AC]

"SUBTRACT ALL" ALGORITHM: d20 ≥ 20 - level - AC - mods

"GO NEGATIVE" ALGORITHM: 0 ≥ 20 - level - AC - mods - d20


Now, obviously, those last few were for humorous illustrations only, and I assume not many people would want to use those systems. But what criteria can we use to choose the "best" possible system? Let's consider the following as guiding principles (and we'll back each of them up with results from experiments in cognitive psychology as we proceed):

(1) Additions are easier than subtractions.
Although mathematically equivalent (and using fundamentally the same operation in digital computing systems), most people find subtraction significantly harder than addition. For example, addition is commutative (the order is irrelevant) whereas subtraction is not. See the paper by MacIntyre, University of Edinburgh, 2004, p. 2: "Addition tasks are clearly completed in a much more confident manner than the subtraction items, with over 80% of the study group with at most one error on the items. Subtraction items appear to have presented a much bigger challenge to the pupils, with over 50% having 3 or more of those questions wrong." See also Kamii et. al. 2001.

(2) Round numbers are easier to compare than odd numbers. In other words, when comparing which of two numbers is larger (the final, required step in any "to hit" algorithm) it will be easier if the second number is "20" than, say "27". This follows from the psychological finding that it's faster to compare single digits that are farther apart; see Sousa, How the Brain Learns Mathematics, p. 21: "When two digits were far apart in values, such as 2 and 9, the adults responded quickly, and almost without error. But when the digits were closer in value, such as 5 and 6, the response time increased significantly, and the error rate rose dramatically..." In our case, setting the second digit to zero would maximize the opportunity for a large (and thus easy-to-discern) difference between the numbers.

(3) Small numbers are easier to compare than large numbers. This has also been borne out by a host of psychological experiments over the last several decades. Again from Sousa, p. 22: "The speed with which we compare two numbers depends not just on the distance between them but on their size as well. It takes far longer to decide that 9 is larger than 8 than to decide that 2 is larger than 1. For numbers of equal distance apart, larger numbers are more difficult to compare than smaller ones." Again, this is true for human computers only, not digital ones (ironically, the digital processor "compare" operation is really just an application of the same "subtract" circuitry).

Okay, so let's think about applying these principles to find the cognitively-justified best tabletop resolution algorithm. Applying principle #3 means that we'd generally prefer dealing with smaller numbers rather than larger. Before considering anything else, it's clear that it will be hardest for people to mentally operate in a d% percentile system, easier in a d20-scaled system, and easier still on a d6-scaled system. We should pick the easiest of these that gives the fidelity necessary to our simulation, and the d20-scale does seem like a nice medium.

We can also apply principles #2 and #3 to discard a key change brought about to D&D in the 3rd Edition: Ascending AC numbers. While it has its proponents (and is of course mathematically equivalent to all the other 32 permutations of the core mechanic inequality), it forces us at the end of our algorithm to run a comparison against a relatively large, and frequently odd, number, such as AC 15, or AC 27. By using instead descending ACs, they will always be a single digit (and therefore easier to manipulate according to finding #3), and we'll also see below that we can arrange a rule such that the final comparison is always run against a fixed, round number (and therefore preferred according to principle #2 as well).

Applying principle #1 indicates that we'd prefer to have all of our operations be additions, and do away with any subtractions (as in the THACO system). Returning to our 32 different options for presenting the basic resolution inequality, this is easily accomplished: simply add back all the terms on the right-hand side of the inequality, and all those terms become simple additions on the left. Having done this, we'll see that we're left with a nice round number to compare that addition to (fortuitously complying with principle #2, as mentioned above). We'll call this the "Target 20" algorithm:

TARGET 20 ALGORITHM: d20 + level + AC + mods ≥ 20

Now, you may have guessed where I was going with this if you'd read previous blog entries of mine supporting the idea. While never presented this way in TSR/WOTC core rulebooks, I'm quite confident that this is the most mentally efficient representation of the core d20-based resolution mechanic: Add d20, your fighter level, your opponent's single-digit descending AC, and miscellaneous bonuses; a number equal to or greater than 20 then indicates a "hit". It satisfies all of our 3 psychologically-verified guiding principles: (1) additions are easier than subtractions, (2) round numbers easier to compare than odd ones, and (3) small numbers easier to manipulate than large ones (particularly in the form of single-digit, descending ACs).

Like a lot of things in our hobby, the Original D&D rule was pretty close to optimal, but not quite perfect in this sense. If I won the lottery it might be interesting to definitively prove which method is best by running a series of psychological experiments; but since the result just follows from already-proven principles, I'd also want to set up a betting pool and recoup some of my money from the WOTC chief designers of the last several years.


  1. Don't be so confident that WotC would bet against you!

    I love the idea of a static target number. It offers up many, many situations where you don't even have to bother with the math, particularly if you eliminate negative ACs.

    Telling a player the target's AC might slow things down a little bit, but probably not any more than the player reporting an attack total and the DM declaring a hit or miss.

    1. It's awesome that Mike Mearls reads delta.

    2. That may have been a one-time thing, but it was quite nice that he commented. :-)

    3. Glad to see Mike Mearls keeps up with the OSR...

  2. Interesting stuff, and interesting to note that the version of the formula I settled on instinctively (d20+mods+AC >= THAC0) is very close to your "ideal" formula. It doesn't meet your criterion #2, because THAC0 isn't a round number, but it has other strengths IMO: because the THAC0 (i.e. 20-level) is pre-factored and static, not something that changes from encounter to encounter (and potentially even round to round) like mods and AC, we only need to factor it once, not every roll. It's not one of your criteria, but instinct tells me that fewer calculations is easier than more calculations, that 12 + 2 + 5 >= 17 is easier for most people than 12 + 2 + 5 + 3 >= 20. Also, pre-figuring the THAC) calculation keeps the numbers smaller, which is consistent with your criterion #2: a high level character might have 12 + 5 - 3 + 9 >= 20 under your system, while with THAC0 pre-calculated it's 12 + 5 - 3 >= 11. And last but not least, I prefer using THAC0 rather than your "level" value, because THAC0 is already in the books (well, it's not actually in the OD&D books, but it's easy enough to extrapolate) whereas "level" requires modifying and house-ruling, which I'm not totally averse to, but would just as soon avoid when I can.

  3. First: A disclaimer. I played for a very long time (both under what is now called "original" D&D and AD&D (mostly 1st) with descending ACs. Heck, we even used the modifiers for weapon versus armor type.

    But I also saw the switch to ascending armor class as a good thing when 3.x came out.

    I think that attempts such as this to redefine the THAC0 system into a 'better' formula fail for one simple reason.

    I think that they fail on actual use the in the game.

    Take your TARGET 20 ALGORITHM: d20 + level + AC + mods >= 20

    This only works (as a coherent formula) if the individual using the algorithm knows BOTH the 'level'(which isn't so simple as level because it varies according to class) and mods of the character, AND the AC of the creature being attacked.

    In short, it requires specific knowledge of every character and every monster in the combat*.

    On the contrary - a d20 system (and, in truth, the original THACo system) works better in actual play because each actor need only know their own part of the equation.

    And, in my opinion, of those an ascending AC system is preferable because it operates through addition - and because it deals with the better ACs (those that would be negative in a descending system but are merely larger numbers in an ascending system) in a more intuitive way.

    d20 AAC: d20 + 'level' + mods => AC.

    The player need only know his level and his modifiers.
    The DM need only know the creatures AC.
    And (although admittedly a minor point and only relevant in contrast to the case where the player is the 'user' of the algorithm) if there are modifiers of which the players are unaware the DM is able to apply them in secret.

    THACo, on the other hand, requires subtraction of AC from 20 (which by your argument above is not a good thing, although admittedly I never really had any problem with it).

    I.e.: d20 + 'level' + mods >= 20 - AC.

    In other words - if you want to use descending AC and involve the players in the rolling process (and avoid forcing the DM to handles each and every 'level' and modifier for each and every character - a desireable goal inmho*) your algorithm fails.

    THAC0/ Descending AC is, for this reason and imho, preferable to your algorithm and Ascending AC is preferable to both.


    *If, on the other hand, you are of the opinion that the players should not have access to these numbers and that the combat system should remain a black box and they give the DM a raw d20 roll and he tells them whether or not they hit OR that the ACs should be transparent and the DM should tell the players the ACs of all the opponents so they can plug them into your Target 20 Algorithm, then you will obviously come to a different conclusion than did I. However, in that case I think that both of these are atypical assumptions and should be stated up front.


    1. I know it's very late to comment on this, but the assumption being made is wrong. The player only knows their roll and their modifiers. They then tell their total to the DM who knows the AC and declares a hit or miss. Target20 is a great system I've used for years and does actually run faster than ascending AC for the reasons stated in this blog.

  4. Carl makes exactly the point I was coming here to comment, and perhaps more succinctly than I could. I too prefer the ascending AC system for the same reasons.

    I think it comes down to the fact that you must consider the source of the of the variables, and how easy each is to obtain. The d20 usually comes first, whether playing or GMing the die is already rattling around in my hand when it comes time to make my attack. Level and mods for the most part come from my character or monster's stats, likely on a piece of paper right in front of me. The AC, however, is external. I must query another human for that value. Therefore, I find it easiest to keep it on one side of the algorithm all on it's own, so I can calculate one side all by myself, and then query the other human for the AC value to compare to my result.

    For a GM, preference may boil down to simple GMing style. Do you as GM have all the player's ACs written on an easily accessible cheat sheet with your other materials? Do you announce the monster's AC to the players at the start of the combat? If both of these are true, I can see the benefit of the Target 20 system. AC is known ahead of time and thus easy to figure into the algorithm.

    I personally prefer to keep monster's AC secret. I keep a cheat sheet of the player character stats, but somehow it's never as handy as I'd like it to be. Thus, I find it easiest to ask a player "Does X beat your AC?" when attacking him, and him announce "I roll a total of X to hit." when attacking me for me to compare in secret to the AC value.

  5. Gar, Blogspot's OpenID support seems to have faltered, and is now reporting my name as index.php. Well done Blogspot. That former post was me.


  6. The correct solution involves more than that. For instance, there's no real need to add a variable most times, you can just line things up to sort out a fairly constant target number and compare it directly.

    d20 <= ToHit + AC + mods.

    You can roll any dice like that, d6 skills or anything, as some games do.

    OK, AC has to be higher when it's better for the attacker, and mods have to be laid out in terms of the active character, but that's all good enough. You just have to take care to note that you're giving out penalties to be attacked rather than bonuses to defense.

    Most of the time, your grunt adds a small number to his base attack, and tries not to roll over the total.

    Slightly trickier with 3e's +15/+10/+5 type attacks, but still easier than adding a variable each time.

  7. I think you're missing a principle:

    (4) fewer operations is easier than more operations.

    If you can collapse parts of the equation by computing a term and using it over and over, you can eliminate an operation and the result will be faster even if the prior computation involves a more expensive operation such as subtraction or a table look-up.

    THAC0 did this by computing 20 - level once per level. As we actually played it,

    THAC0: d20 + Mods + AC > THAC0

    And since back in the day AC represented a type of armor everybody at the table knew that if the hobgoblin was wearing Chain Mail, his AC was 5. Once in a while the GM would have to tell players what the AC was (how good is the armor on that Giant Crab anyway?), but that would happen once at the beginning of combat.

  8. Wonderful post. I think the comments bring up some issues that need to be dealt with, but the fact that your post was meaty enough to elicit them I appreciate.

  9. "Fighter Level" is occasionally referred to in the DMG and occasional Dragon magazines as "Fighting Ability". Of late, that has been the usual way of handling this in our group, so that it has become:

    D20 + AC + FA + Mods = 20+

    The other side of things is that continual use makes things easier. I was very comfortable doing:

    D20 + Mods = THAC0 − AC

    ...and have occasionally fallen back on the process unconsciously.

  10. Thanks for the comments, all.

    It's not a terrible point that the 3E system has all player-scores on the left and the DM-score on the right of the inequality. But that doesn't mean that it's easier.

    In practice with the Target 20 system (which is indeed how I run all my D&D games), the player performs d20 + FtrLevel + Mods, and reports that to the DM. Then the DM adds the AC and compares that to 20.

    I'm confident that this is still significantly easier than the 3E system. (1) It's easier for the DM to lookup, or even flat-out remember, a single-digit DAC than a double-digit AAC. (2) I'm confident that it is indeed easier to add a small single-digit number and compare to 20, than to compare to any random, large, odd number. (3) If the player reports a raw score of 20+ (actually, as long as the first word out of their mouth is "twenty..." anything), then I can just ignore the second digit, skip the last operation, ignore the AC entirely (!) and announce a "hit".

    Note that point (2) addresses the observations like "fewer operations are easier than more operations". True, but for our purposes they need to be more easier than comparing a round number is versus an odd number, which I'm enormously doubtful is the case. (Again, comparison is computationally equivalent to subtraction, which everyone agrees is something we need to avoid as much as possible).

    To quote TFoster's assertion: "instinct tells me... that 12 + 2 + 5 >= 17 is easier for most people than 12 + 2 + 5 + 3 >= 20.". No, all the data I see is that the opposite is true.

  11. Speaking only from my own experience, the AD&D (and similar OD&D) descending AC systems are less intuitive (a disadvantage) but results in simpler single digit numbers to work with (an advantage). While new players in the AD&D system generally had to refer to a chart (a disadvantage), the chart itself provides players with a big picture of how the game works (all my players also had the DMG, so they had the information right in front of them). In our Castles & Crusades campaign, combat resolution is very simple but the players we have that are new to RPGs probably are not getting the big picture in the same way that I did 30 years ago.

    I've found the C&C Siege Engine approach elegant it principle, but a bit of a challenge in actual practice because (1) it is only used occasionally during the game and (2) trying to wrap my mind around numbers like 19, 23, and 28 (as you note in #3 "Small numbers are easier to compare than large numbers").

    #3 "Small numbers are easier to compare than large numbers"--Maybe why d20 games (in a generic sense of d20) are more playable than a d100 game? (setting aside the $$$$ in d20 marketing)

    Setting aside tradition, personal preference, game history, game dogma, my sense is that an ascending system is simpler to manage psychologically. But that is just a concluding unscientific post-script on my part.

  12. @Syrsuro: "I think that attempts such as this to redefine the THAC0 system into a 'better' formula fail for one simple reason."

    This is not an attempt to redefine THACO, any more than the 3E core mechanic was. I think you've missed the fundamental idea of mathematically equivalent algorithms.

    @TFoster: "THAC0 isn't a round number, but it has other strengths IMO: because the THAC0 (i.e. 20-level) is pre-factored and static, not something that changes from encounter to encounter (and potentially even round to round) like mods and AC, we only need to factor it once, not every roll."

    But even that (THACO encapsulation) is additional math work that is being offloaded onto the DM pre-game. What about an old-school situation where you roll up wandering men or monsters on the fly? Isn't it easier to just add the Hit Dice in as the combat "level" directly, rather than doing a compute/lookup of THACO = 20 - level, and then dealing with that large, odd, secondary number thereafter?

  13. It was bugging me after I read this that I had missed your point...and I had. Sadly, it hit me while almost asleep, upsetting the sensitive balance of sleeping wife, sleeping dog, and four sleep cats (all carefully placed).

    Anyway...it's brilliant and simple, which leads to the physicist's highest praise: "Elegant." The Target20 system is the sum of the simple, from the perspective of human cognition. At first blush, the d20 system still seems the most intuitive, but, as you note, the intuitiveness drops off when you are messing with an AC of 27. It also could feel the most intuitive because I have actually used it, unlike this system. Mike Mearls' comment does raise the question about negative ACs--what is the range of ACs and the min/max that this could comfortably support?

  14. jamused said:
    I think you're missing a principle:
    (4) fewer operations is easier than more operations.

    This is at least as important a point as any of the first three points.

    Take the d20 system algorithm: d20 + 'level' + mods >= 20 - DAC.

    Ascending AC precalculates 20-DAC, creating a new Ascending AC:
    d20 + 'level' + mods >= AAC.

    Where does that leave us?
    1) Additions are easier than subtractions.
    Targetd20? Passes.
    D20 System? Passes.
    2A) Round numbers are better. Fallacious Argument: the assertion does not follow logically from the statement that it is quicker to compare distant rather than closer numbers. It may be a valid supposition, but it is not supported by her given evidence.
    2B) Distant numbers are easier to compare than adjacent numbers (what the evidence stated). All systems are equivalent in this regard. In all cases we are dealing with numbers that are clustered around a target number, some higher, some equal and some lower.
    Targetd20? Passes.
    D20 System? Passes.

    Point 3: Small numbers are easier to compare than large ones. Both numbers are making comparisons in the range of 10 to 20. However, the Targetd20 is always comparing numbers to '20', while the D20 System is often comparing smaller numbers. Slight advantage to the D20 system.
    Targetd20? Relative Fail
    D20 System? Relative Pass

    4: Fewer calculations are better than More calculations. Perhaps the most significant point. In fact, the idea that it is faster to do one operation than two, two than three, etc. was probably just too obvious to even merit mention in "How the Brain Learns Mathematics".
    Targetd20? 3 operation. Fail.
    D20 System? 2 operations. Pass

    Bottom Line: Her argument hinges on the assertion that it is better to have a system that uses more operations, and higher values but compares the final value to a round number. I disagree and think that a system that reduces the number of operations required at the table is superior, even if it results in having to compare the final value to a non-round number.

    And ultimately, we are discussing tiny incremental differences here which are wholly overwhelmed by far more important issues such as how the information is tracked, reported and handled in play. I.e. (in my experience and in my opinion) any imagined benefits gained from these subtle mathematical 'advantages' shrink to insignificance if they require the players to know the creatures ACs or the DM to track the players AC.

    Which is, of course, why the author doesn't actually use her own Algorithm, but instead uses:

    d20 + level + mods = x
    x + AC >= 20.

    Which brings us to my final point.

    As a DM, I often have a billion numbers and thoughts buzzing around in my head. The more I can load off to the players, the better (and if that makes them feel more involved, so much the better). It is, imho, better for me to get a single number (large, small, whatever) from the player and compare that number to a discrete value (the AC) than it is to get a value from the players, add that to the AC and then compare the sum to a third value, even if that value is round.

    This offloading of math onto the players (who typically have less to keep track of) while keeping player and DM information compartmentalized is the real advantage of the d20 system. Since we are dealing with people, and not trying to optimize calculation time for a program, I think that this factor is the key criteria on which all algorithms should be judged.

    YMMV, of course.


  15. @RBA: "It was bugging me after I read this that I had missed your point...and I had. Sadly, it hit me while almost asleep, upsetting the sensitive balance of sleeping wife, sleeping dog, and four sleep cats (all carefully placed)."

    This I sympathize with most, most deeply. :)

    I admit I kind of like avoiding negative ACs as much as possible. I don't use the demons from Supplement III (where they arose). I kind of prefer keeping arms/armor bonuses to +3 as in the original books (so best AC around -4, definitely keep to single digits).

  16. >> "2A) Round numbers are better. Fallacious Argument: the assertion does not follow logically from the statement that it is quicker to compare distant rather than closer numbers."

    Wrong. It does in fact follow. You misunderstand that principle (2) is about comparing single digits (one sub-step in the process of comparing numbers).

    >> "Point 3: Small numbers are easier to compare than large ones... Slight advantage to the D20 system."

    Wrong. At the point where Target deals with AC, it is a single digit. When d20 System deals with AC, it is double-digits.

    >> "4: Fewer calculations are better than More calculations. Perhaps the most significant point."

    Wrong. It is perhaps the least significant point, if it turns out to be less time-intensive with small numbers than the other points.

    >> "Which is, of course, why the author doesn't actually use her own Algorithm, but instead uses.."

    Wrong. I do use the stated algorithm, inasmuch as the d20 System uses its algorithm.

    Wrong also that the author is a "her".

    >> "It is, imho, better for me to get a single number (large, small, whatever) from the player and compare that number to a discrete value (the AC) than it is to get a value from the players, add that to the AC and then compare the sum to a third value, even if that value is round."

    Wrong for most people, according to the data, as long as the final comparing number is both (a) fixed and (b) round.

    Wrong also because you're leaving out all the times that the DM must do the attack calculations for monsters, which likely surpasses the total number of attacks made by players.

  17. Delta, I really enjoyed this post a lot.

    With my own troubles with mental arithmetic mean that the table lookup is the best algorithm for me.

    Also, preferring B/X as I do over Wizards’ 3e or even AD&D, I find that without all those other rules to consider, the different between these algorithms seems much less important.

  18. 1) Round numbers are better does not follow from close comparisons are easier. It just doesn't. That said, I found your quoted book on the internet and read parts of it (mostly only the first chapter since the only pages you quoted were from that chapter). I then found some of the primary sources used in that book and read them (ain't the internet grand). Your conclusion does not follow your statement and your implied followup point (that comparisons are made as single digits in most cases) is actually not supported by most authors either. Rather, a holistic model in which (Dehaene, Dupoux and Miller, 1990; JEP) "the digital code of
    numbers is converted into an internal magnitude code on an
    analogical medium termed number line. This encoding stage
    is fast and independent of which particular number is coded." In other words - when comparing two numbers to determine which is larger people do NOT look at them digit by digit. They look at their relative magnitude holistically (this is, by the way, why the 'larger numbers is harder' trend continues past 10. If they were being compared digit by digit, this effect would not be seen.

    That said, if one follows the literature back a few decades one does find a paper that supports your assertion. Your point stands, it is merely poorly supported by your text. I had to go back to Hinrichs et al, 1981 (Journal of Experimental Psychology) to find any support for your statement: Hinrichs (et al) did find that when comparing smaller numbers (but not larger numbers) to a standard ending in 0, the evaluation was commonly shifted to the 10's digit. Arguably there is some small savings here as that results in comparisons of a '0' or '1' to a '2' and thus your point about adjacent numbers holds. The point is that the original book did not (at least not in the first chapter) ever mention this process and thus cannot be used to support your point.

    Regardless, although I think that within the range of values we are dealing with the differences in speed you are talking about are reduced to triviality compared to the amount of time taken up in the process itself and therefore gameplay factors are far more significant.


  19. Moving On

    2) Wrong. At the point where Target deals with AC, it is a single digit. When d20 System deals with AC, it is double-digits.

    True. But where the systems are making comparisons they are both dealing with double digit numbers. Therefore, by the evidence you are presenting there is no advantage.

    3) Wrong. I do use the stated algorithm, inasmuch as the d20 System uses its algorithm.

    You wrote the algorithm, not them. You are responsible for making sure your own algorithm is accurate.

    Technically, the d20 System uses:

    d20+'level'+mods = x
    x >= AC.

    Note that the amount of work required by the DM is minimalized.

    4). Wrong also that the author is a "her".

    My apologies for making the assumption that someone with a common female name (according to the 1980 US Census) is female.
    5) Wrong also because you're leaving out all the times that the DM must do the attack calculations for monsters, which likely surpasses the total number of attacks made by players.

    This only strengthens my point as it represents an example of what the DM has to do and thus why it is important to offload as much of the calculation as possible onto the players.

    In short - you are attempting to use scientific reasoning to support a point that seems to make intuitive sense, but you are drawing conclusions which, although possibly valid, are not directly supported by your evidence.

    This is especially a problem as you are trying to compare different factors and making assumptions about which factor has a greater effect when there is no evidentiary basis upon which to make those comparison.

    For example: You think that comparing to 20 rather than comparing to a non-round number in the vicinity of 20 is a more significant factor than adding an additional operation (which may be the addition of a negative number), I disagree. And there is insufficient evidence to prove either point as none of the studies quoted were interested in making that particular comparison.

    And a final point, in case anyone missed it. We are talking about millisecond differences here. For example, when comparing numbers to the standard 66, Dehaene et al found there was about a 20 millisecond difference between an adjacent number and a non-adjacent number within the same decade. That's right - 20 milliseconds is the advantage we are talking about here.


  20. Another thing occurs to me: What might be a trivial improvement for most people might be a significant improvement for some. If the group is made up of four “mosts” and two “somes”, then the improvement could be more significant to the group than to most of the individuals.

    If that makes any sense. shrug I’m torn between saying that this is all way overthinking the issue and saying—as someone who has felt himself struggling with arithmetic or algorithmic mechanics to the detriment of play—that it is a very worth while conversation.

    (Of course, I’ve seldom let trivialness prevent me from participating in a discussion. ^_^)

  21. Now that I am actually awake, I can add a bit more to my thought on this.

    (1) If I were designing a game from scratch, this system would definitely be an asset if it fit with the other elements of the game design.

    (2) Beyond an interesting thought experiment, I am wondering how much difference any of these algorithms make in actual game play. Obviously there is some difference, but enough for a casual player like me to actually do a redesign of my current game of choice (Castles & Crusades)? That is an ROI question.

    (3) I may be missing something here but it seems like the bandwidth for your AC is reduced, at least compared to AD&D and systems more recent. I started with Holmes and also used OD&D back in the day, so I think a narrow bandwidth of 0-9 for AC is not necessarily problematic, but it certainly changes the nature of AD&D.

    (4) I've never played (as player or GM/DM/CK/Ref) where players did not handle the attack roles (including the computation of success) themselves. The only times where this was not the case has been with unknown creatures (which is easier to handle with the d20 system, in my opinion). Here I would have to agree with Carl (aka Syrsuro).

    (5) I'm probably in Robert's "most people" camp in that in play, the gain here may be trivial as there are other variables that have a bigger impact on play. However, I wouldn't say that trivial (which is as much a value judgment as anything else) is the same as statistically insignificant. That is where the formula boy side of me, now much atrophied, finds this fascinating.

    (6) Other variables: I've been playing C&C, which to me feels very similar to AD&D at the game table. Not the same, but similar. A much closer feel than C&C vs. 3.5e (both have the same d20 attack system). That is just my limited and very subjected experience, but it would be interesting to identify other variables that affect game perception in terms of complexity, playability, realism, etc. This is beyond my pay grade but...

  22. @Syrsuro: "My apologies for making the assumption that someone with a common female name (according to the 1980 US Census) is female."

    You must be misreading things. In the database I looked at, my name "Daniel" is the #12 most common male name, and not anywhere in the top 1,000 of female names.


  23. @Delta: Any comment on tussock's algorithm?

    level + AC + mods >= d20

    It satisfies principle #1, ignores principle #2, and satisfies principle #3 better than Target 20, while removing an entire term from the algorithm.

  24. "Any comment on tussock's algorithm? level + AC + mods >= d20"

    You can probably guess. (1) Ignoring Principle #2 (comparing odd numbers) causes pain. (2) The need for the player to separately report "level+mods" and "d20", and the DM to then corellate to AC and compare (remembering two numbers separately), causes pain. (3) Upending the classic roll-high-is-better causes pain (sure enough, the last game I played I saw a newer player remark on the wierdness of OD&D 2-in-6 roll-low chances).

  25. @Delta. I always tell AC when the attack is made, and trust the players to do the math and check the hit, but that's a style thing of course. I have a handy list of party AC at the table.

    I consider it's hard enough to let players know useful things about the world without me obfuscating anything.

    Oh, and I'm using low rolls good always, the same trick with d6 skills, saves, and so on. Set a high target and don't roll over it. Penalise your opponent's targets.

    Add before the roll, compare after. The answer should be right there on the die, as soon as it stops rolling.

  26. "I always tell AC when the attack is made, and trust the players to do the math and check the hit..."

    No, I really don't want to tell the players about AC, hit points, magic effects, or other opponent abilities they can't see, or take the DM out of the loop. Secrets and mysteries are part of the fun of RPGs. Even the 3E DMG says not to tell these things to players.

  27. @tussock: I hope your players still have fun even though the 3E DMG says not to.

  28. "No, I really don't want to tell the players about AC, hit points, magic effects, or other opponent abilities they can't see, or take the DM out of the loop."

    Fair enough. I'm sure it's not for everyone, but it (generally only the things they are interacting with, that being the point for me) works very well.

    "Secrets and mysteries are part of the fun of RPGs."

    I agree, but there is and will remain an infinite amount of things the PCs don't know about the world without me adding fairly trivial combat stats to that.

    "Even the 3E DMG says not to tell these things to players."

    Even 3e runs noticeably quicker and smoother when I do.


    Linked to this post from a Dragonsfoot thread; I really really like the sound of this method and will be stealing the hell out of it.


  30. Cool post.

    One thing though. You mention that addition seem to be easier for most, but using the descending AC system will mean adding a negative number when the AC is really good. Or am I missing something?

  31. @Andreas: "You mention that addition seem to be easier for most, but using the descending AC system will mean adding a negative number when the AC is really good. Or am I missing something?"

    You're completely correct. However, if you're running an OD&D-style game, such an AC is so enormously rare that it doesn't even appear in the LBBs. Having it hyper-streamlined single-digit additions for the most common cases is one of the several advantages of the classic AC system. Even in the rare cases it's negative it's a small single-digit number (as opposed to double-digit ascending-AC varieties).

  32. See, I was missing something. The negative AC is of course me thinking of AD&D. Like you say, in the LBB negative AC is almost a non issue.

  33. While I am torn between systems as to which is better, I do like something that the old d&d character sheets had. I like the hit table where you filled in what numbers you needed to roll to hit a certain AC.

    Currently, for the math challenged players in my games, I have the players make a list numbered 1 to 20 and beside it I have them list the their attack bonus added to the number from the list. Thus the math is done ahead of time. It even makes penalties and bonuses easy to deal with. You simply move up or down the list a certain number to find your total.

    The only issue is having multiple lists for your extra attacks, but even so it is still faster and fewer mistakes are made overall.

  34. Very interesting post and commentary.

    I think both Delta's method and THAC0 work quite well for OD&D (and well for AD&D). The essential advantage really is doubling the range of single digit adjustments. Also the "counter itself" aspect, where as you get better, the 'opposition' subtracts from your own number, resulting in a very slowly changing net result.

    I imagine MM agrees with you largely b/c of that concept of 'matching', where bonuses and targets scale at the same rate. It plays largely into the latest version of the game.

    For a game where a typical AC is -7 (equiv. to the AC 27 example) though, the system breaks down a bit. For a roll of 12, Level 10, modifiers of 5, and AC of -13 say, you have:
    T20: 12 + 10 + 5 + (-13) >= 20
    D20: 12 + 10 + 5 >= 33

    I think this example shows where the "easier to compare numbers farther apart" comes into play. It's easier to tell (imho) the D20 example won't reach it's target.

    In the end though, I think each system is very well suited for the game it's used in. Although a OD&D game using AAC's going from 10 to 20 (90%+ of the time) would be an interesting comparison.

  35. Came up with another solution for this too. Avoids telling the players a target number and avoids almost all calculation.

    First define AC as 1+ (leather 3, chain 5, plate 7, etc).

    Define base "to hit" as 10+ (so +5 class and +1 Str and +1 magic is "17").

    Now roll d20: if you roll less than or equal to your "to hit" number, the roll is the AC you've hit.

    Minor problem with higher level games and bigger bonuses to hit and AC, as "to hit" numbers of 21+ mean the low die rolls must get +20 for AC.
    So a high level Fighter might have 34 as his "to hit" meaning the d20 is read "21-34" for 1-14, with 15-20 normally.

  36. Majuba: I agree that Target20 leverages the fact that in OD&D most ACs are single digits, and usually positive. You're right that if they grow into double-digit negatives then some of the advantages are definitely sacrificed.

    Tussock: Just a side-note, I don't tell players the target ACs already. Player rolls d20+known bonuses, DM (me) does all the other stuff.

  37. Actually, I reworked the system entirely.

    It involves you not adding ANYTHING to the die, just using the die result. The enemy's stats and equipment determine the critical hit range as well as a the (usually quite low) miss chance.

    First of all, its based off of an armor house rule designed by another guy (Sgt. Brother on the Giant in the Playground forums) for use in his historical campaigns where armor grants Damage Reduction. (He also used a much lower hit point pool and added BAB to Armor class, but we aren't going to be discussing THOSE rules here).

    This system changed critical hits to merely bypassing armor. The more armor you wear, the smaller the crit chance counting down from 20.

    And, for dodging, we count up from 1. Add dexterity (heavier armor lowered the dexterity modifier to AC/miss chance) and shield bonus to determine a miss chance. Some weapons might modify the miss chance by a small portion.

    Therefore, if you roll high, you

    Some stats:

    Damage Reduction
    Padded or soft leather : 1
    Thick leather, wood, wicker, hide, weave, etc. : 2
    Buff coat, cuirboulli, or thick hide : 3
    Byzainted or light chainmail : 4
    Heavy chainmail, scale, splint : 5
    Coat of plates, banded : 6
    Light or partial plate : 7
    Heavy plate : 8

    The Critical hit range starts at 10-20 and decreases by one for each portion of the body covered:

    one arm or partial both arms
    +other arm or rest of the arms*
    one leg or partial both legs
    +other leg or rest of the legs*
    Upper left body*
    Upper right body*
    Lower left body*
    Lower right body*

    *-the armor can optionally only cover part of a section of the body. You could just protect one arm, or wear guantlets on both arms

    If you were counting, you'll notice that there are 10 areas on that list. Being completely armored closes the Crit range to 20-20.

    Armor weight:
    To determine the weight of all armor worn, Multiple the armor's DR by each portion of the body (or each point that the crit range is decreased by) the armor covers. And (to use Sgt. Brother's exact wording) For every 25 points, reduce the character Dexterity modifier by -1 (notice that this brings the Dexterity modifier DOWN, instead of merely capping it).

    Yes, all this talk about dexterity modifiers is from future editions, but for this system, we kind of NEED a bonus from dexterity. Borrow or devise whatever system you please. (I'm still working on that.)

  38. But anyway, this system means that one of three outcomes will happen when you roll:

    1-critical hit. The weapon finds the chink in the armor, dealing full damage. Its important to note that magic still has to deal with 1/2 DR from armor and cannot crit.
    2-Attack will hit the armor and have damage reduced. If the target is wearing different types of armor, such as a heavy plate helm and hide armor everywhere else, then the higher you roll, the lighter the armor you will hit.
    3-Attack will bounce of the shield or be dodged or otherwise miss entirely. Its low, but it can protect you even from higher level foes. Most magic completely ignores this in favor of saving throws.

    If the player rolls a 17, he says "I rolled a 17." (as opposed to specifying that he rolled a 21 AND a "NATURAL 17" with his +4 attack bonus, because only the GM knows the crit range of the NPC he's attacking and he really only needs to know what the d20 says.) Its all reduced to a single roll of the d20, and then going on to the damage.

    It ends up doing the opposite of Sgt. Brother's system (short changing and stagnanting evasion while allowing Hit points to flourish), but I kind of think that eliminating "accuracy bonuses" makes the whole power dynamic of the game more interesting.

    Damage still has all of its bonuses, and in fact might improve with level in lue of BAB or the AC/level chart. Will all of this Damage reduction floating around, I've also broken the "no subtraction" rule, but well, its the lesser of two evils. (Granting bonus damage for not being armored enough would probably warrant reworking hit points...). Also, maybe level grants some DR that isn't susceptible to critical hits or magic or what have you.

    Adding a rule to let attacks do at least 1 damage might be needed to make magic missiles not irrelevant. And also prevent high levels from fearlessly wading into a sea of foes if they get free non-critable DR.

  39. So what I really want is to have the d20 roll isolated.
    It's possible in d20 if the players know the AC because then it's just

    d20 > AAC - AAB

    It’s possible in thac0 too:
    d20 > DAB - DAC

    It’s also possible to do with just pluses:
    d20 > DAC + AAB
    d20 > AAC + DAB
    It’s possible if the armor class that is written down is the descending one and the attack bonus that is written down is the ascending one, OR vice versa.
    I.e. both d20 and Old School did it wrong, requiring a subtraction if you want to isolate the d20 variable! But it’s easy enough to hack.

    (AAC = Ascending Armor Class (i.e. d20 style), AAB = Ascending Attack Bonus (i.e. d20 style), DAC = Descending Armor Class (i.e. old school style), DAB = Descending Attack Bonus (i.e. thac0).)

    However, DMs are sometimes really stingy about revealing the AC (even though it becomes obvious after a few rolls, but...)

    I played alternating weeks in two Labyrinth Lord games, one with traditional descending armor class, one changed to be d20 style.

    To speed up combat we rolled damage dice along with the attack roll.

    The d20 one was onerous enough. It was always:
    Roll, + add, then ask the DM “Is a 17 enough? Is it, is it? Teacher, please, do I hit? If so, it’s three damage”.

    But the thac0 one, which I had looked forward to because I thought it would be easier to isolate the d20, was much more onerous.

    It was:
    Roll and then subtract [significantly more annoying!] [or look at at table]
    And then ask the DM “Is to-hit-armor-class-two-enough? Is it, is it?” etc etc.
    Not only was the subtraction annoying — and we could all do it, that’s not the question, it was just even more annoying — it was cumbersome to even phrase the question. And even as the weeks went by, the right language for it didn’t come, or didn’t sound good.

    Now, if instead the DMs would be a little more generous with revealing the AC, I could pre-figure the to-hit-number against a particular foe and the get the INSTANT gratification as the twenty sided die hit the table (possibly along with some damage dice).
    Roll, see that it’s a 17 and a 3, and exclaim happily:
    “BAM! I hit it for 3 damage!”

    And again, if it were EITHER descending attack bonus (like thac0) with ascending AC, or ascending attack bonus with descending AC, that “pre-figuring” of the number would be a simple addition instead of a subtraction. Perfect!

    Moral of the story: the system is designed around DMs being stingy with information about AC. And that’s the problem. But given that stinginess, it seems to me that it can’t get easier than d20 + ascending, like the d20 system does it.

    Let’s look at the whole process with GM interaction included, given monster AC secrecy:

    • d20:
    Player rolls, player adds, player asks, GM compares to stat block.

    • traditional thac0 / to-hit chart
    Player rolls, player subtracts, player asks, GM compares to stat block
    Player rolls, player asks [just giving the die result], GM looks at
    chart, GM compares to stat block

    • Target d20:
    Player rolls, player adds, player asks, GM adds from stat block, GM compares to 20.
    [This is how you do it, right?]

    Of those four, it seems to me that the d20 style is best. And honestly, target20 looks like the most convoluted of the four.

    Let’s look at the whole process if players know the AC:
    • d20:
    Player subtracts once (for the whole fight),
    Player rolls, player compares

    • traditional thac0:
    Player subtracts once (for the whole fight),
    Player rolls, player compares

    • My “Ascending vs descending” idea:
    Player adds once (for the whole fight),
    Player rolls, player compares.

    • Target20:
    Player can add together level + AC + mods once for the whole fight.
    Player rolls, player adds, player compares to twenty.

    Of these four, target20 is the only one where players lose out on the immediacy of seeing that hit land as the dice land.

    1. Well, the initial assumption that the DM can tell players the AC, and have the result isolated on the d20 roll, is one that I've always politely and firmly disagreed with. The decision-making for "yes or no" success should always go through the DM. And as you might guess, the information players get about opponents is always purely narrative descriptions, never in-game numbers (like AC). A bit of mystery is immersive; and if players deduce the numbers later, bully for them.

      So the Target 20 process is (about as you expect):
      - Player rolls d20, adds bonus, announces total.
      - DM mentally adds AC, compares to 20, and announces success or failure.

      There is a small bit of extra burden on the shoulders of the DM (adding the AC). But I consider this to be very much acceptable -- the DM should be the most learned with the system, proficient at that add/compare, and be ready to assist neophyte players by making the game maximally welcoming (and simple) to their participation.

    2. Likewise: In the case of the d20 system, the rulebooks also explicitly said not to tell players the AC or other stats of monsters they were fighting. See 3E DMG.

    3. You’re right. Many DMs do wish to abide with the rule of not revealing AC, and they have support in the text.

      That's why I gave examples of the various protocols both with and without AC secrecy.
      For Target20 with AC secrecy, I wrote:
      Player rolls, player adds, player asks, GM adds from stat block, GM compares to 20.

      To me that doesn’t seem simpler than the d20 system:
      Player rolls, player adds, player asks, GM compares to stat block.

      Also: Delta, thank you for still keeping this topic open after so many years. You have a great blog.

    4. Thanks so much for saying that! Admittedly to a certain extent to real simplification with Target 20 is that I can still use original source material AC without rewriting it ascending-style. Conceivably if the original was ascending then I wouldn't have thought of it; but I also like the mechanic for other stuff like thief skills, saves, etc., where it's usable in absence of an explicit target or modifying number. (That is: save vs. spells is d20 + level >= 20, if it's individual hold person then -3 on the die, but in most cases no modifier/target need be documented; it's always 20 by default.)

  40. (Just to correct myself:

    I wrote:

    It’s also possible to do with just pluses:
    d20 > DAC + AAB
    d20 > AAC + DAB

    The first one doesn't make any sense and I must've flipped the polarity a few times too many. It should read d20 < DAC + AAB, and that would suck, rolling high is the best. So that leaves d20 > AAC + DAB. I have it set up so that I as DM use that, while the players use the familiar d20 method of d20+AAB > AAC. That way I can very quickly roll a whole bunch of d20:s and see which hit and which misses, for rolling many monster attacks in one go.)

    1. That's a reasonable point. I also do a subtraction mentally when I want to roll a fistful of d20's for monster hits. Obviously players won't be doing that same thing often at all.

  41. I love your algorithm, but I just have 1 question. It works great when you add a Warrior's level, because a Warrior goes down 1 Thac0 per level. But what about Priests, Rogues and Wizards? Their attack bonuses don't arrive nearly as quickly as Warriors. So my question is, how do you calculate for the other classes?

    1. Good point, I need to remember to include that as a parenthetical note whenever it comes up. I equate "fighter level", as you might guess, to 2/3 the cleric or thief level, and 1/2 the wizard level.

      Those fractions are the same as 3E, which I settled on because they're easy enough to possibly do in one's head. You could modify them a little to strictly follow other editions. Of course advance documentation can be useful, and it's a minor task because the preponderance of enemies will be fighters or HD-based monsters.

      See the Target 20 document here for full info:


    2. It is also often OK to let “to hit” progress the same for everyone. The main measure of combat prowess is hp, so if you’re using different HD by class, the fighters will retain an advantage. If you use variable damage by class or variable damage by weapon and restrict what weapons other classes can use, you’ll have that differentiator as well.

  42. I'm running OD&D, 3lbb + some Greyhawk + your house rules at a con in a fortnight. I've only GMed once before (Cinematic Unisystem, about 8 years ago), so I playtested it to see how it would go.

    Most of the players were not used to D&D, some had experience but mainly with 3e. I really did not want to use THAC0, as I personally found that system extremely difficult, and resorted to writing my own tables telling me what my die roll would hit.

    So how did the Target20 hold up? Very well actually. The players added d20 + their (pre-modded) attack bonus, reported the result to me, I added AC, and checked if it passed 20. I didn't use any situational modifiers, but I'd have handled them myself had it come up. However I did sometimes wonder why I was adding, when comparing to an AAC might be quicker. Despite that it was still faster than any 3e game I've ever played, and a little faster than my Basic D&D game where I'm using a table.

    I'm playtesting again tonight with some board gaming friends, including one person who is totally dyscalculate, so it will be interesting to see how that works out, and if I need to let her just roll the d20 and handle the rest myself.

    1. That's great, thanks so much for the feedback!

  43. I'm coming to the conversation late but this is great. I would prefer to base even the PCs on HD rather than Lvl. When they have a "4+1," I would allow the additional bonus. That way you don't have to go back and back divide for clerics and MUs. It powers up the FM too.

    If I want to keep AC secret, I suppose I could just ask them to tell me their totals, I could then add the AC in my head. Done.

    So elegant. Thanks much.

    1. Right -- If you're using the original Vol-1 hit dice for PCs, then that's a very elegant way of doing it (personally I use the revision in Sup-I so it's not quite the same option for me). I'm pretty sure that most of the people in my extended gaming circle do it this way now. Thanks for the input!

  44. Thanks, Delta. By the way, I have your book of war and I have modified it and put it to use in a hex-crawl I am running right now.

    Question (perhaps worthy of a blog post?): I know you don't like clerics. But, for the sake of a nice reader like me, can you imagine how the turn-undead mechanic could be cleaned up?

    1. Now that's a question I've never gotten before! :-) Looking at the Vol-1 table quickly, it seems like the numerical part of the table is equivalent to rolling 2d6 + 2(Clr level - Undead HD), needing a total of 9+ for success.

      So I suppose I woulds consider collapsing that to 1d6 + Clr level - Undead HD, need 5+ for success? (i.e., base chance 2-in-6.) Obviously, that table has a pretty narrow range where success depends on the roll (so it collapses to a small die). That turns the "T" results into numerical chances (equivalent to having targets 5 or 3 in the table), so you could say if the roll is automatic then you get the "D" result.

      Alternatively, you could expand it to d20, like d20 + 3(Clr level - Monster HD), target 15+, or something.

    2. Oh, and thanks for the comment about your using Book of War, that's great!

  45. Wow, no wonder I couldn't come up with something smooth. I am no mathematician and I would never have figured out that you have to multiply the difference of the CL lvl and the undead HD by 2!

    Very cool to know now. I like the d6 resolution mechanic. What if we gave a generic +1 for the clerical class, then another +1 per HD. That could render it a "target 6" w/ a d6 much like the corresponding target 20 w/ the d20. The math would be the same as you describe above with a d6 per target 5, right? Just a thought.

    I ran the wilderness adventure today ("Through Hollow Lands," in Jimm Johnson's Planet Eris campaign). It worked great. If you are interested I can send you my "even-rules-lighter" version of your B of W. We have been using HX and counter rather than minis so I made some mods for that.

    Anyway, it is awesome to have creative mathematicians in service of our great hobby. Thank you.


    1. Cool, I'm glad it helped! Your modification sounds great, too. I'd love to see your even-lighter version of Book of War -- delta at superdan dot net, if you don't already have that.

  46. Sure, absolutely. But I think that's more than outweighed by the majority of times when you'll be adding a positive single-digit number instead (like, all the monsters listed in OD&D).

  47. Target 19!?
    Dear Delta, I was just reading in Troy Denning's old version of "The Classic D&D Game" and what do I see?

    "Using THACO is often an easier way to remember combat rolls. THACO stands for "To Hit Armor Class 0." The Character Hit Roll Table shows what a character needs to hit Armor Class 0. For instance, a 1st-level fighter needs to roll 19 or better to hit a target with Armor Class 0. Instead of looking on the Hit Roll table for every attack, the player only needs to remember that the character's THACO is 19. Whenever that fighter attacks, the player rolls a d20 as usual. Then any combat modifiers are added, like bonuses for magical weapons or ability score adjustments. Finally, the defender's Armor Class is added. If the total is above the fighter's THACO of 19, a hit is scored. Note that negative Armor Classes will be subtracted from the roll, making them harder to hit."

    Sound familiar? d20 + AC > 19! Or, rather d20 + AC > THAC0.

    1. Ha! Well yes... although that 19 changes depending on level, of course. So I do like getting rid of the whole THACO stat and just remembering to "add your level", basically (esp. for monsters from the DM side).

  48. Can you help me? I am trying to devise a system than runs ONLY against the opponent's AC. Let me show you my poor calculations.

    a) d20 + mods + level ≥ 20 - AC

    b) d20 + mods + level - 20 ≥ 20 - 20 - AC

    c) d20 + mods + level - 20 ≥ - AC * (-1)

    d) 20 - d20 - mods - level ≥ AC

    Unless I can ignore that (- AC) on c) because that is really how it is, then I would be spared the need to recalculate everything else via subtraction. Am I doing something wrong, or am I doomed to work with subtractions on the left hand side?

    1. Your work looks all correct to me. With classic downward-improving AC, if you want AC isolated on the right-hand-side, then unfortunately you are going to be doing a bunch of subtractions. That is certainly the motivation for (i) me in Target 20 keeping AC as an addition on the left [as in your (a)], or (ii) newer games redefining AC as upward-improving, so as to flip all the negatives to positives [compared to your (d)].

      What's the motivation for needing AC isolated on the left? Have you tried out the Target 20 system in practice (remembering the DM does the add-AC step)? Many of us don't want to go back once we've tried that out a little bit.

    2. Thank you for the quick and clear reply. I still get amused by such politeness on the internet.

      I was just trying to easen calculations on my (Game Master) side. But it seems Target 20 is the best system so far.

      I am running a THAC0 table right now (next session next sunday, feb. 17th) because the players asked it so, it is not that bad, but still takes a bit of time. Target seems the best so far, because it is a quick comparison (because 20 is a rigid, unchanging value, not much fluctuating, excellent).

    3. I think that's a good observation, and I agree! See if you can't get your players to at least try the Target 20 method... It's usually a pretty easy sell once they see they can just positively add their modifiers, instead of the reverse-subtraction needed with THACO. :-) (If they're sticklers for math, send them here and they can get as much as they want.)

    4. Apparently, past step c), I should of have changed the orientation of the great-than sign, as follows:

      original c)
      (d20+mods+level-20)*(-1) ≥ (-AC)*(-1)

      original d)
      20 - d20 - mods - level ≥ AC

      When it should have been:

      original c) [re-type]
      (d20+mods+level-20)*(-1) ≥ (-AC)*(-1)

      corrected d)
      20 - d20 - mods - level ≤ AC

    5. Oh, yeah, that's a good catch. Thanks for posting the correction!

  49. Hello Delta. Doing necromancy from 2021.

    I figured an algorithm that follows those principles and cuts some math further, with some extra perks. Target 20 was mentioned so I'm sharing it with you so you tell me what you think of it.


    1. Hey, thanks for sharing that! It's funny, in my heart I honestly orbit around want a low-roll mechanic just like that a whole lot. Just a month ago I wrote in the d6-mechanic post, "So there are days when I wistfully daydream of a D&D tradition in which all the mechanics were always roll-low by default..."

      The really clever thing you've got there is maintaining the nat-20 as an "ace" success, that's very clever! That said, I'm always feel blocked at making that switch due to everyone's long-standing expectation for D&D of a roll-high mechanic on the d20. :-/