Tabletop RPGs, Computer Wargaming (part 7)

Season 1: Part 1Part 2Part 3Part 4Part 5Part 6 – Part 7

This wraps up the first forum thread. There’s a lot more, but I’m already tired of maintaining that part-index here above. So this closes the first section and what will come after will only be divided into parts in the title, and a separate category.

Here I am again for a brand new SIDETRACK! The loops ever getting wider and wider.

The whole point of the above whole, was to go dig in the lost tradition of RPGs, not back when they were simple and naive but when they were ambitious and convolutedly eccentric. That’s the real main root of RPGs that we collectively abandoned and forgot about: wargames.

So one of these sidetracks is retrieving some of those games I wanted to play for a very long time when I was a kid, but never ended up trying on a real Commodore 64.

The title I remember (reading reviews of) is “Halls of Montezuma.” As you can see there are a few, all using the same “Battlefront” engine or some variations of it. The comments I read about these games mention that most of them are only collections of scenarios, and only the Russia game had a proper campaign, so I picked that one.

I employed the well practiced strategy of poking at things to figure them out without a manual, and it’s all relatively straightforward. Some menus to toggle on/off some map features, some text screens to see reinforcements and various statistics, and so on.

The only problem is that I couldn’t find a command to actually MOVE stuff on the map, and I’ve tried for quite a while.

I suppose that menu is to set up ground and air support for that precise attack, and then there’s a menu with various options, like: ASSAULT – PROBE – DEFEND – RETREAT

And there seems to be some upper level “directive” that only switches from “resting” to “normal”.

Units that aren’t shown engaged in combat can only switch from “hold” to “deploy”.

That’s about it?

After trying for a while I went looking for some discussions online, and it does seem that you don’t push counters in this game… It should be some higher scale strategic thing, so you pretty much only set up the intensity of an attack, but it’s the AI that is in charge of the tactical game.

I guess this can help the game to be more balanced, since it’s all the AI doing those moves. With the player only playing from the backseat, the game probably holds up better when it comes to challenge, but it still feels quite limited… and dry.

You’d expect me to stop here, after having an idea of how the game works. But instead I’m looking for very specific things one doesn’t usually care about.

This time I started wondering how they put together that “tiled” hex map. Because after a quick analysis it doesn’t seem like they use the same “grid” that they used for text. So I started to wonder, are they using two separate graphic modes, shared on the same screen, one for the map and another for all the text?

Yet that tiled hex map defied my first attempts at deconstructing it. The vertical spacing makes sense, it’s horizontally that it does something weird.

To find a solution I had to remove that ugly CRT filter and resize to a native resolution. The final result is a grid of 8×10:

Horizontally the sequence is two tiles forming an unit, then one tile used for the hex grid. The hex grid goes all around the two unit tiles, so each unit tile has 10 grid tiles surrounding it. Those tiles can be empty, but they can always only contain the hex grid.

Now you can see that vertically the hex tiles form a column from the top to the bottom of the screen (horizontally with multiples of 3), whereas this doesn’t happen horizontally, because horizontally we have two unit tiles followed by four hex tiles. Producing that slanted offset…

Why should one waste time to figure out these relics of map representation? Because for my own game thing I was trying to figure out how to best represent an hex map having only available a square grid. So not only I need to find some graphical solution that looks nice, but also the “algorithm” that would build such thing.

It’s not as trivial as it might appear, and it was very interesting to go back and dissect this game.

This series was made by SSG, but the better known in the field is SSI. I haven’t dug as much here because I got sidetracked again, but SSI has its own way of building an hex grid, and its own solution produces an arguably prettier result, since these looks more like proper hexes compared to the hamburger-ized version by SSG.

(a matter of scale…)

…In the future I’ll try to code my very own solution. Because about two months ago I stumbled on this problem of “building hex grids with square tiles”, and after fiddling with the most common solutions for a while I eventually ended up with some weird hybrid that I’ve never seen used before. Only accidentally I now stumbled on these SSG wargames, and that solution has something in common with mine… But not quite the same.

So what’s the sidetrack that sidetracked me? That from SSG I moved to SSI, and the SSI catalogue is quite huge.

For most of everyone SSI is only synonym of the GoldBox games, but as it happens with the pen and paper RPGs the true root was in the wargame genre. SSI was primarily a wargame publisher.

My story is that, before getting watered down, pen and paper RPGs were after simulation and complexity.

Is it possible that this is true even on the computer side? Is it possible that the GoldBox games were watered down designs coming from more complex systems that preceded them and then got erased from our collective memory?


I introduce you to: Wizard’s Crown + The Eternal Dagger

In the SSI catalogue these are the only two fantasy games showing up as “intermediate”. Everything that belongs to fantasy is otherwise “introductory”. The system contemplates three tiers, but the “advanced” one is only reserved for the actual wargames.

The Digital Antiquarian reinforces the story:

At their best, though, the rules behind these games felt more consciously designed than the games in the bigger, more respected series — doubtless a legacy of SSI’s wargame roots. This quality is most notable in Wizard’s Crown. The most wargamey of all SSI’s CRPGs, Wizard’s Crown was not coincidentally also the first CRPG to be designed in-house by the company’s own small staff of developers, led by Paul Murray and Keith Brors, the two most devoted tabletop Dungeons & Dragons fans in the office. Built around a combat engine of enormous tactical depth in comparison to Ultima and The Bard’s Tale, it may not be a sustainedly fun game — the sheer quantity and detail of the fights gets exhausting well before the end, and the game has little else to offer — but it’s one of real importance in the history of both SSI and the CRPG.

And confirmed by the wikipedia:

Wizard’s Crown was the first RPG designed in-house by SSI, previously known as a wargame company. Its detailed tactical combat system came from Murray and Brors’s background in wargaming, and they brought the complexity of those games to Wizard’s Crown’s tactical combat. For instance, shields block attacks only from the front and left (shielded) side, and not from the rear and right (unshielded side). Spears can attack two squares away, flails ignore the defender’s shields, and axes have a chance of breaking shields. There is an option for “quick combat”, and regular combat can take as long as 40 minutes per encounter. This combat system influenced SSI’s later Gold Box series of RPGs, but it was streamlined and simplified.

I think The Eternal Dagger implements one idea I also had for my game (that I didn’t know existed already in this form): when you are in a dungeon the whole party is a “blob” represented by a single unit, but when you enter combat you instead deploy all the party units onto a separate tactical map. Actually Ultima does something along these lines already. The difference in my idea is that I wouldn’t use a separate map, but deploy directly the party on the same map, smoothing this transition somewhat.

The game system has a plenty of good ideas. No levels, skill based. Experience points are spent directly to improve skills. Every skill increased has a fixed cost, then the amount of the increase is rolled randomly, and goes 1 to 8 if the skill is below 100, then 1 to 4, 1 to 2, and just 1 when you go above 200, progressively slowing down.

On the excerpt above there’s interesting differentiation between weapon types (in the image you can see the considerable attack range when using a spear), but it goes further as damage is divided onto “thrust”, “cut” and “bash”, and of course this is matched by the armor types and their damage absorption values.

Another important feature is the facing and how it’s handled. If you aren’t moving you can switch the facing how many times you want, up to three movement steps you only have 1 facing change, and above three you just can’t change facing at all.

It becomes relevant because facing is used in combat calculations

There’s distinction between front, rear, shielded and unshielded side. Side and rear add a to-hit attack bonus, the shield adds to the defensive skill, since the to-hit roll is essentially attack skill versus defensive skill, plus some randomness added. The defensive skill is the weapon skill, but halved, so that’s why a shield is probably quite important since without one the mechanic favors massively the attacker.

But there are also a bunch of situational modifiers. Fatigue and morale, but also injuries. If the defender moved more than half his points, then his defensive skill is halved again, BUT only if it’s a melee attack, because if instead the attack is ranged then his defense skill is DOUBLED, because by moving he gets harder to hit.

And there’s more. Four types of melee attacks: normal, defensive, aimed and killing.

The difference between these four is how they modify to-hit chance and damage. “Aimed” attacks lower to-hit to increase damage, “killing” lower defense to increase damage, and “defensive” attacks lower to-hit to increase defense, with the manual suggesting to use this option when you are threatened by enemies on your sides and rear (since they’ll have their to-hit bonus due to their positional advantage).

In Wizard’s Crown aiming behaves differently, it lets you skip a turn to obtain a to-hit and damage bonus on the next.

Wizard’s Crown also has an option to stand or go prone, so that you can actually DIVE and avoid arrows, on the other hand making you more vulnerable to melee attacks. And a “shield bash” can be executed to SEND a character prone (but it doesn’t inflict damage).

Wizard’s Crown also seems way more complex when it comes to determine damage. The manual explains the process without giving much insight in the formulas. But it does mention the damage is made of both injury and bleeding, and that these are applied through a “multiple” that is determined by hit locations: chest and stomach causing more bleeding, limbs and head more injury. Bleeding is what causes death directly, injury instead can knock someone unconscious and also affect fighting skills.

Even here the horrible trend is showing, The Eternal Dagger, being the sequel, simplifies the rules instead of enriching them. All reviews seem to agree that Wizard’s Crown (the first) was the better one.

It might sound complicate to organize mentally, but the manual gives some good tips:

There are plenty of good mechanics everywhere:

The general idea I get out of these two games is that they had an excellent system waiting to be used in a broader game. On their own they also end up rather dry since there’s not much outside the handling of the combat. You have to camp frequently, eat and recover morale/fatigue. It’s essentially tactical hack and slash with a very bland setting and “flavor”.

The CRPG Addict of course played and completed both:

Wizard’s Crown (1985): P1 | P2 | P3 | Revisit

Eternal Dagger, The (1987): P1 | P2 | P3 | Won

And this is what he has to say:

“I can only say that I’m glad that they simplified it for the Gold Box games, because there are enough statistics and options in combat to give a migraine to Sun Tzu.”

My opinion is slightly different. A lot of what doesn’t work with this game depends on interface and controls. Moving around and switching the facing are extremely clunky, the command menu is a list of 20 letters you have to memorize, and not all mechanics are immediately clear even in the manual. But the system overall is elegantly designed and manages to make all the right choices: skill based progression, tactical movement and facing, weapon classes with perks, damage types, armor as absorption.

Once you have the overall picture the system is actually simple. Its basic matrix is well done and built on what matters. The problem is again that once put in practice the handling was rather clunky.

Tabletop RPGs, D&D and TACH0: final analysis final (part 6)

Part 1Part 2Part 3Part 4Part 5 – Part 6 – Part 7

Sub-part 3 (of 3) on TACH0

How about not even knowing if you hit, or if you did, if the hit did any damage?

It’s an interesting mechanic but I don’t think it applies all that well to D&D and similar.

Realistically you know when you swing your weapon if you’ve done any damage. It also goes against the most current trend. In general players roll their own actions, and rolling for damage is part of the satisfaction of “swinging the sword.” So in classic PnP it makes sense that you roll those dice personally.

There’s also this modern trend of letting the players roll ALL the dice. It comes in two flavors, either the NPCs and monsters have fixed stats, or every possible action is turned into a pro-active player action. For example in combat the players either roll their attacks, or their active defense. So when it’s the monsters’ turn it’s once again the players performing their defenses against incoming attacks.

Even in D&D you don’t usually know the exact damage because while Armor Class is usually known, the monsters’ HPs are instead generally rolled by the DM and kept hidden. So the system naturally mimics this aspect of realism. You know what kind of damage you’ve done, but you don’t know when combat is going to end.

It’s interesting to know there used to be referees in wargames too. It really does seem there’s not a single original bone at the roots of RPGs ;)
Part of this thread was about a “what if”, taking RPGs and removing one of their core parts, the DM. And so the idea of “solo boardgame” applied to a roguelike, dynamical world but with boardgame style mechanics. Just another hybrid (with no original bones, too).

Anyway, after the last pass above I think I might have essentially exhausted this THAC0 controversy. I’ve read a few more things but they only focus on aspects within the analysis above.

There’s an interesting one here, that deals with the mathematical translations more competently:

If you scroll down to the comments, the first one is from Mike Mearls, the lead designer of D&D 5e.

This discussion precedes 5e, so it’s interesting to know that in the end they decided to go with what I described above as the third method, the one where both the attack bonus and AC are ascending.

Now… that blog is well written and tries to promote this True20 style, that corresponds instead to the second method described previously. The problem is that it doesn’t take into consideration the practical use. That’s what someone points out in the comments:

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*. […]

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.

And another:

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

The blog author responds:

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

But I don’t think (3) is correct, since descending AC can go negative. And I’d argue about (2) too.

I don’t think that taking a number like 12 (told by a player), adding 7 (hypothetical AC, known by GM), and comparing the result to 20 is actually faster than taking a number and comparing it to an AC you have under your eyes. Simply put, I think that addition + fast comparison is always consistently slower than one single “slower” comparison. Taking a number, mentally add another and taking the result requires more memory work and mental gymnastic… I can’t even imagine this being subjective.

Doing 12 + 7, already demands more than comparing 12 to 13. It’s a “miss”. The first case falls short of the “20” target, being 19, the second case 12 is obviously not equal or above 13.

Ultimately the best algorithm is the one that can handle well both cases: starting with AC hidden and then letting the players know the odds before rolling the die, after they figured out the mysterious AC through experience.

Let’s see the breakdown of all four methods in each of the two most relevant cases:

a) keeping AC hidden (requires knowing the roll)
b) knowing the exact odds (requires knowing AC)

1. THAC0
a) THAC0 – roll = the minimum AC you hit
b) THAC0 – AC = minimum roll you need to hit

2. True20
a) roll + attack bonus = DM adds AC, sees if 20 or above (but the player will mentally calculate 20 – the roll to eventually guess the AC of the monster)
b) (20 – attack bonus) – AC = minimum roll you need to hit (but not very smooth)

3. 5e
a) roll + attack bonus = the max (ascending) AC you hit, if the monster AC is higher, you miss
b) AC – attack bonus = minimum roll you need to hit

4. roll under
a) roll – attack bonus = the minimum AC you hit
b) attack bonus + AC = the number you need to roll under

THAC0 is not intuitive but works fine after you memorize the procedure and stick to it.
True20 is a bit gimmicky. It works superficially, but gets clunky if you want to grasp the mechanics.
5e is the most straightforward despite the larger numbers due to using 10 AC as the baseline.
The “roll under” works best in the second case, not so much in the first (and it strays away from the tradition of rolling high).

