Thursday, July 16, 2009

What is the Best Combat Algorithm?

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:

THACO ALGORITHM: d20 + mods ≥ THACO* - AC

* 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

"ZERO BEATS ME" ALGORITHM: 0 ≥ 20 - level - AC - mods - d20

Etc...

Now, obviously, those last few were for humorous illustrations only, and I assume not many people would want to use those systems. So, 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, 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."

(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 "0" (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 AC15, or AC27. 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 extremely confident that this is the most mentally efficient representation of the core d20-based resolution mechanic (add d20, your fighter level, opponent's single-digit descending AC, and miscellaneous bonuses; a number equal to or greater than 20 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.

46 comments:

  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.

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

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

      Delete
  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.

    ReplyDelete
  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.

    Carl

    *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.

    CFT

    ReplyDelete
  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.

    ReplyDelete
  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.

    -Paul

    ReplyDelete
  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.

    ReplyDelete
  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.

    ReplyDelete
  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.

    ReplyDelete
  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.

    ReplyDelete
  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.

    ReplyDelete
  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.

    ReplyDelete
  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?

    ReplyDelete
  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?

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

    Exactly.
    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.

    Carl

    ReplyDelete
  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).

    ReplyDelete
  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.

    ReplyDelete
  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.

    ReplyDelete
  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.


    Carl

    ReplyDelete
  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.

    Carl

    ReplyDelete
  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. ^_^)

    ReplyDelete
  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...

    ReplyDelete
  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.

    http://names.mongabay.com

    ReplyDelete
  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.

    ReplyDelete
  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).

    ReplyDelete
  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.

    ReplyDelete
  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.

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

    ReplyDelete
  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.

    ReplyDelete
  29. SUPER STOLEN

    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.

    -DYA

    ReplyDelete
  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?

    ReplyDelete
  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).

    ReplyDelete
  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.

    ReplyDelete
  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.

    ReplyDelete
  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.

    ReplyDelete
  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.

    ReplyDelete
  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.

    ReplyDelete
  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:

    head
    +face*
    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.)

    ReplyDelete
  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.

    ReplyDelete
  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
    or
    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
    OR
    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.

    ReplyDelete
    Replies
    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.

      Delete
    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.

      Delete
    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.

      Delete
    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.)

      Delete