What is Game Depth and How to Evaluate It

Depth is a positive quality attributed to games that are intellectually stimulating or complex. In this post, I aim to define depth in a way that is concrete and clear as well as lay out why depth is a helpful and practical target to aim for in game design & development.

In his GDC talk, Raph Koster argues that fun in games boils down to 2 simple mechanisms:

1. Succeeding and failing at something inconsistently
2. Your rate of success at the thing growing over time.

This can be summarized as Games are fun when you’re building a skill and learning.

We can further extrapolate this by saying that games are not fun when you’re always winning at everything, because they’re boring or routine. And games are not fun when you are losing at everything, because they’re frustrating.

Games are fun when you are winning only some of the time at some of the things. This is frequently summed up as Flow Theory, which is already well-known in game design. Depth is our tool for practically achieving this.

What is depth in games?

In game design, depth can be summarized as the effective complexity of a game. It’s easy to design a game with a massive number of working elements and interactions between them, but frequently not all of those elements or interactions are useful to players, or even mechanically distinct from one another.

The effective complexity is the portion of this behemoth that actually matters in the real game. In other words, how much does the player actually have to think about.

With good design sense, it’s possible to build games that have a much higher effective complexity with a lot fewer elements and interactions.

This post is a bit long, so feel free to use the table of contents below to skip to the parts that interest you 👇

Depth type 1: Possibility space

To get to depth, we need to start with Possibility Space.

Possibility space is the range of everything that can happen within a game. More precisely, Possibility Space is the sum of every single possible Game State.

A Game State is a snapshot of everything that is currently happening in a game. In a video game, this would be all the data present on a single frame or tick of gameplay.

When you make a save game (especially if it’s a save state), you are saving a game state to be reloaded later.

Together, all of these game states create Possibility Space, which can also be thought of as the total complexity of the game.

To give an example: Imagine a turn-based RPG. You have a single character with a set amount of hit points, versus a single enemy with a set amount of hit points.

If these are the only factors in the game, then the possibility space is all of the possible HP values that both the character and enemy can mutually have during a given battle, as well as whose turn it currently is.

If you introduce more types of attacks, more stats other than HP, more party members for the player and enemy side, and more general options and states, that will increase the raw possibility space.

Simply adding more things to a game will increase its possibility space, but even more effective is considering the multiplicative effects of the things you add. Adding a single thing might create a few additional states, but adding a single thing that can interact with a number of other things can create a very large number of states.

In the prior example, adding attacks and other options might give you a wider range of possible HP values within a battle, but adding multiple participants can exponentiate the range of possible interactions that take place during a battle.

Depth type 2: Absolute depth

After Possibility Space is Absolute Depth, the range of differentiation between different game states. A game might superficially have a lot of different elements, but many of those elements might be uniform, or the differences between them might not matter.

If you have 3 different enemies, all with the same move set, then you have the same enemy with 3 skins.

If you can walk around your enemy in 3D space, but the only factor that matters is distance, then you have a 1D game.

Creating differentiation is about breaking symmetry. Elements should have uneven relations to one another, and disproportionate numbers of relationships in general.

In our RPG example, you might add a number of different elements to your RPG game, but a lot of them might actually be the same thing. You might have 5 different attacks, but they all ultimately do nothing but output damage.

You might have 20 different enemies, but they might all just vary in how much health they have and damage they do. To create differentiation between states, you need to have a difference of proportions and situations.

There needs to be a reason to pick one option in one situation, and another option in another. Many RPGs accomplish this through type weaknesses or status effects.

For example: Pokemon accomplishes this by limiting how many times you can use a move, and by varying the type, accuracy, power, psychical/special attribute, and effect of each move individually, with very little repetition.

Pokemon also has a complicated type of weakness chart that doesn’t have a lot of symmetry or repetition.

Another example: Zeboyd Games’ line of RPGs makes turn count matter by having enemies grow in power every turn.

Their game Cosmic Star Heroine creates unique situations across turns by having you expend your moves when you use them, requiring you to defend to replenish them.

Then they have a system they call “Hyper Points” that will double your damage every few turns. Getting your super effective attacks to line up with when your Hyper Points are full and that character has been buffed is a difficult logistical problem that helps make situations vary over the course of a battle, meaning you’re adapting to what the enemy does and the current state of your team.

Depth type 3: Relevant depth

And after Absolute Depth we arrive at Relevant Depth, the range of distinct possibilities that actually matter to players. Relevant depth will grow and shrink relative to the player base and the individual.

Relevant depth is how much of the game players know about, how much they are capable of interacting with, and how much of the game is balanced to be worth their time.

Relevant depth is how much of the game’s complexity you can get players to actually engage with.

If you fail to teach players, or if some skills are too hard to learn, then a large portion of the player base may never interact with many mechanics.

In addition, if you balance the game poorly, then players will decide some mechanics aren’t worth interacting with.

Ironically, adding more elements to a game can harm the balance, reducing the relevant depth of the game. As a player base ages, they will expose more of the game’s depth, moving more of it into their relevant sphere.

In Pokemon, there are a massive number of possible Pokemon, moves, abilities, and so on that can be combined to make a Pokemon team.

This means there’s a huge number of things that can happen within a given Pokemon battle. However, these Pokemon and moves are not created equally.

Some Pokemon are stronger than others, or more accurately, they’re more useful than others because weak Pokemon are sometimes still useful for winning.

This is represented through the community’s tiering system that separates Pokemon into tiers based on how often they’re used in

• Competitive play
• Ubers
• Over Used (OU)
• Under Used (UU)
• Never Used(NU)

For a competitive game, the goal of the game designer is usually to try to make sure as many game elements fall into Over Used as possible.

In a non-competitive game, there is more leeway, as players will be free to pick underpowered favorites instead of feeling compelled to keep up with their peers, but good balance is still helpful for encouraging players to make thoughtful decisions and to use as much of the possibility space as possible.

Balance can be the macro level of character/weapon/loadout picks, and the micro level of which options you pick during play.

A character having poor microbalance can make them simpler to play, which can help out beginners.

Rather than trying to make all options equally useful in every scenario, it’s better to try to make options have different proportions of usefulness relative to situations and try to ensure that no option is completely useless.

Depth is whatever is left over after passing through these 3 filters. So creating a deep game is less about making as complicated a game as possible so much as being efficient about what you include in your game.

Adding more elements to your game, giving them more nuance, and creating more interactions between elements is the way to increase the possibility space, but you need to be careful that each element is differentiated from the others, and that they are all balanced such that they are useful at least some of the time.

How to evaluate a game element’s depth

To help make it more obvious what creates depth, I have 4 rule-of-thumb criteria for whether or not a game element is deep.

1. Does this element have its own niche?
2. Does this element have a variety of uses?
3. Does this element produce varied outputs relative to varied inputs?
4. Does this element have synergy or interaction with other elements?

Criteria 1: Does this element its own niche?

Giving every element a niche is a matter of making sure that no two elements are accomplishing practically the same thing. A game might have 20 guns, and 15 of them might be some variation of assault rifles.

This is redundancy.

To avoid redundancy, ask yourself are the player is making different choices relative to the situation? Is there a reason to pick one thing over another?

According to Shigeru Miyamoto:

“A good idea is something that does not solve just one single problem, but rather can solve multiple problems at once.”

Criteria 2: Does this element have a variety of uses?

Allowing elements to serve multiple roles helps both in diversifying situations and creates more possible interactions between different elements, expanding the possibility space of the game.

But simultaneously, if an element functions in every role, then nothing else has a niche anymore.

Criteria 3: Does this element produce varied outputs relative to varied inputs?

Nuance is the range of possible outputs that a mechanic or element can produce. The inputs going into a mechanic can include the player’s button presses, their proximity to something else, their timing, their inventory state, or any number of other possible variables. By allowing the output of a mechanic to be varied this way, you can make the mechanic feel different every time the player uses it, and it gives the player something to master over time.

Mechanics can have direct interaction with other mechanics, and they can also have synergy. A number of games have combos, where one mechanic naturally leads into another for a greater combined effect than either individually.

RTS games let you mix army units together, so you can make a rock-paper army that will beat a pure scissors or rock army, and narrowly lose to a pure-paper army.

Super Mario lets you jump higher if you’re running. These types of interactions and synergies help make situations more varied and interesting.

For example: The game Getting Over It with Bennett Foddy only has one mechanic – Controlling the hammer attached to your pot by using the mouse.

Since it’s the only mechanic in the game, it automatically has its own niche, but it has no other mechanics to interact with, only the elements composing the level.

Despite this, the hammer is useful for a variety of purposes:

• You can pull yourself up a ledge.
• You can carefully position yourself using the head of the hammer.
• You can pogo off the hammer to ascend.
• You can pull yourself along a slanted surface.
• You can push off of walls.
• You can push a few moveable objects in the game.

However, Getting Over It is real victory is in the sheer amount of nuance it brings to handling the hammer.

You can fine-tune your position with an incredible amount of precision, and your character will rotate and fly with velocity based on physics. You’ll slide off of objects based on your angle of approach and in what direction you apply force.