If you read 5e rules there’s no mention at all that the DM should keep monsters’ AC hidden. The formula given implies an explicit AC value, so no reference to option (a) here.

With both cases the “roll under” mirrors 5e, but since AC is descending the numbers are overall smaller. So without a preference for the two cases the “roll under” is one step ahead. And if we consider that players start with (a) and then would eventually settle with (b) the consequence is that (b) is more important in the longer term, and the fourth method is the one that makes it easier.

But “roll under” still has to deal with negative AC…

Tabletop RPGs, D&D and TACH0: final analysis continued (part 5)

Part 1Part 2Part 3Part 4 – Part 5 – Part 6Part 7

Sub-part 2 (of 3?) on TACH0

Still a couple of things to add to the above. After I wrote all that, I decided to search and read online if there were similar analysis of the THAC0, and I found a few.

There’s more historical insight about the wargaming origins of the system:

In the beginning, Gary Gygax played wargames. In wargames, you would have something like an Attack value and a Defense value. You would also have a table on the game’s rulebook: If attacker’s attack value is x, and the defender’s defense value is y, you roll a die and cross-reference the result against the chart (attack values on the x-axis, defense values on the y-axis) to see if you scored a hit.

Specifically, he played naval wargames. The term Armor Class refers to ships: how thick, and how well-covered the ship was in armor plates. An AC of 1 was very good: it meant first-class armor. AC 2 meant second-class, and so on, such that a higher numerical value for AC meant that the protection granted by the armor was worse, and so it was easier to score a damaging hit against the ship.

But it’s interesting because no one seems to analyze the same aspects I did above, like the split between knowing whether you hit or not, and the odds of the roll. Instead they make DIFFERENT observations that even lead to another set of formulas.

So again if I thought I exhausted the topic, I was wrong again. My perspective if wholly mechanical, or practical when it comes to “smooth” the formulas so that they are simpler to use. But their angle is instead completely different:

A player of the game ISN’T SUPPOSED TO KNOW the Armor Class of a monster. Because this adds mystery to those monsters. It increases uncertainty and tension in the game. The idea is that you are supposed to role-play, not play the rules. And that means that sometimes the mechanics are better hidden.

How this converts to the THAC0 if the system is about subtracting Armor Class from that THAC0? It’s simple, you have to move around the formula again:
1a. roll + attack bonus = THAC0 – AC
1c. AC = THAC0 – (roll + attack bonus)
1d. (simplified) AC = cumulative THAC0 – roll

Let’s say you got TACH0 16, with a +2 strength bonus trying to hit a monster with AC -1.

The standard formula says you get to a cumulative THAC0 of 14, then add the 1 for AC. So you need to roll 15 or more.

Under the new method first you roll the die, let’s say you roll a 12:
14 – 12 = “I hit Armor Class 2” (then the master will say if it’s enough, it’s not in this case)

Now I wonder… how those other formulas deal with this other approach of keeping AC unknown?

I’ve written down some examples and it seems the third method (ascending AC, roll over AC) is the one that works best by far:
It’s just roll + attack bonus, the result is the Armor Class you hit.

1d20 + attack bonus = AC being hit
You roll 12 and attack bonus is 7? You hit up to AC 19 (or 1 in AC descending)
You roll 8 and attack bonus is 3? You hit up to AC 11 (or 9 in AC descending)
You roll 19 and attack bonus is 5? You hit up to AC 24 (or -4 in AC descending)

If instead you wanted to know the odds, in those two examples, while knowing the exact AC:
AC – attack bonus = target number (to roll equal or above)
19 – 7 = you need to roll a 12.
11 – 3 = you need to roll a 8.
24 – 5 = you need to roll a 19.

Do we have a winner? Is there anything else to all this? The THAC0 keeps (mis)giving.

Tabletop RPGs, D&D and TACH0: final analysis (part 4)

Part 1Part 2Part 3 – Part 4 – Part 5Part 6Part 7

Sub-part 1 (of 3?) on TACH0

A note & update on what’s written below:
All this, including what came before and is coming after, is extremely convoluted and confusing to read, even for me. But the purpose wasn’t to create a well organized and easily readable analysis of some problem. The purpose instead was to chart as precisely as possible my own journey. To reproduce the order of every step, in the way they happened. To follow this path, along with all the winding sidetracks, and doubts, and switchbacks, and dead ends. It is extremely convoluted to read, but it is meant to preserve the fun of the curiosity & discovery.
It reflects my own preference: I don’t want to read an history book, I want to read about the personal journey of the historian. Traverse history by digging new paths.

I should probably splinter this to some specialized forum. There are a few but I have no idea where all this mechanical wanking might be more tolerated… While I’ll probably keep here some analysis about the older stuff because if I do that elsewhere and start making assumptions they’d probably skin me alive.

I was quite satisfied with what I wrote above and the turning around of the system I currently use, but as it often happens I read something else and suddenly all the doubts are back and I have to reconsider everything from the start. In that endless cycle.

