Part 1 – Part 2 – Part 3 – Part 4 – Part 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:
http://deltasdnd.blogspot.com/2009/07/what-is-best-combat-algorithm.html

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…

Part 1 – Part 2 – Part 3 – Part 4 – Part 5 – Part 6 – Part 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.

Part 1 – Part 2 – Part 3 – Part 4 – Part 5 – Part 6 – Part 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.

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

Part 1 – Part 2 – Part 3 – Part 4 – Part 5 – Part 6 – Part 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: http://www.darkshire.net/jhkim/rpg/systemdesign/dice-motive.html

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

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

I was supposed to add a part where I was going to explain that nothing really begins anywhere.

The FPS didn’t begin with Doom, RPGs didn’t begin with D&D, and the fantasy genre didn’t begin with Tolkien. What’s fun is to dig out what came before, and then see if things could have also gone in a different direction. And so the time warp.

The problem is I already outpaced my train of thoughts and gone in a different sidetracks.

Here above I was commenting on Valkenburg Castle and how it’s a completely unknown little game that blends wargames and RPGs, in those chaotic and creative years when the classic historical wargames started to hybridize with fantasy and sci-fi.

So I thought, am I the only one seeing the huge potential in that small game? How it could be the gate to something bigger that didn’t happen?

Not really, because it did happen.

Weeks later after looking into Valkenburg Castle I realized the designer, Stephen V. Cole, is not some unknown dude who made that game and then disappeared from the scene, but he was the creator of a much bigger thing: Star Fleet Battles.

That’s a giant tactical game in space that continued to be relevant, despite its substantial grognard-ness, from 1979 to 1999, pretty much. That also spawned its supporting ecosystem of magazines like Nexus and Captain’s Log, while going though various versions of rules compilations and endless erratas. Pretty much like Advanced Squad Leader. But in Spaaace.

It also lead to the development of a new language that looks incredibly close to a cat walking on a keyboard:

Or, at other times, almost machine code:

Yes, we are grognard, but are we grognard enough?

I also found out that the format of Valkenburg Castle was actually copied from the “MicroGames” done by Metagaming (that also published the magazine The Space Gamer), that I also mentioned above because two of those microgames were “Melee” and “Wizard” designed by Steve Jackson that would then be joined to make their D&D rival called The Fantasy Trip.

These MicroGame games have all a similar format. A few pages of rules, an handful of counters and a game board themed around a concept.

Those were times of wild experimentation and hybridization, and it’s from there that D&D came out. What I absolutely didn’t know is that a whole lot more came out, and now I’m discovering it first-hard, as it happened back then. I’m finding that past that was overwritten and hidden away.

Going through all those loops made me find this:

And look more closely:

This guy that, if I’m not wrong, I heard about on this forum back then when I first found it. But I don’t remember what it was about. I think he had a blog where he ranted about stuff, those years when we all had a blog where to rant about stuff.

But Greg Costikyan made a lot of games, in the styles of these above.

One of them looks very closely to this idea of the solo dungeon crawler, where the dungeon is generated and assembled with some basic board pieces.

It too had the foundation for a “campaign”:

And so we are back to this idea of the unknown (forgotten) fantasy board game.

I wonder how much stuff does exist that indeed did happen but I simply know nothing about. I connected a whole lot of dots, but I really don’t know if the fantasy genre really mixed with the wargaming one. I knew about Star Fleet Battles, and all those variations of 4X and tactical battles (Starmada is another), but it all relatively blank when it comes to the fantasy side of things.

I wonder if there was an equally expansive fantasy cousin to those deep tactical sci-fi games. And probably it might be that Blackmoor that was then overwritten and erased by D&D, but I’m not sure. It might be once again that it exists and I know nothing about it.

In any case, to link back to the starting point, not even Star Fleet Battles was a beginning, of course.

That’s a real boat, from a different game called Battlewagon, also by Task Force. Wasn’t Star Fleet Battles about boats in space anyway?

But maybe not, because Battlewagon came out later that SFB… So who knows what came before SFB?

In any case, those years going from early 70s (or even before) to early 80s are a goldmine, if a little hard to dig.

I have to go back.

—
Oh, and I was forgetting. Sometime you have those widgets that give information about the “complexity” of a game.

I’m looking for the stuff in the “impossible” tier. that one step beyond the absolute grognard. The mind-bending, soul shattering bookkeeping.

And I CAN’T FIND ANYTHING.

They are all pansy “intermediate”, at best.

Now these days a game like Star Fleet Battles is up there with the absolute grognards, as I said.

…But back then?

Look at this shit:

Back then SFB was considered “introductory”!

Before everything got watered down into nothingness, those grandfathers of games didn’t cower in front of an handful of charts and tables. They knew their stuff.