There’s a massive number of possible and differentiated game states depending on how exactly you wield the hammer.

Other examples of this include:

• Mario’s jump is based on how long you hold the button down.
• Nero’s Red Queen in DMC4 revving is based on pressing and holding the rev button in a rhythm.

Many fighting game characters have different moves for pressing (attack), holding (charged attack), and releasing (puppet character attack) buttons. Multiple button and stick inputs can be combined together to create even more dynamic results. Buttons can act as modifiers for other buttons.

• Tilts and smashes in Smash Bros are based on the synchronicity of your button press with the stick input, and how far the stick is tilted over what time interval.
• Gestural inputs of multiple directions in sequence are the basis of fighting game moves.

Tying inputs to outputs that are modulated over a range is especially effective for creating depth.

• Again, Mario’s variable height jump is a classic example of this – the analog range of time that you hold the button down is converted into the analog range of jump height.

In many games, the range of speed you mash buttons at is converted into a range of possible output, such as speed escaping from stun, or maximizing a bonus.

• In Tony Hawk, you balance yourself by attempting to keep the reticule in the center of the line as it veers from right to left.

Matching analog input to analog output is a powerful strategy for creating state space. Matching discretely differentiated inputs to discretely differentiated outputs is similarly effective.

Criteria 4: Does this element have synergy or interaction with other elements?

The fourth criteria is about allowing elements to interact in order to create combined states they wouldn’t create alone.

The designers of Breath of the Wild referred to their style of design for the game as “multiplicative”. This is a good term for it.

Supposing that every element can uniquely interact with every other element, for every element you add to a game the total number of interactions grows. This can look a lot like a Punnett Square, mapping all the possible combinations.

With 2 elements, there’s 4 resulting interactions.

With 3 elements, you get 9.

And so on…

However you might notice that this includes elements interacting with themselves where element 1 crosses on the punnett square with element 1, element 2 with element 2, and so on.

Another thing you might notice is that this is assuming that element 2 interacting with element 3 is different from element 3 interacting with element 2.

In most games, this isn’t true, there isn’t a directionality to influence from one element onto another, and elements tend not to interact with themselves.

When you take these rules into account, then the Punnett Square is reduced to only one half, and none of the diagonal row where elements cross over themselves.

So a square with 2 elements only has 1 interaction, not 4.

A square with 3 elements has 3 interactions, not 9.

It’s about the number of combinations, ignoring permutations.

However the number of combinations still grows at a compounding rate as you introduce more elements.

With 4 elements, you have 6 combinations.

5 makes 10

8 makes 28

10 makes 43:

20 makes 189:

Of course, you don’t have to limit yourself to this. If you can build ways for elements to affect each other directionally, where it’s different based on which one affects which, you’re creating a larger state space.

If you allow multiple instances of the same element to interact with itself, then increase the range even more. And then on top of that, if you build every element with respect to the third criteria, AND have the particular modulation of each element reflected when those elements interact with other elements, then you have an explosion in state-space.

These dynamics can also be represented with a node-graph.

Elements (nodes) that can interact with each other are connected by edges, with the directionality of the edge indicating which one has an effect on which, bidirectional indicating they can affect each other.

This creates a clear goal, create elements that have as many connections as possible. Every cell on the Punnett Square starts out null, and is activated when there is an edge connecting it in the node-graph.

If it’s a one-way interaction or a symmetrical interaction (like mario collecting a powerup), only the cell on one side gets activated. If it’s a bi-directional interaction (like mario either stomping an enemy, or getting hit by an enemy), then the cells on both sides get activated.

This can help make tangible exactly how much possibility space there is in a game, in a way that’s not too complicated to implement.

There are more complex types of interaction, such as chains of objects having effects on each other (like Mario hitting a block, bouncing something on top of the block), but that’s a bit harder to represent in this format.

This also makes clear why it can be dangerous to segregate a game into different modes of gameplay, like with minigames.

By doing this, it creates localized ghettos of elements that have connections with each other, but not any elements outside that particular mode. Reusing elements between different modes alleviates this problem.

Another shortcoming of this model is fairly representing things like loadouts. In the abstract unabridged graph, there may be many possible interactions, but loadouts require to to slim those down to only a few interactions, but when a loadout is selected, the graph gets a lot smaller.

This does not mean loadouts are inherently bad, because there’s other considerations like balance and differentiation that are also important to depth, where this article is focusing purely on state-space.

If everyone has access to everything at all times, then much of that might be redundant, or irrelevant to play, resulting in a samey game experience where only a few options are chosen, so only a few interactions are shown off, even if vastly more are possible overall.