But before going there, there’s something else to say about the THAC0 and its alternative(s).

Summarizing, the classic THAC0 is inelegant because it’s hard to remember intuitively all its aspects. You have a descending THAC0 value, when you level up, that depends on the class. Then descending Armor Class you have to subtract from that first value. But not always because AC can go below zero, and so in that case you have to add the number to your THAC0. It’s not that complex but it never gets “smooth”. You often bump into some mental hiccup when you try to straighten these ascending and descending scales.

This is generally all very obvious and plain but while writing this I realized a few more things. There’s a difference between knowing whether you hit or not, and knowing the probability of the roll.

In that standard THAC0 roll you can already “embed” some calculations. Strength bonus and eventual magical weapon bonus can already be subtracted from the total before combat starts. Whereas in the other method your attack bonus will have to be added every time to the roll, because the Target Number is fixed. So the first system is compressed to a subtraction + comparison, while the second system is still addition + addition + comparison. (one subtraction VS two additions, now it looks more balanced)

It doesn’t stop there. That’s to know whether you hit or not, but to know your basic chance you need to know the number you need to roll on the d20. In the first method you already know. The single subtraction gives you the raw TN to roll. Instead in the second method you need to add attack bonus to AC, THEN subtract the result from 20. That gives you the actual TN to roll on the die. Here it becomes one subtraction VS addition + subtraction.

Let’s see, you ultimately want to know the number you need to roll on the die, so that’s the variable to find:
1a. roll + attack bonus = THAC0 – AC
1b. (becomes) roll = cumulative THAC0 – AC

The THAC0 and attack bonus can be aggregated because they are both going to be static. The variable parts that cannot be pre-calculated are the die roll and the AC of the target.

In the second method you have, instead:
2a. roll + attack bonus + AC = 20
2b. roll = 20 – (attack bonus + AC)
2c. roll = (20 – attack bonus) – AC

You could aggregate the attack bonus to 20 and write it down, because they are both static. But it goes against the grain of this formula. So that you have two different ones. One to know if you hit, and another to know the odds (the roll).

I thought there wasn’t anything else to say in what I wrote above. Not only there was more to say, but it even lead to the opposite conclusion: the THAC0 might be conceptually clunky, but works better in practice for what matters! (knowing the odds)

Is that all? Nope, there’s a third method:
2c. roll = (20 – attack bonus) – AC
3a. roll = AC – attack bonus

This was possible because both AC and 20 are static (I’ll explain better below).

And so we distill the three methods to:
1b. roll = THAC0 – AC
2c. roll = TN – AC (going against the grain, but same as above)
3a. roll = AC – attack bonus

With the second system I didn’t consider the possibility of AC going LOWER than zero (because Dark Dungeons, where the second system comes from, still uses descending AC values). For example with magic armor. In the first system you just have to consider that negative AC is added to the total THAC0. So it’s now even simpler (as long you remember the rule). Just one addition. But with the second method you’d have to add the attack bonus to the die roll, then subtract AC… Only to realize it’s more immediate if you simply add the negative AC to the TN of 20. It becomes addition + comparison + addition (shifted to the TN). But to know the odds you’d have to subtract from an addition. It suddenly became even messier.

In this case it comes more naturally to consider die roll + attack bonus on one side, and compare it to 20 + AC (when it’s below zero). It’s an even simpler calculation, but it requires to keep in your mind these two-way resolution, where you add AC to the roll when AC is positive OR add AC to the 20 when AC is negative. It’s once again a bit “fiddly”.

Here comes our third option!

It might even be obvious: what if we turn around AC as well and make EVERYTHING ascending? If the crux of the problems with THAC0 was its descending nature on its improvement (as you go up in level, TACH0 comes down), then we can as well apply it to AC. Again with a mathematically identical mechanic but even more simple to handle. Maybe?

We have once again the die roll + attack bonus. Nothing changes here. But this time the roll needs to be on Armor Class instead of a fixed TN of 20. We essentially have the same addition, addition, comparison, with some slight shuffling. AC is now calculated by adding 10 to the AC you read in the monster or character description. And that’s the number you have to directly roll over.

(If plate is 3 in the classic AC system, it becomes 10 – 3 = 7 in this one, if leather is 7, it becomes 10 – 7 = 3. Negative AC of the classic system is added to 10 here. But once this is written down no more subtractions are needed. But see below, because that also can be compacted and simply use 20 – AC.)

The advantage should be obvious. The comparison isn’t against a fixed number, but it’s found automatically as soon you look up AC. Adding 10 to a number is the most simple operation, so that second addition in the formula is much simplified. Say for example you are dealing with magic AC of -2, in this system you’d read something like 12. To which you need to add 10. It’s immediately a 22, that you have to roll over (after you add the attack bonus to the roll). It would become more complex if you had AC under 0, in this system, but it won’t happen here because 0 is the value of someone wearing no armor at all. It’s the baseline.

Not only these three systems are mechanically equivalent, but it also means that conversions can be immediate.

Between the first and second method the only difference is in the class table that gives your progress as THAC0 or attack bonus, then it’s only the formula being different.

Between the second and third we only have to convert descending AC to ascending. And that’s quite immediate: 20 – current value.

This third system seems to blend the good parts of both, it’s easy to use for both deciding on a hit, and knowing the odds. You either add the attack bonus to the die to see if you hit, or subtract the attack bonus from Armor Class to know the odds.

…But then I wondered, isn’t there a way to convert that one subtraction to know the odds, to simply another addition?

We’re dealing with Armor Class and a fixed bonus, so why couldn’t they be organized to add both together and obtain a Target Number? But since my mathematical competence is rather poor, I couldn’t decide whether this was a real possibility.

It turns out it’s possible: you just have to turn around something else in that formula.

The key to make it work is that the roll itself needs to change. You don’t roll anymore above the value, but below. And AC, since it’s added to the attack bonus, needs to be descending, so that lower values lower the odds.

The only thing left to do is slightly shifting the numbers, because we are starting from 1 on the die, not a zero. And so that +1 needs to be factored either in the attack bonus or in the AC.

For example, let’s say you want to hit some guy in plate armor (3 classic AC descending) no Dex bonus, with a total attack bonus of 4. In the THAC0 system the attack bonus becomes a 16, from which you subtract the 3 AC, to obtain 13, the number you need to roll on the die to hit. Or 40% (success on 13-20, 5% each). In this fourth system, instead, you simply add the attack bonus to the AC. 4 + 3 = 7. That’s the number you need to roll under, but that needs to be shifted to 8 to account for that +1. The result is the same 40%. (you can then incorporate seamlessly the +1 in the attack bonus itself)

I wonder if there’s a D&D based system that uses this fourth method.

But anyway, all this is only part 1 of 3. Me trying to come to terms with mathematical skills I don’t have while trying to find solutions to problems solved decades ago.

DIGRESSION #1: Tables VS Formulas (this was where I wanted to go next, at the time… It didn’t happen)

Tabletop RPGs, dice wars: linear VS bell curve (part 3)

Part 1Part 2 – Part 3 – Part 4Part 5Part 6Part 7

This time I prepare for THE HOLY WAR.

Dice wars: linear VS bell curve.

I’m lost into many other sidetracks but I was now trying to wrap my head around some very basic mathematical problem and I could as well write it down since I stumble on this constantly.

This isn’t about the solo boardgame project and more about my other project on the very complex combat system, but I guess I’ll use this thread to write about all the things (I want to make an analysis about two of the lesser know systems, Chivalry & Sorcery and Ysgarth, next).

The theme here is about the basic mechanics of a to-hit roll.

If we consider on one side the classic D&D d20, and on the other side systems like RuneQuest or Harnmaster, that are based on d100, it doesn’t seem there’s a concrete mathematical difference…

For example if I have my sword skill at 50%, if I roll the d100 under 50 it’s a hit, if I roll over it’s a miss.

The difference from the d20 seems to be just about the granularity: the d20 progresses at 5% steps, in the exact same linear way. So let’s say my TACH0 is 16 and I’m hitting some guy with 5 Armor Class, I roll 1-10 it’s a miss, I roll 11-20 it’s a hit. We got the exact same result of the system used above.

TACH0 improves through leveling up, with 5% increments, in the same way a skill system does the same thing, with whatever step of increment you decide to use.

Are we dealing with mechanically identical systems, at a basic level?

What I was trying to figure out is how this (a linear distribution) compares to a system like GURPS (3d6), using instead a bell curve.

We miss some granularity because the results go only 3-18, so -4 steps available, but also due to the different distribution the most common results are in a narrower range. And basically the ten results between 6-15 are roughly 80% of all possible results. Compared to a d20 where that 80% is mapped across 16 results instead of 10.

What are the merits of a bell curve, then?

Because in the end, for a to-hit roll, the value is still a target number. If you use 3d6 and have to roll 11 or better to hit, then you still have the exact same mathematical probability of the systems used above.

If that’s true then the mechanical difference can only be when we move to consider the progress system:
+1.39 +2.51 +4.9 +6.94 +9.73 +11.57 +12.5 +12.5 and so on in reverse.

It’s essentially what’s being shown in the third column of this chart, from the compiled rules of Traveller:

It translates to: slow to both learn and to master. If you match this with a level system where you gain a +1 bonus every level, the result is that the character will always miss for the first few levels, then rapidly improving, and with the higher levels a progressively slower growth. (but not quite, GURPS makes the cost of the +1 variable on your Dex value…)

I’m trying to distill “meaning” out of all this.