But where the hell are the HARD games?! Have they transcended reality and left no trace?

(not everything written here is True, but a slight divergence of perception is in the nature of a time warp)

—

loses some of the essential ambition of the game in its presentation.

I rage at this. It’s always the same…

Anyway, I vaguely mentioned above Starfire, a close relative of SFB. That too got greatly expanded… and then dumbed down in the most current versions.

But it is interesting because Starfire was the foundation that lead to “Dwarf Fortress in space”. That grognard computer game known as Aurora.

Sadly the author decided to go through endless rewrites of the game, so it has stalled for years. But it’s probably the most ambitious 4X out there:

http://aurora2.pentarch.org/index.php?topic=5663.0

—

??? current version of Starfire (SOLAR Starfire) is pretty much unplayable due to the complexity (429 pages of text and more text…). It’s also poorly organized and you need to have played SF 2 or 3 (which are the playable but expansive versions) to be able to understand what the hell theya re talking about.

You might like looking into Victory by Any Means (VBAM). It’s much more simple, but still complex enough (especially if you use the first edition with expansions and optional rules) but much more playable. It is a campaign system with no tactical combat rules (you are supossed to either use the fast combat resolution included -works well for the scale- or plug in your favorite starship tactical combat system to resolve battles).

For fantasy I don’t think you have mentioned Dragon Pass yet (or White Bear and Red Moon if you want the very original). Cool wargame, average complexity on the basic, but loads of special rules and lots of flavor. Also, Heroquest’s setting comes from this game, so definitely another tie between wargames and RPGs.

Yes, from what I read the “good” version of Starfire was the third. The maximum “reach” of the game was between the third and fourth, but the fourth was a mess of its own and didn’t establish itself.

The fifth was an attempt to reorganize again the fourth, but it says right on their site:
“Updated over the next 5 years, the goal of ULTRA STARFIRE was to produce a set of rules that were streamlined, had reduced paperwork”

Of course that sounds good, but not in my peculiar book.

Then the sixth version continues pretty much the same.

In their own internal complexity chart Task Force, even the third version of the game, considered Starfire a “moderately” complex game. Only when you add the campaigns then it moves to “advanced”.

There’s a thread on Aurora forums where they discuss a bit the various versions:
http://aurora2.pentarch.org/index.php?topic=4731.0

I’ve also looked at other Task Force games and they are all usually “moderate” at best.

There’s also this thing about the YEARS. I pretty much can write off everything that comes after 1999 (at least through this retro perspective). It’s the whole mindset that got warped. That’s why it’s so hard to truly go back, because most current resources on the internet filter the old stuff through the modern point of view, rather than letting you FEEL the ways these games were perceived during their time.

So for example Starfire develops between 1975-80, then the second edition in 1984-85, and the third in 1992-93. The 90s is when everything IMPLODES. It’s when things start to get muddled. There’s some good stuff because it comes in the wake of some big games that still drag their origin with them, and those don’t simply vanish, but when something goes past early-90s then it means it most likely lost all its flavor. It’s game over.

Hence my reticence to consider Starfire in all its incarnations past the fourth. These are new species of gamers, even when they are old-schoolers and grognards.

—
Some info on that chimeric Sword Path Glory melee system:

“The rest of the combat system is also fairly complex. For example, combat takes place using a 1/12th of a second time scale. Weapon, shield, and movement speed are all tracked separately. When moving, you track acceleration, deceleration, and turn radius. There are specific rules for how armor affects damage — both inflicted and taken — and much more.”

SP:G is what you get when five off-duty engineers lock themselves in a room and they want some realism. It models able-bodied, right-handed humanoids *(he said it scaled down to dwarves really well, 4’2″ guys with 40″ vertical leaps in armor)* down to 1/10 second impulses, with linear and rotational acceleration rates, and every single swing. For damage, they modeled weapon tip shapes, body target areas, and the volumetric intersections thereof, and assigned hit point density values based on things like muscles/nerves/brains.

The designer of the game now works on slightly less complex stuff:
https://www.researchgate.net/scientific-contributions/2113111462_Barry_Nakazono

The widening links of my projects’ chains are becoming galaxies. Come along for an impossible, pointless journey through time and theme.

Back in April 2019 I wrote that I was going to archive some rambly posts, so I will now.

This will be a flood on tabletop RPGs. I’m going to move here what I wrote at the time across a couple of forums. Then maybe I’ll move to an analysis about the various iterations of Chivalry & Sorcery. One of the most significant destinations is the 70s.

(This is how long? 6000 words? Just the first part? Ok.)

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

—
“The only way forward is going back.”

But I’m not going forward here, I’m crossing the streams. I’m doing a time warp by stepping sideways, to a different timeline.

It’s because I enjoy completely owning, solely driving, and wholly understanding the narrative and mechanics in these self-contained story/challenge machines. They’re like computer games but without any graphics to shove my imagination aside and without any rules running unseen under the hood and without any hardware conflicts or bugs or framerate issues. They’re tactile and complete, played at my own pace, saved anywhere. I can mull over a turn for an hour while I do something else, or just charge ahead to see what happens, because if it all falls apart, I can just start again.

But I know it looks weird to a lot of people who have no compunction about playing a computer game solitaire, or boardgaming with a group of friends. Why doesn’t it make perfect sense that just as someone might play a computer game with friends, someone also might play a boardgame solitaire? To me, they’re all of a piece.

-Tom

—

Huh?

I thought it was better to splinter this from the thread where we discussed Pen and Paper RPG rules and progression systems, because it was about to go way off the rails. Usually I would write this and tuck it away on some blog, but I decided otherwise for the following two reasons:

1 – It’s overly ambitious in depth and scope. No hope nor plan to ever make it concrete, so the goal is to inspire someone else with ideas that are cool, on their own. “Passing the torch”, so to speak (if someone won’t mind getting burnt).
2- Maybe eventually get some feedback or suggestions about those ideas, furthering the rabbit hole, solve problems and all that.

But due to the extremely niche nature of the endeavor I doubt people will engage, beside some superficial curiosity about the breadth and mess of such project(s).

Beginnings.

Anyway, all things have origins that are treacherous and misleading (the theme of origin will be discussed later, it’s the prerequisite for creating new timelines and changing the world through syzygies and timegates, hint: they are the same, but we won’t go there, here). Because no-thing has an origin, only a flux in a system of complexity. The more you see, the more you see (especially the redundancies). The “origin” of this project was (quite) a few years go. I spent some time in a time machine, living again the medieval age of computers. It’s something extremely absorbing to do because now you can find on the internet those old magazines like BYTE, “Creative Computing” and so on, while also watching “Halt and Catch Fire” for flavor. The stuff that is the most important is the stuff that you’d ignore, like ads and readers’ mails.

At the same time I launched myself on a journey through the early (well early for me, I started there as a kid) computer games, on the Commodore 64 and the Amiga. All sort of stuff, but especially RPGs. And especially dungeon crawlers. Dungeon Master, Black Crypt, Captive, Fate Gates of Dawn, and so on and so on (insert Zizek meme). But with my style, that is about analyzing and abstracting. All games have universal mechanics after you abstract them enough, and then you can re-base them, and create something new (more on this later… and before).

I was fully immersed, with the game magazines as companions, of course, or it would never work. You cannot go back without context. And so reading Zzap!, Aholy!, Compute Gazette, and all that. I went through the whole lifetime of the Amiga, looking up games in the emulator and then reading reviews and the excitement of those years. (the work of The CRPG Addict was also invaluable… who’s now on Patreon and for just $1 you should support him!) I remember the last game was “Liberator”, a really weird and overly ambitious sequel to Captive on the Amiga CD32 (and a mess to set up properly). Right after that I went for a different journey, through the breadth of the “roguelikes.” Not really following a timeline, and more jumping around to see the most interesting ones. To get a whiff of that absolute freedom. (those that are important for me: Cataclysm:DDA, Legerdemain, Incursion, Tome 2.3)

(at this point I wrote many more paragraphs describing the history of this project, but I’ll cut to get faster to the point)

Through all that I started building on an idea (or rather, an unending stream of ideas, that continue to this day): I would try to code a roguelike-like based on a few parallel paths: the history of computer RPGs, the history of Pen & Paper RP systems, and my own learning how to code, starting from scratch. It was an ideal trajectory, where my project would work like a time machine, from the early simple days to the maturity of the genre, with much deeper mechanics and broadening of the scope. I’d use my game-project as a vehicle to move through time.

(Consider this: the simplicity of the first RPGs wasn’t for a lack of ambition, but it was shaped by hardware constraints. Those programmers and designers had to worry about exhausting memory and speed. Here instead I have INFINITE POWER. That enables me to slipstream through time, and express what couldn’t be expressed.)

I wasn’t trying to learn how “to code”, but just getting to a serviceable point where I could then do what I wanted to do, so that I could experiment with the core “content”, the design of the game itself. An ideal “plateau.” With also another purpose: to rediscover what made those old games truly special and that is now lost. Because yes, progress is transformative and things get better. But with that process there’s something that always gets lost, and that still maintains its potential if you know how to find it and express it. There’s so much value that is NOT nostalgia, the lifeforce wanes with time, and you have to go back to discover how it works (this will then lead to the principle behind this new project).

