Just having game classes is not enough! Let’s take the resource approach to system design, to properly distinguish and balance our classes. We’ll describe the design in terms of abstractions representing the game as an economic system, using a diverse selection: Dungeons and Dragons and Mario Kart, as case studies.
For RPGs, as well as some other genres, some key, distinct features that help draw in players and drive replayability are a rich metagame and a variety of game glasses. But merely having these game classes is not enough: we need to be able to properly balance them and to effectively distinguish them from one another.
So, how can we do this? For example, we could use the resource approach to system design, described in Game Mechanics: Advanced Game Design by Ernest Adams and Joris Dormans. It describes design in terms of abstractions that represent the game as an economic system. (You can read more about this in the book itself or on Machinations.io.)
This article will cover the basics of this approach. We’l give practical examples of applying it in class design for games across very different genres: from Dungeons & Dragons 3.5 to racing games, like Mario Kart.
The basics of game economy
First of all, let’s briefly analyze the composition of the game economy. We’ll describe it in simple terms.
An economy is a system of resources and their interrelations. Each resource can be produced, exchanged, and consumed. A resource enters the system according to some rules, moves between its nodes, and exits the system.
For example, in StarCraft, workers mine minerals (entering the system), and buy buildings with these minerals (exchanging and taking the minerals out of the system).
Machinations diagrams use similar designations for economic elements in the form of triangles and circles
Direct links between resources
There can be links between resources; these links can be direct and indirect. A direct link is a resource exchange: this is when a resource goes from one pool to another, or when exchanging one resource for another.
Let’s take Starcraft’s minerals as an example again. Mineral deposits are a form of pool, with one crystal containing 900–1800 minerals. While they’re securely encased within the crystal, players do not have a mechanism to spend them.
Then, a worker mines 5 units of minerals per mining cycle. While the worker is doing his thing, in fact, he himself is now acting as pool of minerals; the pool has changed. The miner can take 5 minerals from a deposit, but unlike the deposits themselves, the miner can be killed, thus destroying the resource. And again, at this stage, the player still cannot spend these minerals.
Finally, the worker brings 5 minerals back to the base, and the minerals are transferred to the player’s account. This is the third form of pool in the chain: now the minerals are completely under the player’s control, and they can be spent as desired.
Reckoning with indirect links between resources
An indirect link is when a resource, depending on its quantity, somehow affects another, but nonetheless, stays unspent, (otherwise it would be a direct exchange).
To illustrate what this looks like in practice: besides the aforementioned minerals, the workers themselves could also be considered as a resource available to the player: the player does not buy anything directly with the workers, but the number of workers directly impacts how much resources can flow into the player’s account per cycle.
Resources with such an “indirect” connection are not spent on the exchange, but do affect other connections and resources.
In our example, workers are indirectly related to minerals — they change the rate of mining. Meanwhile, minerals are directly linked to workers, as you can directly exchange minerals for additional workers.
You can see that the connections of the minerals form a loop: the more minerals players can mine, the faster they can mine them in the future (by buying workers), and this is called a positive feedback loop.
Anything can be a resource!
The main trick that makes such gameplay work is that anything can be represented as a resource: not only measurable, exchangeable things, but also abstract elements.
These can be varied: mana is a measurable resource; character level is measurable, though usually not spendable; player reputation, measurable or not, depending on the game; a tactical advantage on the field is unmeasurable.
Even player skill can be a resource: this doesn’t usually change during the game, but it has indirect connections with many elements of the economy.
As an example: chess can be thought of as a game with two resources: the number of pieces and tactical advantages. During the game, players exchange pieces in order to gain a tactical advantage on the field. The game ends when a player reaches “100 points” worth of tactical advantage — checkmate. The more experienced a player is, the more profitable their exchange rate of pieces.
We provide a complex illustration of this mechanism, as each piece has its own “exchange rate”, and the opponent’s skill also affects this exchange rate. An opponent can take away this advantage. But such a pattern is sufficient to showcase the idea.
That’s enough background about resources and the types of links we encounter in game design. So, with this all in mind, ultimately, we need to define a central resource within the system — the resource to which everything ultimately reduces. From there, we’ll need to see how all other resources affect it: where the direct exchanges happen, and where the indirect connections lie.
Let’s illustrate this with some practical examples.
Class design in RPGs
In any game there is a certain central resource. This is a resource to which all the rest are reduced. In chess it’s tactical advantage; in Starcraft, minerals; in combat games, character strength; in card games, mana costs.
Different classes/weapons/game races/cards have different tools for interacting with resources and different features that modify them. But in the end, everything is recalculated into one central resource in the balance sheet. To apply a resource approach to class design, you must define this resource and understand how other game resources interact with it.
For the sake of simplicity, let’s consider a combat-oriented RPG as an example. Dungeons & Dragons is sometimes criticized for being an RPG about fighting and dice-rolling, and not role-playing, so it is fit for our purposes. Let’s take the old D&D 3.5 rules as an example.
As with any combat game, the central resource in D&D is character strength, which results from the survival rate times DPS (Damage per Second).
Character power is calculated according to this diagram
Any character can be decomposed to these two parameters: survival rate and DPS. We can change the parameters themselves, and thus, get a certain number of different characters.
Tanks naturally have low DPS and high survival rates and damage dealers have the opposite characteristics. One could also envision a sort of average character with both characteristics at an average level. Or two other characters with both characteristics at a low and high level. So, five characters, two of which are not balanced. It will be pretty difficult to imagine any interesting gameplay in this scenario.
What can we do to make these characters come alive and create some magical gameplay moments? If we’re talking about D&D, then, given the expansions, there are dozens of character classes. This pattern needs to be enriched with new resources and connections.
Like this:
Example №1
Here, we’ve added one indirect link, thus creating a new game class. The barbarian hides behind this pattern: a ferocious warrior who, by losing HP or defenсe, gains attack bonuses.
Here and elsewhere, it should be noted that the game design of a particular RPG will determine exactly how these links will work. In D&D, players who pick barbarians are clearly trading survival rates for attack and the ability to enter a rage mode, thus spending an armor.
But this could be designed differently. In Diablo, for instance, barbarians get a bonus after they lose HP. These are two different types of barbarians, so indirect survival rate-DPS link works differently for them. The survival rate itself is a complex resource that consists of HP and armor (and dodging, and other things). You can spend different survival rate components, but the structure of the barbarian class does not change. In the abstract resource pattern, these are the same direct and indirect links.
Let’s move on.
Example №2
If necessary, you can introduce new resources into the pattern. Those who are familiar with D&D might have already guessed the next class by the name of the new resource in the pattern above. This is the wizard. In D&D, wizards have a limited number of spell casts per day — that is, if they’ve used all their spell casts for that day, their DPS is almost zero. This is a direct exchange.
Again, the pattern is not perfectly accurate and can be modified. The wizard’s DPS in D&D will also depend on the spell level: the higher the level, the bigger the DPS in this round. That is, each level of spells is a separate resource with its own exchange rate for a spell per DPS point.
If we start nerding out, we can say that wizards spend money on some spells in the form of material components: the eye of a newt, the feather of a raven, and all that. This all creates a space for designing alternative classes and prestige classes. Spontaneous wizards who aren’t directly tied to components, wizards who can trade one spell level for another, and so on.
Now, let’s consider one more class.
Example №3
Again, some very familiar numbers. This is the rogue and its derived classes. In D&D, the rogue deals additional damage to an enemy if he attacks with an ally. Let’s call this resource a tactical advantage. It has two states, 1 or 0: either it exists or it doesn’t. It also has an indirect connection with DPS. Unlike spell slots, tactical advantage is not spent on an attack.
To make it more interesting, there is a level dependency in the pattern. The connection of character level with DPS and survival rate is a common feature of all classes in the D&D system (and most games), in general: the higher the level, the more HP characters possess and the harder they hit.
In the rogue’s case, the level directly affects the DPS modifier of a bonus damage, although this is also true for the previous examples: the wizard gains more spell slots at higher levels, the barbarian’s rage improves and the number of rages per day grows with the level increase.
Wrapping up our discussion of RPG classes
The RPG genre is perhaps the most illustrative example to capture the essence of this approach. The task of creating classes in an RPG is relatively simple at a basic level: it’s all about archetypes, (and popular culture has done a lot of the heavy lifting for us here already).
However, you’ll still need to work out the design of a specific class. Resource patterns don’t provide an answer on how specific features of a class should work; they only describe a general pattern at a top level.
The task becomes much more interesting when there are no established archetypes, or you aren’t familiar with them. So let’s explore that a bit next.
Classes design for racing
Racing is a much more exciting genre for us to tackle. Racing games certainly have their own classes, which, to some extent, are already well established: front-wheel, rear-wheel, and all-wheel drive cars. In addition, cars with high acceleration, or high top speed, or outstanding steering response.
But these subtleties can be difficult to look at with a focused eye if you haven’t spent hundreds of hours behind a real (or virtual) steering wheel. And second, the racing genre itself can be unusual. Take Mario Kart, for example, where, unlike a game like Need for Speed, you don’t want to burden the player with different aspects of type of drive and track grip characteristics.
Defining the central resource
The central resource for most races is the same: track time. Here, the main objective is to be first — to be faster than the rest. In turn, the elements of the track (and other racers) are in place to slow the player down: driving off the track slows you down, just like heavy turns, or when other cars hit you.
With this in mind, the car class allows you to save time, (regardless of the mechanics your racing game is based on and how well you are familiar with cars in general).
The peculiarity of this genre is that all the key links here are indirect — car characteristics only affect track time, but cannot be exchanged for it. This may change if a car is damaged, but this is a separate relationship between a characteristic and an event.
Car class creation
As discussed earlier, base classes are created by making direct changes to the main parameters of a “character” (in this case a car). We just choose the one with the higher and get a comfortably steerable car that shifts well around corners, a fast car speeding ahead on straight sections, and a car with great cross-country characteristics — it can cut corners off-road, and we could even create special track segments with this class in mind.
Due to the fact that we have various basic parameters, we can create more viable combinations. Our cars can have two high parameters and one low. (Off-road time, straight track time, and cornering time). In any case, we’re still talking about a finite number of options (and not many of them).
Let’s take Mario Kart as an example, which has several additional gameplay elements that we can also tie to time.
Drifting
Every car in Mario Kart can drift around corners. If the car keeps drifting long enough, then it receives an acceleration boost.
Drifting can have different effects depending on how you use it. One of these is the acceleration rate following the drift — this is the sum of the acceleration duration after the drift, or the force of this acceleration itself. As a result, it affects the straight track time. For some cars in the game, drifting can also affect the steering response: drifting makes it easier to turn corners, and the acceleration after passing the corners is not as strong or long lasting.
Springboards and nitro panels
Mario Kart tracks also have special elements that can boost a car. Taking advantage of these accelerates when driving on special panels or ramps, somewhat similar to drifting.
Despite the fact that this effect is similar to the acceleration after drifting (and specifically in Mario Kart this is the same characteristic), in the pattern, we can denote the interaction with objects as a basic resource that is directly related to time.
Weapons in Mario Kart
In Mario Kart, players can use weapons to slow down other racers. These mechanics alone create two basic classes: a car with strong weapons and a car resistant to weapons. The first one slows racers down, the second one receives less damage from hits.
Weapon power is an interesting parameter: it doesn’t save player time, it slows down other racers. That is, it lengthens the race. In theory, the weapon power shouldn’t affect the track time, only other racers speed. And the track time itself is affected by the player’s speed against other racers’ speed. But such detail is beyond the scope of this article. Nevertheless, for clarity, let’s keep this resource in the example — after all, it found the way into Rock’n’Roll Racing.
Wrapping up our discussion of racing classes
In the final version of the racing pattern, 10 basic car classes can be found. By basic, we mean where one car has a high parameter and the rest have average (or all of them are average). If you choose two leading parameters, then the number of combinations increases to dozens. Moreover, each characteristic has a range, we don’t have to rank them in the primitive categories of “many” and “few”.
In order to represent classes in a racing game, no expertise in cars, or even racing games is needed. This is just the result of decomposing the game into abstract resources, characteristics, and tracking the links between them.
(This approach works for RPGs, racing games, and other games as long as you reach a high level of abstraction.)
A final word
Of course, these approaches will not help you fully develop a game. Each link needs to be designed and balanced in detail, and the final form of the game will depend on this level of care. But with these methodologies in mind, you can solve the creativity-blocking “blank-sheet-of-paper” problem or decompose reference games to figure out the principles they operate on.
Patterns like this might show you that you don’t have enough basic elements in your game to build a web of links to provide the variety you need, so then you’ll have to create new features to fill in the gaps. And hey, perhaps that’s how the nitro panels and drifting appeared in Mario Kart in the first place! Who knows?