Essentially, when you have a target number then bell or linear curve make no difference. You either hit or miss, it’s a binary result and the distribution doesn’t affect that result. For example, if we want to use a 3d6 bell curve, but want it to map on a d100 system, we can look at that image above, the 5th column. Those are the “steps” available with the 3d6 granularity. So, in a d100 system, you could have a skill at 16%, and that’s exactly the same as a “7” on a 3d6. By rolling 3d6 you continue to have 16% of rolling below. Simply to say that rolling a d100 and succeeding only on a <= 16 is mechanically equivalent as rolling a 3d6 and succeeding on a <= 7.

It affects instead the progress system, or the way that target number “moves”. But with a d100 I could mechanically copy the outcome by designing a progress system around the same values of the one based on the 3d6.

This, oddly enough, was triggered by reading about an OSR system (OSR = Old School Renaissance) called “Dark Dungeons”, that mimics the rules of the basic D&D set.

What was explained in the rules is that we all known the clunkiness of a system like TACH0 and there are always debates about what’s the best system.

Dark Dungeons replaces it by using a system that it claims to be mathematically identical, but that is much simpler to use: instead of a TACH0 value, you have simply an attack bonus. It’s given by your class and Strength bonus. So the to-hit roll is:
d20 + attack bonus + armor value of the enemy.
If the result is 20 or higher, you hit, if not, you miss.

Armor value in this case is descending but it works because you don’t have to subtract it from some arbitrary value, you simply add it to the roll. So if someone is without armor his value is 9, and that will obviously push the result closer to 20.

Ultimately it’s all about ease of use and nothing else, if the system is mathematically identical then there isn’t anything else to consider beside that ease of use.

While looking into this I found this page:

It easily explains there’s a hierarchy of “ease of use”: comparison is easier than addition, which is easier than subtraction, which is easier than multiplication, which is easier than division. (for “comparison” I think it means “less than” or “more than”)

The classic D&D TACH0 is made of: dice + attack bonus, compared to armor value subtracted from a class-dependent target value.

Versus the simplified system in “Dark Dungeons” that is: dice + attack bonus + armor class, compared to target value (fixed at 20).

So: addition, subtraction, comparison VS addition, addition, comparison.

This is simplified in two ways, one addition replaces the subtraction and the comparison is always against a 20, so you don’t have to look it up. While both attack bonus and armor class have to be collected every time in both systems, since they are variable.

From that sidetrack the problem becomes: is there something that a bell curve offers and that can’t be “mapped” on a d100 system (or other linear systems)? Is there something that is intrinsically different?

In general, the distribution of the possible values does matter, for example the typical damage dice. Rolling 1d12 is different compared to rolling 2d6, because you’ll statistically obtain a 12 much, much more frequently by rolling a d12. But even in this case, if you are against a dragon with a million hit points, it doesn’t matter. Because over time those rolls will even out around the middle, and once again the two options become identical.

The general consensus (and math, we aren’t dealing with “opinions” here, the only opinion is the potential lack of insight) is that the bell curve is more “skill based”, and so less random. The distribution of those results is narrower, so the outcome is usually more predictable. Compared to a linear system where instead the outliers are just as frequent. In fact, the bell curve is also often matched with dice pools (Earthdawn being a good example), and especially with exploding dice. It means results are common (same-y), and when they get uncommon they have the potential to become truly extraordinary.

(But I’m not a fan of exploding dice. Even if they happen rarely there’s always this possibility the system goes completely out of control. It simply makes randomness king, eventually. And it is randomness that can happen at very illogical times. I understand the appeal, but I prefer something more structured.)

…And then I thought, what happens if I try to mix up everything?

My current system, at a basic level, has the to-hit roll based on the standard d100. You have a % skill, take a 1d100 and need to roll under your skill.

…What if I replace the d100 with a 2d50 (because being based on computer code I can afford something weird)?

The resulting bell curve is a bit more flat, but we obtain that “realistic” effect of having more predictable results. The whole range that goes from 2 to 23 is cumulatively just 10%. 26 is where the probability is 1%, so matching the linear system, and it grows to 51, where it’s 2%, and then goes back down to 1% at 76.

2-23 = 10.12%
24-75 = 76.88%
76-100 = 13%

There are two direct consequences of this experiment. The first is that I have to redo the criticals, since the range 2-10 is less than 2%. GURPS for criticals uses 3-4 and 17-18 (plus a few quirks, but let’s keep those out), so still less than 2%.

But more importantly, the whole idea of score percentages goes out of the window because your skill value isn’t mapped anymore 1:1 to the probability of that number. If anything, it becomes misleading.

So I though… Let’s go further and make more radical changes. I keep the 2d50, but with score percentages gone I can as well turn it upside down, so you don’t anymore roll UNDER, but over (as it happens above with Dark Dungeons). Let’s say that instead of rolling under a target number you have to roll over a fixed value = 100. So now we have the bell curve of the dice that gives us the baseline number. That’s random chance and it will follow the bell curve, so with the most typical results (80%) in the 25-75 range. To obtain a 100 I then would need some sort of skill value that goes from 75-25 (at minimum), of course.

In the end I would have mapped GURPS onto a 2-100 wider range, slightly flatter “bell”, then reverse it so you have to roll over, and using a fixed target number instead of a variable skill value. It’s not impressive, but it should work fine.

The bell curve is intrinsically counter intuitive. There’s no fast way to extrapolate the exact %. So that’s an aspect that is unfixable. Linear systems are immediately explicit, whereas bell curves are more opaque but simulate better a certain behavior.

At this point I started going a bit too far and wild with ideas. For example I imagined a system that came out of the desire to have a melee combat where every attack carries a momentum to the next. So instead of having a fixed skill value, it might work like first you roll the dice, let’s say you get a 30. So now you need at least 70 to hit 100. And you could have instead a skill “pool” that you can use. So in this case you have a tactical option. You either “push” the attack and spend 70 points (but maybe leaving you out open for a counterattack, if you spend too much on the attack and don’t have much left for defense), or you can instead not spend those points and wait the next turn in the hope for a more favorable roll. It even gets interesting tactically because you could try to “build up” an attack, but it would always be a gamble because if you got hit before you next attack you then would also lose all your momentum with it.

…So I’d have a system where every turn you get a “pool refresh”, maybe based on Dex, or Initiative, or both, and where you carry over the values from the previous turn, in one flow.

This gets too fiddly and with too much bookkeeping even for a computer system. But maybe I can replace those numbers with “tiers”, like every tier is +5 points. That way I can mask away the lack of explicit percentages inherent to the 2d50 (while retaining the benefits).

…But that would gave gone against ANOTHER idea I had. The problem with skill based systems is that the basic statistics become almost irrelevant. Once you get your skill value that’s all that matters, and the stats only give some weak bonuses here and there. The D&D d20 isn’t that different and in fact it’s not skill based but class based. So it’s actually the class that has the biggest impact on what your character can or cannot do.

My idea here was about making the progression of the skill directly based on the stats it is derived from. The basic stats that you generate during character creation would be your natural disposition. So for example a guy with very high Dexterity makes for a potentially amazing archer. But it’s not mandatory, you get good only if you practice enough. On the other side, if you have a poor talent you can practice as much as you want, but you will still struggle a lot compared to the other guy. How this translates to the game? You make the SKILL progress depend on the STATS. So your improvement with that skill, over time, directly depends on the stats that rule the skill. And you could still focus a lot and improve in a skill that doesn’t come naturally to you. You’d just observe a slower progress compared to someone with a natural talent. …But all this goes against the idea of fixed skill tiers to use (because the rate is directly variable in its granularity).

How to fix? Well, I thought of separating the systems. So you have “points” (like Dark Souls’ souls) that you spend to buy skill “tiers”. But the COST in points of the next tier depends on the stats. So a guy with high Dex will have to spend less points to buy a tier in the bow skill, compared to a different guy with lower Dex. And the tiers still end up fixed +5!

And it goes on and on. I shouldn’t waste time writing all it down, but I kind of need to, or face the risk of going again and again through the same ideas.

In any case, if you take it as a whole, all this brainstorming lead to a clunky (but potentially interesting, once massaged into a better form) system that looks VERY similar to the one used in The Riddle of the Steel. Also because once you use a variable system like this one you the realize you don’t really need anymore any target number. You just let the player decide the “intensity” of the attack and see what your opponent does with it. For example a weak attack that in the classic system would be an automatic “miss”, here could still land if the defender doesn’t defend, and still do a little bit of damage (because in my system the to-hit roll has influence on damage done with that attack). But maybe the defender went for that option to prepare a much bigger counterattack by not wasting his own points on that defense for that weak attack and pour them all on his own, stronger attack… It’s tactics bound to a nice random bell curve!

And this brings me to the last point: I still need to do more basic research.

This isn’t a wide argument just about linear systems versus bell curve. There’s a third option that is extremely popular, especially in all the more recent games. And it’s all about pools of dice rolled against a target number. The downside of these systems is that they are VERY OPAQUE, in the sense again that the probability of success isn’t immediately explicit, and calculations are non-trivial. Sometimes the rules manuals hand you a nice table, but quite often you are on your own. But on the other side it’s a system that embraces much more directly both the opposed rolls AND variable successes.

It’s not anymore a binary hit/miss, but how good was the hit and how bad the miss. In some elaborate systems, like those used by Fantasy Flight, you directly have “narrative” side effects:

That, too, can be mapped out of the narrative and in a more mechanical way, but I think it’s still too fiddly.

I certainly need to research more the basic advantages/disadvantages of a dice pool compared to the other two. Only when I know all the technical details I will be able to do some more fancy experiments.

Squaring a circle would be too trivial, so I’ll have to find some way to take this triangle and square it into this circle. Possibly with a very big hammer.

(All the while, reinventing wheels. If it wasn’t already painfully obvious.)