I did a podcast this past Sunday – and I’ll provide a link once it’s online – where I met with a friend I haven’t seen in several years. His schtick is that he invites people to decide the content for his podcast, without his input and without his knowledge, such that he doesn’t know what he’ll be talking about until the day of the recording. It’s quite entertaining and, like any artist, his work has been steadily improving since he started some 40 episodes ago. Of course, given our background together – we met as gaming buddies just after I graduated high school – and given my lack of actual roleplaying over the years, I had to talk D&D. Honestly, I was thankful for the opportunity to pick his brain about some things and to, hopefully, get him going on a few of these topics; especially since it seems that, whenever I try to engage people on the subject, their eyes just glaze over. And I’m not talking about non-gamers: I specifically mean that avid, fanatic and life-long D&D players just don’t seem to care about critically evaluating their games. It baffles me to no end.

One of the things I mentioned on the podcast, as an example of critical game design, was how I’ve adopted the XP rules from the Tao of D&D. To me, it’s a simple rule with wide-ranging implications in its application; it’s a basic reward system that the players can embrace as they see fit. Yes, it encourages players to murder the shit out of everyone they meet, but common sense – and a rational, dynamic and dangerous world – will keep them in line by balancing their desire for advancement against the risk of failure (i.e. death).

This is the foundation of a good D&D game: a fair and impartial risk and reward system.

But where do we go from there?

OD&D and AD&D have distinct XP tables for each class; a fighter advances slower than a cleric who advances slower than a thief. It makes sense when you consider each class’ abilities in terms of their usefulness at accomplishing the primary goal of the game: to kill things and take its stuff. Of course a fighter will advance slower than a thief; the fighter is better suited to dish out more damage and to earn more XP. (This reasoning fails if you have static XP awards, which the game has always had, which is why, in part, I like Alexis’ rule so much better. You can see this play out in the development of the different editions, starting with 3rd, where the XP tables were consolidated into a single advancement chart, to put each class on a even playing field. I reject this design standard simply on the basis that professions, in real life, are of varying degrees of difficulty. A pharmacy technician knows a lot more than a food service technician; it stands to reason that the pharmacy tech will require more experience to advance.)

Interestingly, AD&D gave the DM the ability to address this sort of thing. The DM’s Guide (pg.32) has a section for creating classes. It’s a brilliantly misguided and underused section, if only because the designers had no fucking clue what they were doing. But the core concept is solid: you have a base experience chart which is modified by a variable, unique to each class. The variable is determined by assigning skills to the class and adding a modifier based on that skill’s utility or power. Now, where the AD&D designers went wrong, is they didn’t design their base classes by this method – they tell us as much in the DM’s Guide. Also, the modifiers they provide don’t make sense and they don’t even list the full range of powers/skills.

(Yes, I know that Skills and Powers was a thing. I also know that it was crap, for basically the same reasons I list above, but mainly because the designers didn’t put in the proper effort to ensure that their system made sense. We can certainly look to it for ideas, but so far, I haven’t found much of use.)

So let’s fix it.

We start with the base experience chart.

Base XP Chart

The final formula is: [ (base XP) * 125 * (class modifier) ] – rounded to the nearest multiple of 250. The 125 is a static modifier; you can easily replace it with any number that suits your purposes. The rounding is something I do because I want the XP chart to be some sort of even number; again, use a different multiple or remove it altogether, whatever works.

To determine the class modifier, we need to break our classes down into skills and powers. Let’s start with the fighter. The core class from AD&D has the following skills:

  • d10 hit points per level (up to 9th)
  • +3 hit points per level (after 9th)
  • Excellent THAC0 progression (1 point per level)
  • Armor proficiency (all types)
  • Shield proficiency
  • 4 weapon proficiencies (at 1st level)
  • +6 weapon proficiencies (by 20th level)
  • -2 non-proficiency penalty (best of all classes)
  • Weapon specialization
  • Multiple attacks
  • Excellent saving throw progression (fastest and best value at 20th level)

There are other skills I would give to fighters, but for our purposes, this list will suffice.

It took some time to figure out the numbers. I started with the assumption that a fighter’s THAC0 progression is worth 3 points. I then based the other modifiers on their relationship to THAC0. In other words, proficiency in all shields, starting at 1st level, affords fighters the opportunity to improve their defense, making it easier to survive fights and earn more experience. However, it’s a defensive skill, so it shouldn’t be worth as much as an excellent THAC0. It’s also, at best, a 2-point modifier to AC, which is nothing to sneeze at but not quite as significant as heavy armor proficiency. So let’s give shields a 0.5 modifier. Following a similar line of reasoning, the modifiers we might assign are:

  • d10 hit points per level (up to 9th) (+3)
  • +3 hit points per level (after 9th) (+0.5)
  • Excellent THAC0 progression (+3)
  • Armor proficiency (all types) (+1)
  • Shield proficiency (+0.5)
  • 4 weapon proficiencies (+0.4)
  • +6 weapon proficiencies (+0.6)
  • -2 non-proficiency penalty (+0.25)
  • Weapon specialization (+0.5)
  • Multiple attacks (+1.5)
  • Excellent saving throw progression (+2.5)

Total modifier: 13.75. Final XP chart:

Sample Fighter XP Chart

We can find ways to make the modifiers more fine-tuned (and, therefore, more fair). For example, if we assume that each 1-point improvement to THAC0 is worth 1/32 of a point (as an XP modifier), and keep a running (cumulative) total over the character’s progression, we get a modifier of 3.28125. This methodology can be applied to any numerical improvement we can track, like saving throws or hit points, or even skill points (if we added such a system, which I did, and which gives me a final XP modifier, for the fighter, of 16.1796875.)

Now, I am the first to admit that this level of detail is a bit… well, insane. The final result is all the players see: a list of class skills and an XP chart. The difference between the classes is significant – it’ll affect a player’s decision to play one class over another – but it’s not so great as to immediately encourage or discourage any one class. Classes with quick progression are also weaker than the other classes.

More than that, however, this approach benefits the game by giving the DM options for expanding the world. I’m currently toying with how to use this methodology to create monster classes; combined with a standard for tracking monster XP, I’ll have random encounters where the players might face a veteran chimera; or a juvenile one, with fewer levels or immature abilities. And all of this will be done at random, such that I won’t know, until I need to know, what’s around the corner. Just like the players. Just like in the real world.


One thought on “Foundation

Add yours

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Blog at

Up ↑

%d bloggers like this: