This article is about match-based single-player games, such as roguelikes, Civilization or Tetris. Specifically, we'll take a close look at a very typical design problem of those games. The underlying analyses can be applied to other kinds of games as well, but for now we'll focus on such exquisite titles as Dead Cells, The Binding of Isaac or FTL.

Why go match-based?

First let's establish why anyone would want to design their single-player game to follow a match-based structure to begin with. For multiplayer games, the huge logistical challenge of getting multiple people to the same (virtual) place at the same time is pretty much enough to justify a discrete format.

If there's just one player however, one might as well create a linear, stringently designed experience. And that's what regularly happens. Especially in AAA games that have enough of a budget to keep a giant content machine running, this model is pretty much the standard model.

Indie developers usually don't have this kind of funding. Hence tools such as procedurally generated content can help. However, this articles is not about the practical, financial reasons for taking more systemic approaches to game design, but about a fundamental cognitive efficiency advantage.

Length Matters

Especially big productions full of hand-crafted content like to boast playing times of "hundreds of hours". What they mean by that is of course a prescribed period of time supported by the game, basically how long it takes to see everything and "get through" the game. But content aside and looking at actual depth of gameplay, what's the optimal length of a game?

Ideally players are engaged for as long as they still learn new and interesting things on a systemic level. If there is content beyond that point, for example because there's a story that needs another ten hours to be told, something tends to feel off. Players are basically "forced" to continue playing, even though they see through the system itself already. If a game is shorter than it should be on the other hand, players are missing out on significant parts of the system. Potential goes to waste.

"Problem solved!" you may think. Just design the game so that its length fits its depth! While that's not totally wrong, it's unfortunately not that simple. Every single player comes with their own mix of "game literacy". Veterans might see through a game after two hours, while newbies don't get it after ten. A game might be too long for one player, too short for another, and just right for a third. At best games can try to define vague structures that "work okay-ish for most players". However, a universally ideal playing time prescribed by the game simply doesn't exist.

And that's exactly where the match-based format shines. After every match, players can make the decision to quit, if they feel their own personal lifecycle for that particular game is approaching its end. The game's length is now in its players' hands. Self-determination over prescription. Of course this takes some amount of introspection, but it's worth it.

In the end the point of it all is to reach a richer, more substantial understanding of the medium, and being able to make better decision on how to spend your time. In good match-based games players repeatedly traverse feedback loops, and are free switch to the next title whenever those loops stop providing intellectual value. However, a different feature of match-based formats threatens this gain in efficiency time and again.

Groundhog Play

In particular, self-contained matches mean "starting from scratch" over and over again. A recent example of this design pattern is Dead Cells. After every death and the following restart, players have to go through the first few levels with their simple monsters and layouts again. Sure, they are procedurally generated, but the frame conditions of the generator stay untouched. It's irrelevant how skillful a player has become already. The game is reset. While the early-game might have been a great starting point initially, it slowly but surely becomes a grind.

To be clear: This is just one of many examples. Motion Twin's roguelike platformer is a great game and shares this problem with most single-player games that can be permanently won or lost (per run). If you're looking for an especially clumsy design, consider Diablo 3 and its "permadeath" mode. In its case, the early grind takes dozens of hours instead of a few minutes. After all, the feature is more of a curiosity (and a tribute to the game's roguelike roots) rather than a deliberate design.

In any case we can derive the core of the reset problem from the above observations:

This results in a twofold feedback problem. Players learn less and less in the early-game and not often enough in the late-game. Neither part reliably and regularly confronts them with interesting gameplay appropriate to their skill level. The efficiency gained by choosing a match-based format is lost again in this highly suboptimal learning process.

Asides: Save Points and City-Builders

By the way, a variant of the reset problem can be found in games with pre-designed levels, too. If the last save point lies too far back, players will not just be confronted with the challenge they just failed again, but also with previous obstacles they had already mastered. In those cases players will sense that their time is not being treated with respect and get frustrated quickly. That's the reason why titles such as Celeste or VVVVVV are praised for their granular structure and frequent save points.

Another side note: Builder games like Anno or Banished are themselves closely related to the reset problem. Every playthrough tasks the players with fulfilling basic needs again and building the first few default buildings again. Tabula rasa. Interesting decisions come in at a later point. Incidentally, similar things are true for "build orders" in, for example, StarCraft. They are rehearsed in minute detail. A necessary routine besides the "actual" game.

But now back to match-based single-player. Good news: The reset problem can be solved!

Single-player Matchmaking

Basically, the solution can be directly derived from the critique: Resetting the system below the skill level of the player leads to a loss of efficiency. This means the game has to determine the skill of the player and continually, i.e. with every new match, adjust accordingly.

If this reminds you of the controversies around dynamic monster level scaling (e.g. Oblivion), you can calm down. Those discussions were concerned with a completely different kind of gameplay where the consistency of the simulated fantasy world is more important than efficient gameplay and learning. Match-based games however live by the latter. On top of that, they can transparently communicate adjustment to the difficulty between the self-contained playthroughs, and don't have to do it "secretly" while keeping a persistent game world running.

In so far, the Elo system or the traditional "ladder" are much better points of reference. That's right, in multiplayer dynamic difficulty has long been established. Players are constantly ranked according to their performance so that they can be matched with opponents of equal playing strength. That's how those games make sure players are always challenged according to their current skill level.

The solitaire equivalent: Single-player matchmaking! Now, it obviously can't rely on a dynamically filled (and depending on the player base very granular) ladders. Instead of matching players against one another, players are "matched" with a variant of the game tailored to their skill level. That means the different difficulty levels have to be explicitly designed for this purpose, and the game has to be complex and scalable enough to allow that.

So far there are very few design forays in this direction. Auro for example uses a combination of scaling scoring requirements and hand-crafting ranking tiers to tweak its random level generator. Similarly, the BrainGoodGames titles scale various factors, such as enemy density or map layout, depending on the rank of the player. In both cases the difficulty is automatically determined by the system that continuously measures the player's skill.

Recently, the popular roguelike card game Slay the Spire took a different approach in its "Ascension Mode". While it also poses an ever-increasing challenge, it requires players to essentially become designers of their own experience and choose the exact Ascension level by themselves every time. On top of that, even high-level matches have the problem of starting out too easy. This is most likely a relic of the RPG-like setting of the game: Players are, within a single playthrough, supposed to get stronger over time as the game gets harder. Suboptimal.

But while the Ascension system isn't perfect, it's certainly an answer to the described problem. That alone makes it a piece of progressive design, since most match-based single-player games simply don't have one. At best they provide a handful of difficulty levels the player is supposed to choose from, or they simply resort to the sadly still pretty widespread "highscore" format.

Maybe it's because developers have more fundamental questions on their plates ("How do you create interesting core gameplay to begin with?"). But maybe some are just not fully aware of the reset problem and its implications, as it's rarely talked about in much detail. Yet.