Card games have to contend with this type of problem and do their best to encourage variety when players can assemble a deck with practically any card available, but imagine how much worse it would be if you didn’t have to assemble a deck, and could simply play any card you wanted at any time.

For that matter, imagine how impossible a game like that would be for a human to play.

Additionally, not everything neatly fits this model. Some games don’t have discrete elements that interact, and have a lot of ways the same element can interact with itself such as in Go or Reversi.

Here’s a graph of the super effective interactions in Pokemon:

Cultivating possibility space

Depth starts at possibility space, the remaining filters just tell us what parts of possibility space are worth keeping around. There are a number of approaches to creating possibility space, but 3 basic building blocks are

1. Game elements
2. Nuance
3. Interactions

1. Game Elements

It’s one of the broadest terms possible for things in your game, characters, enemies, attacks, weapons, moves, items, cards, etc.

Creating new game elements creates new possibilities for how they can be arranged, where and when they can be chosen, and so on. If your game has more game elements, it gains more possibility space, which can potentially create more depth.

2. Nuance

This is achieved by taking ranges of input values and creating ranges of output values. Nuance is destroyed by taking ranges of input values and compressing them into a single output (such as snap-to-point mechanics).

For example: The hammer in Getting Over It With Bennett Foddy is the epitome of nuance because it takes in the values of

• The mouse’s position, velocity, and the angle of velocity
• The hammer’s current point relative to the environment
• The man in the cauldron then outputs that into momentum for the hammer
• The man in the cauldron with a bit of angular momentum thrown in

3. Interactions

Interactions are how game elements can affect other game elements.

• Running can carry its momentum into a jump
• One enemy can buff its allies
• Multiple moves can set up a combo

Interactions can be nuanced the same way mechanics can, having weaker or stronger effects based on distance, level, angle, etc.

A game doesn’t have to have all of these necessarily, you can create a lot of dynamic situations, and depth, because you have a lot of content, or because the little content you have is extremely nuanced and has a ton of interactions.

These are tools that can be leveraged, and ideally, you understand what you’re leveraging and why. Any approach is valid as long as it ends up with a lot of space left for the player to explore. As long as it pushes them to make interesting choices, where the answer isn’t the same every time.

The practicals

In our attempts to make a fun game, how does depth practically help us?

A deep game is one with a lot of different things to master.

In a deep game, a player might master a more basic skill, but there will always be more to learn.

If learning, if inconsistent success, is fun, then a deep game keeps people occupied for as long as possible.

If a player gets frustrated with one thing, a deep game offers them something else to work on, and if nothing else, makes their attempts at learning varied enough that they never repeat the same thing twice.

From a development perspective, targeting depth is also a matter of practicality. It’s easier to develop fewer game elements than a massive number.

If you can get those elements to all play off of each other multiplicatively, and you can give each element a great deal of nuance, then you can get a lot more done in a lot less development time.

While you’re actually working on a game, you might have a base set of verbs for the player character that might theoretically have a lot of depth, but remember that the level design and enemy design are what’s going to actually bring that depth out.

Be careful not to focus too hard on the player’s options at the expense of the challenges you present to them.

Most games are developed at least somewhat iteratively. As you iterate your game, you’re going to see that some approaches to creating depth don’t actually pan out as you intended.

As you introduce more elements, you might find that the depth of the game shifts as new elements or systems are introduced, which changes the relative distinction and importance of pre-existing systems.

Strictly speaking, to an end player, it doesn’t matter how much gets left on the cutting room floor due to redundancy or poor balance, as long as the final game is still deep.

As we develop, we want to avoid situations where some of the play space ends up unused, as that represents wasted development time.

Elden Ring might have 300 weapons and a player might only use 5 of them, but as long as those 5 are enjoyable or deep in their own right, that’s a success. However if the whole community agrees only 5 weapons are worth using in the whole game, that’s an area that can be improved upon.

A game that is complex, but not all of that complexity gets funneled into depth is inelegant. Elegance is when everything has a purpose, and nothing is wasted.

Elegant games are easier to learn and inelegant games frequently overwhelm players with decision paralysis. As the old adage says

“Simple to learn, difficult to master.”

Final thoughts…

The biggest lesson from all of this is that we should be targeting choices for the player, ones that vary depending on the situation.

Big choices, little choices, choices as small as how long you hold a button. If anything, with depth, the smaller the choice, the more depth it creates.

The rest is just iteration and targeting what type of game you want to build. Any type of game can be deep, in any genre. Depth is a guiding principle of design holism and a set of tools for you to enrich everything you create.