I was actually able to achieve a lot of what I wanted to, but I also got severely bogged down every time I had to deal with the UI. Even coding a tiny menu with mouse controls would require me many, many hours if not days. I didn’t get stuck, but I was moving so slowly that it felt like trying to paint a wallpaper in 4k, pixel by pixel.

It got especially worse when I tried to code the primitives of what would become both an event and dialogue system. It was way too much code “busywork” and not enough the core I wanted to spend time on. And this is the important part. My roguelike project was built on the idea of building a “full” Pen & Paper system. I didn’t want the feel of a computer RPG, I wanted the PnP RPG feel. All mechanics being explicit, all classic dice rolls and no shady computer calculations. The idea was to meticulously study ALL the existing systems and make one GIANT FRANKENSTEIN HYBRID. I was going to fuse the history of PnP systems into one. The one ring to rule them all. (I know it all sounds bullshit, and I was fully aware of this bullshittery already when I started, the Vision is lucid)

The basis of the system was going to be Harnmaster, a game that aimed for a quite in-depth, tactical combat based on the percentile dice, so not much different from Chaosium games like Call of Cthulhu and RuneQuest. It’s the most straightforward mechanic to grasp, you have like a 75% to succeed and that’s immediately intuitive. Then I started to layer more and more systems on top of it, taking the turn phases from Combat & Tactics supplement for AD&D 2nd, integrating some ideas from the less known and fidgety Gygaxian Dangerous Journey, trying to make sense of RoleMaster… Until I really discovered the entrance to the rabbit hole of complex combat mechanics: The Riddle of the Steel, leading then to its spawn of three, Band of Bastards (Sword and Scoundrel), Blade of the Iron Throne, and the better known Song of Swords. Hunting down their respective alpha versions so that I could study not only the shape of those games, but they way they evolved through their design. But these are just a few examples because in just the last three months my knowledge increased tenfolds, until I dug deep and struck an ancient vein of true gold: Chivalry and Tactics, Aftermath!

…and then the deepest cavern, the Leading Edge games:

Sword’s Path Glory, Phoenix Command and Living Steel.

It sounds like a joke but the game design of these games was made by a guy who’s, literally, a rocket scientist working for NASA. And if you read some comments on the internet you’d learn (if they are to be trusted) that all the games produced across a decade were a way to “dumb down” the original concept in a way that it could have been at least accessible for the most hardcore of the grognards. From the original Sword’s Path Glory, to its first dumbed down public release with a red cover, to another simplified version in two volumes, this one the only one that still survives today. Its advanced book, though, was never completed:

The story, and simplification of rules continues with Rhand – Morning Star Missions, this time offering a fantasy setting along with the simpler rules. A setting that then would be kicked in the far future with Living Steel, that is sci-fi with power armors. But before getting to that point there were another couple of games, Spectrum Small Arms (some people claim having it, but it’s like the Grail) and the most famous of all: Phoenix Command.

The funny thing is that Phoenix Command, the system that was the result of many phases of rules’ simplification, is considered today the game that still defies the most grognards:

“Any game system needs to balance complexity against “realism”. Modeling reality is can be complicated – super-complexity doesn’t make for enjoyable gaming. Designers have to draw the line at some point in the spectrum. This game has no line.”

“There are plenty of reviews/play sessions around the internet that try to play out a single round of combat (sub-second in game time). Most of these conclude it takes about twenty to thirty minutes to execute a simple round with a few combatants. I’ll note that I’ve yet to see this done for the Advanced Game. I’ve never seen it done with mounted combat, mechanized vehicles, artillery, hand-to-hand, or engagements with more than a handful of combatants (usually it’s with two). I’ll note also that most of the summaries you do find have various disclaimers like “we didn’t use the drop radius rules”, or “we didn’t use the impact location rules”, etc. That’s because in reality the game is too complicated actually to be played. You just can’t follow the rules because there are too many rules, too many formula, and too many variables to actually track. You can muddle through it and give it a college try. But you really can’t just play it.”

And of course I absolutely relish this stuff. And SUFFER because I really want to lay hands on that 300 pages fantasy supplement that was never published. It’s one of my most sought human artifacts. My precioussss.

But hey, these guys also made a really cool Aliens boardgame, also produced by further phases of simplification, and even a really cool Aliens RPG, both “regressing” in complexity to the point of being ALMOST playable and fun.

This to show the path I was following. Studying these complex systems to learn their cores, abstracting them and see if I could use those ideas into my own hybrid thing. I knew it could work because what players hate the most in complex systems is the bookkeeping, and the bookkeeping is what computers do best. I could get away with lots of complexity that would bog down a true PnP session. As long those rules were coherent, they would only broaden the tactical possibilities. They “would make sense.”

In the process of doing this I was also not avoiding the possibility of stepping back from time to time and appreciate the elegance of simple systems. There is no perfect game, only games with different goals and strengths. Pathfinder is good for what it does, same as those systems that inverted the path and went back (known as “OSR”, Old School Renaissance in the form of Labyrinth Lord, Swords and Wizardry, Lamentation of the Flame Princess, Dark Dungeons, Astonishing Swordsmen & Sorcerers of Hyperborea, Champions of Zed, Adventurer Conqueror King, Dungeon Crawl Classics… and I could go on for a while. Until the quirky but ingenious progressive systems like Torchbearer and Dungeon World.

But my attention was caught by a different sidetrack: the solo RPGs.

Now I need to step back a moment. Another foundation of my roguelike project was that it was meant to miss two of the most important core features of a roguelike, the way the term is meant in modern times: all content was going to be static and handcrafted, and death that was harsh but not permanent. Again, I wanted the old-school feel of dungeon exploration. And this was the antithesis of a roguelike, where you run through samey looking, mostly empty rooms to kill dozen and dozen of monsters in a few hits. From Nethack to Moria/Angband and all their spawn, the formula is to move and kill, with very little flavor that wasn’t coming from the intricacy of the tactical scope. Instead I wanted room descriptions, interaction with objects, clever traps. And when it came to combat I wanted much, much rarer fights, but that played with the complexity of a turn based game. Like a Final Fantasy Tactics, but with PnP rules that came from Harnmaster, Runequest, RoleMaster… and now Phoenix Command.

(…but a few years later…)

(Steve Jackson would then move on to make GURPS, even if that took a few more years)

Maybe you can now have a glimpse at the Big Picture. Not only my project was aiming at this huge systemic complexity, but it also wanted to recreate the old-school feel through those specific room descriptions and interaction, let’s say a retro-evolution of the Gold Box games, unlocking that potential that no one saw. A fully handcrafted dungeon that offered A LOT more than monsters to kill. But that also meant that not only I need to create “a game”, but also the “content” of the game. Room by room, drawing and writing the dungeon, reading old RPG modules like Temple of Elemental Evil, and warp, fuse with everything else. Creating new shapes from the old. And, again, of course I knew all of this was absurd, and I kept joking I had a project that I absolutely could complete, give or take 700 years, working full time. I knew exactly what I was doing, I had a clear Vision, no groping around blindly to find out what works or doesn’t, it was all precisely directed and no roadblock in sight. Only the flimsy transience of existence, but who cares.

That duplicity, of the game as a system, and the game as content, was a problem that was unsolvable by its nature. A dungeon had to be created room by room, no shortcut. I was deliberately moving away from the generative, dynamic structure of classic roguelikes. The stuff I wanted to avoid the most, if you again look at how strongly I wanted to adhere to PnP material, “no computer stuff.” I didn’t want to get swamped with algorithms to generate dungeons and other non-boardgame mechanics. Including pathfinding and enemy AI, that were mandatory and unavoidable anyway.

And that’s the whole point.

I realized there was this subset of games that DID AWAY WITH ALL COMPUTER COMPLEXITY. That removed everything that was “technical.” A miracle. All that baggage that seemed embedded in the thing… completely gone. There’s a subset of systems whose main purpose is to be played alone:

D100 Dungeon, Four Against Darkness and the more recent Rangers of Shadow Keep.

(and along those I also found a cool youtube channel where grandma teaches you all the secrets of the solo RPGs, I love this channel now)

The “mechanics” that build these games are essentially nothing more than a bunch of tables that are put together in a clever way. And what’s one of the easiest data structure in a program? A table. I realized that it would be rather simple to “convert” a game like D100 Dungeon in a computer game. Once you know how to print text on screen the rest is straightforward. And it’s a wholly contained, replayable system. It needs “content”, but it’s systemic content. It’s built on moving parts that stay in the game.

So I started to have a vision of a much different “roguelike” hybrid, one that was the antithesis of my other project. With simple rules and generated content. But not “generated” through complex computer algorithms like Dwarf Fortress or Caves of Qud. Generated instead in the sense of a boardgame hybridized with a RPG. A (solo) boardgame-style computer RPG. Something that could actually be made whole and COMPLETE in a (almost) realistic timeframe. Not a project that defied humanity as a scale, but something humanely possible. Even by myself (although not really).

This new project would start by deconstructing and analyzing the moving parts of those solo games. The prepping before an adventure, for example, creating the character, equipping it, choosing a quest. Then moving to the dungeon itself, the mechanics of the player’s choice, until the end of the quest, so the reward and character progress. With the idea then of chaining these small adventures into a bigger “campaign”, that could open up and scale to new levels. Once again I would study the mechanics of these three systems, and then fuse the best parts. One game, with a bigger scope.

Now… You probably start having the feel you’ve already seen this. For example Darkest Dungeon is doing exactly this. But it isn’t. Darkest Dungeon follows a similar structure, but again it is deeply ingrained as a “computer game”. It’s full of fiddly bits and it’s a game of attrition where all the focus is about the tactical combat and the way you build and develop your party. Those fiddly bits move it very far away from the feeling of a RPG. It’s a great game for what it does, but the focus I want is instead on the adventure. On the exploration.

To find that flavor, again, you have to go back.

Let’s call this initial analysis and fusion of those three solo games I mentioned as “Phase One.” When that’s done I’d have a self-contained system that’s relatively simple and straightforward. That “just works.” It wouldn’t be all that interesting, though, because the success of those game comes from the physical aspects, holding the dice in your hands, drawing the maps with real paper and pencil. Once you erase that layer it would probably feel playable, but shallow. And when I strike a vein, then I don’t stop.

The idea that followed was that if I was making a boardgame-like roguelike, then I could go ALL THE WAY, and embrace the vision. I needed more breadth and complexity, and I went where it can be found: Gloomhaven and Kingdom Death Monster.

Phase Two would be to hybridize the conglomerate of solo games coming from Phase One, with the most loved boardgames in this subgenre.

Does it stop here? Nope. We have a Phase Three, and then a final wrap up. Now, I haven’t really started anything at this point, beside making up this general outline. I have a very, very vague idea of the inner mechanics of both Gloomhaven and Kingdom Death Monster. I don’t know how much they can be brought together in a useful and pragmatic way. But I know the more the task looks impossible, and the more it leaves space for something entirely new. So here we get to the philosophical point (a little more patience).

Phase Three would be taking the conglomerate that comes out of Phase One and Two, and hybridize it with a new set. This new set is the timegate. It is where we (I) (no one) will attempt the time warp.

While exploring all this stuff I found an old, small and generally unknown game. It’s called “Valkenburg Castle.” This game is the result of its own hybridization, but it targets exactly that “history that never was.” OD&D (Original D&D) was created by Dave Arneson from its wargaming roots. From some Grand Campaigns so broad in scope that it was necessary to model the single generals. These games would then be linked together so that different groups of players would participate and contribute to an enormous Big Picture. Because that was the ambition of those days. The golden age didn’t start with D&D, it DIED with it.

These roots were still visible in that OD&D:

And especially in the Blackmoor campaign that preceded it, and that is mostly lost now:

(this type of combat actually does appear in the form of optional rules to D&D, in the first published Blackmoor module)

We got all the the beautiful maps and tunnels of the Blackmoor dungeon, but sadly not much of the actual content like room descriptions. In more recent years it was made into updated sourcebooks, but it’s really just a remake that erases all that made the dungeon so distant from what we then got in the shape of RPGs.

Without even considering the level, what kind of party can face a THOUSAND of monsters, all preparing an ambush? It wasn’t much better even for the first level of the dungeon:

Your newly assembled party opens the door to the first room of the dungeon. What do they find? THIRTYTWO Kobolds. Or look at room 9D, FORTY Goblins! Will it take the rest of the evening to clear that room? It sounds more like the dungeon was meant to be stormed by a full army.

But the stuff that is most interesting is again the wargaming roots. The game space was an area meant to be conquered and fought over by players, the rules that would then be plugged into the OD&D by allowing characters at the high levels to build strongholds. But the game was never going back again to its Darkmoor roots. There were detailed rules to make roads, and even keep their maintenance as time passed:

Pre-Original D&D, in the form of Blackmoor was a full featured, extremely complex grognard wargame with a dungeon crawl embedded in its structure. With the release of D&D we got the dungeon part severely dumbed down, and the wargame layer completely removed. A turn of history. Here and there you can read hints about that original Blackmoor. It was more like a modern MMORPG, it was a game space, populated by multiple parties of players, all coordinated at a general level by the referee, or more than one referee. It was a GIANT thing. A simulation of a fantasy world. It was essentially an Eve-Online prototype in a fantasy form.

Here we have implied rules just in case you wanted to make an harem. See the asterisk? You can buy slaves either for pleasure or for labor. If male they can do both, if female it’s only for pleasure. But you see, there’s a distinction, because female slaves that wear white silk cost quite a bit more than those who wear red. And you can buy a single one, or get a discount if you order in bulk. Even then you need to be wary, because those precious white silk ladies come with a 50% failure to arrive. I suppose brigands. So I’m not so sure it’s a good deal, as the red silk clad ladies instead only take a 16% risk. Unless, I guess, you send an escort to make sure your purchase is secured.

All this stuff in a table. And through the 40+ years of RPGs I haven’t seen anything that compares to the intricacy of that system. These are “systemic” rules, they aren’t part of a linear story. They structure the way this virtual world operates, and players will be just travelers, deciding freely how to interact. The focus is moved outside, to the world, not a bubble of personal story.

I’m sure most people, if not simply everyone, would think that it was only good if RPGs found their own space and shrugged away those grognard roots. And that’s fine, but here we jump back to Valkenburg Castle. This mostly forgotten game was considered somewhat mediocre, yet when I found it I thought I had struck a whole new vein of greatness.

It’s an odd sort of dungeon crawler boardgame. It’s two players, one “good”, the other “evil”. You get to set up multiple parties, decide how to distribute you men, but considering that you can’t have more than 12 men in a single square, then choose what kind of armor they wear, because if they wear heavy armor they are more resistant, but move slower, and if they wear light armor they are squishy, but move faster. The combat is very simple, you roll a d6 and depending on a few factors you look on a table how many wounds or hits you delivered. For every hit, one kill. But despite this, there’s a level of intricacy below. Doors can be smashed open, chopped down, or lock-picked. If the lockpicking fails there’s a chance they are stuck permanently. There are some elaborate maneuver rules in combat, that consider flanking and wide open or closed spaces. You can hold a door open with one unit while another goes through it, sparing a movement point. It’s all interesting stuff because it’s all flavor and mechanical interaction you don’t expect to find. You’d expect something far more abstracted, streamlined. You an play a number of scenarios, or a campaign where those scenarios are linked together, tracking your progress from game to game. See how it takes a new shape? It’s just a small dungeon with five levels, some orcs, and a dragon at the bottom, but it starts to feel like a small world with all the options it offers. In the “designer’s notes” the author writes:

Now tell me, what kind of game makes its focus not the killing of the dragon, but in the transportation of the loot, that thanks to an encumbrance system will slow down the “good” player units, making them easier to reach by the orc reinforcements? And of course you NEED that gold, here, because in the campaign you use it to assemble new units to send in the dungeon. Successes and failures carry over from game to game.

In just a few pages of rules, some dungeon levels and an handful of ugly counters, there’s a game with an incredible depth and significant replayability. The idea of the campaign makes it “matter”, shaping up like a little contained world, even if you don’t get to see the locales outside the dungeon. I see this game as a symbol of a history that never was.

What is the difference between a boardgame like Kingdom Death Monster, and a PnP RPG? The absence of a master. My project is about removing the computer as a master. Imagine a game that offers “tools” for the player to use, and build a story. It would be about giving shape to that history that wasn’t. A bit like how Cultist Simulator uses cards to shape a story. A simulation without a simulation. Without any computer trickery moving behind the scene.

Here we arrive to the final layer. It comes at the end, but it was immediately part of the concept: The Binding of Isaac. My idea to wrap this thing together is that the first time you launch the game all you should have is a very linear, very simple story. An immediate, easy to reach goal. In the tradition of roguelikes, you’ll likely die a lot. Roguelikes are built on the concept that, even if with each character death you reset the whole thing, the “progress” is instead all focused on the player, as the real character. You learn by dying. Over and over. Learning new tricks and avoiding old traps. Every time you go a little deeper, make a little progress. But in the eventuality you win the game you’d have seen most it has to offer. The dungeon is more or less always the same. My idea was instead to rely on a “combo.” On one side the player learns, but on the other the game world grows too. It takes its shape piece by piece. Every small progress unlocks a new chunk, and that chunk joins the bigger game in a “systemic” way, so that from that point onward it will be available at all times. It opens up, offers alternative paths, new trajectories. With this party you’ll go that way, with this other party you might decide for a completely different journey. Or go back and forth. It’s the idea of a sandbox, opposed to a game with a linear flow. And here we get to the last idea.

While doing all this, reading PnP rulesets and all that stuff, I also spent some time having a look at the “gamebooks.” That stuff you’d consider completely obsolete these days, something you’d bet can ONLY be fueled by nostalgia and nothing else of worth. But I found some interesting stuff. I bought a few gamebooks when I was a kid, and no access to Dungeons & Dragons beside a couple of episodes of the animated series. But even at that time I thought those gamebooks were extremely disappointing. They were shallow and felt like poor power fantasy fanfiction. Besides a few volumes of Lone Wolf, I had another two series. That I’ve now looked up.

The first is a series titled “Fatemaster.” It doesn’t seem to be remembered too fondly nowadays (by the way, all the Lone Wolf books are online and available for free) but it’s interesting because it offered a little more in the way of an RPG. Instead of presenting a mostly linear path, it allowed a small amount of free exploration, and it even included a little hex-crawl! Along with the usual dungeon. You were meant to draw your maps while exploring that world.

Another I had is instead far more popular and probably the apex of the whole genre: Blood Sword. This was a series of five books, but they were much bigger in scope, and included dungeons with at least some weak tactical combat. If Lone Wolf is mostly built by 350 entries for every book, Blood Sword goes above 800. It was somewhat more serious and interesting to read, although it was meant to be played with other “players” and so you’d have to take turns reading aloud, and in the end I don’t remember the experience all that fondly because it gets tiring when your school friend drones on and on. Attention wanes and so goes the appreciation of the story. You wake up from stupor only when it’s time to fight again.

And finally we come to the one that gets the crown along with Blood Sword, and that brought new ideas: Fabled Lands. This was also a series. Can you see that, even here, I have no interest what so ever for one-shots? But this is truly generally considered the best the gamebooks had to offer along with Blood Sword. Sadly the series came out too late in the cycle, when the vein of gamebooks already started to dry. The Lone Wolf books came out, the main series of the first 20, between 1984 and 1993. Blood Sword was 1987-1988. Fabled Lands only started to appear in 1995 and it was an overly ambitious series with 12 big books planned. Only six were published, with the seventh Kickstarted and released just a year ago. Because we live in post-modernity when all time is contemporary. So why not gamebooks.

The Fabled Lands was a truly interesting series because it greatly expanded on the Fatemaster concept of an explorable “world”. But it didn’t stop there. It wasn’t just one adventure/quest turned non-linear and allowing free exploration. It instead CHAINED all the books together, non-linearly. You can start at any point, with any volume of those six that where released, and then travel back and forth BETWEEN BOOKS, exploring how you please. The “game” uses a clever system of keywords that you write down, so that every time you revisit an old location you skip some events that were meant to happen only once, or trigger new ones. (the Fabled Lands, with the exclusion of the seventh recent book, are also freely available, with a nifty Java app that tracks all progress for you)

I found online some diagrams for the Lone Wolf book. They all look pretty much like this:

What Lost Lands offered, and the concept I want to retrieve, is that instead of a linear path with a few branches, you got a “system.” It can be visualized like a “cloud”, (sadly I couldn’t find similar diagrams for Lost Lands). Every path is non-linear, or at least only linear in segments. But you find your own path through that system. You draw your lines, your trajectories. You build your story.

With this Grand Plan came more ideas: for example your character could get hopelessly lost and in danger in a dungeon, but you could create a brand new party and send it to the rescue. Or you could, if you wanted, send and suspend different parties out in the world in a static way, going back and forth. The game world would never reset, it would take its shape as it is randomly built. Shuffling the dungeons themselves on demand for replayability. (something like Adom, for example)

Now join all the blocks.

You take this Lost Lands cloud-world structure of systemic possibilities, but mixed with the inspiration I took from The Binding of Isaac. Instead of having this game-world all open the first time you boot the game, you’d have it slowly taking shape and expanding, through deaths and victories. Growing with the player.

It would have dungeon crawls when you go deep, and hex-crawl when you explore outside. You could go on your own, aimlessly, or get a quest for a reward. With straightforward and simple combat rules, but with some tactical wargame combat sprinkled over. Some depth of interaction as seen in the Valkenburg game.

All built through the explicit mechanics of a boardgame. No hidden computery stuff, and no game master. No behind the curtain stuff. Just a box of tools, a sandbox, to explore.

I’m jumping onto a different timeline, by going BACK to obsolete game books and those intense golden years that PRECEDED the origin of RPGs. Before everything was funneled into one path. This is the hidden history. It’s as if we only remember as far back as Doom and Ultima, as if nothing that came before is relevant now. Our histories have fake starting points, they start with us instead of before us. In the same (blind) way we might consider Tolkien as the origin of Fantasy.

With the Original D&D Arneson and Gygax gave shape to only one of the possible worlds. The one we live in. But the seeds that delivered it weren’t planted by them. They were planted BEFORE them. And they could have grown in much different ways, create different worlds. In at least one of them Trump is not the president (now you know who to blame).

Games are a way to explore retro-futures that didn’t happen, in the same way you can explore a what-if scenario in a WW2 wargame.

Summary:
Phase One: hybridize Four Against Darkness, D100 Dungeon and Rangers of Shadow Keep into one conglomerate.
Phase Two: hybridize what comes out of Phase One, with boardgame depth and flavor in Gloomhaven and Kingdom Death Monster.
Phase Three: hybridize what comes out of Phase Two with old-school fantasy board-wargames. With some tactical combat and also more focus on adventure and exploration.
Wrap it all in a super-structure: starts small, linear, simple, but expands through a stacking of plug-in modules into a systemic CLUSTERFUCK. (no Stadia or AIs needed)