Giving Space to Design Space
The 101
“Design space” is a fairly nebulous term; it’s strange and abstract. As far as I know, it’s the measurement of potential avenues of design. It questions what has been done, what could be done, and what will be done given a set of parameters. Being able to sense design space, even intuitively, requires an amalgamation of several design skills and experience in curiosity.
The most basic of ways to figure out design space is as follows: For any given thing—mechanic, system, game, composition, methodology, syntax, recipe, date plans, routing, distribution, show format, really… anything!—figure out what variables can change without altering the foundation and quantify the permutations. The greater the number, the larger the space.
But it’s never so simple. Just like simple arithmetic or basic grammar rules, the concept of mapping out permutations is a stepping stone to greater nuance and complexity. The common second step is this: Of those permutations, which are worth considering? For most, this is more than enough to get by. But as always, we’re all about diving a little deeper.
What Has “Design Space”?
The answer is probably everything but that helps nobody so let’s narrow our focus to make it approachable. This is somewhat of a game design blog so we’ll choose some common subjects of “design space analysis” and explore how we might view design space in that context.
From here, I’ll be using the terms “input” and “output” frequently so let’s define them. “Input” is anything that gets processed in some way by a function. This encompasses things such as button presses, a range of variables (decided by designer, player, or environment), or formula components. “Output” is anything that is the result of those functions such as actions being taken, something where all the variables are finalized, or the result of an equation.
1. Mechanics
For clarity, I’ll be referring to “mechanics” as any action a game allows a player to take rather than “keyword mechanics”.
This is fairly straightforward. Design space for mechanics usually manifests as input and output. Being able to quantify what is a possible input and, of course, the potential output makes this relatively straightforward. For example, character movement in a video game. Pressing a direction on the d-pad or tilting an analog stick is usually enough for a character to start walking. But introduce some spice such as a sprint button or modifying handling while making turns and suddenly we’re pod racing.
Occasionally (ideally, really), mechanics have overlaps with other mechanics, groups, and systems. This usually means an output is part of another mechanic’s input. For example, Sonic’s velocity in Sonic the Hedgehog translates directly to differences in their jump trajectory.
2. Groupings (Including Factions/Archetypes)
Mechanics are usually one part of a whole bunch of other mechanics. For example, you might group walking, running, jumping, and turning under “movement mechanics”. You can probably think of examples of your own from a variety of games, such as combat mechanics, leveling mechanics, or exploration mechanics. From here, we can start recognizing a common trope used in game design: Factions/archetypes. In essence, these are groups of mechanics, sometimes disparate, that form an identity somehow. Big costs, big stats, a focus on using bulk to bully others rather than weathering a storm, and a slight reckless streak in exchange for damage are all attributes of Legend of Runeterra’s Noxus faction. These mechanics (or at least the concept of these mechanics) do intermingle, but not quite in the way that running, momentum, and jumping would. However, I bring up these two methodologies in the same subsection because how I approach design space for both is practically identical.
Whereas the design space for individual mechanics is more of a tree-like structure, design space for groupings generally manifests as more of a web. What players can do with one mechanic will most likely affect another mechanic (usually in a way that aligns with their goal, probably making some sort of synergy obvious). When it comes to factions and archetypes, designers will usually opt to instead integrate trade-offs: Mages in the Final Fantasy series are known for having powerful magic that can also deal area-of-effect damage, but they also have measly defense and health stats. Rather than be great at everything, groups having clear strengths and weaknesses makes things more exciting and personal. Understanding the range of things you can change while keeping the contrast of trade-offs is part of the design space of groups.
Left: A representation of a singular mechanic and its input (top) and output (bottom).
Right: A representation of mechanics that would make up a group of “Movement Mechanics”.
In essence, the design space for a grouping is recognizing what mechanics within that group share inputs, what mechanics feed into each other, and whether you can effectively mold the output into something the group wants or needs. You’re effectively figuring out how much leeway you have to tune different parts of the group while maintaining or striving for a certain perception of that group. Let’s look at Bros. Attacks in the Mario & Luigi RPG series. For the most part, the design space is how much you can change the average of the the following: Different costs to use the Bros. Attack, outcome of the Bros. Attack (usually damage), and the mini-game involved with it.
3. Systems
System is the term I’m going to use to describe the basic and foundational webs of mechanics that make up a game. It generally covers things such as “how do you play a card” or “all of these mechanics that push towards a victory condition”, though it is also a term that covers meta interaction such as progression systems like leveling up or ranked ladders.
As a result, our metaphor is going to get a lot more nebulous. We’re going from trees to webs to, finally, a cloud. It’s difficult to point out specific things about a cloud; we can’t really see each individual vapor with the naked eye after all. But we’re able to recognize when clouds change density or when they start raining, thunderbolting, or snowing. Meteorologists (the halfbaked wizards that they are) can even do things such as notice trends in humidity, temperature, and wind currents to somewhat predict how clouds and certain weather events might happen.
A representation of everything that might go into a “Leveling System”. Keep in mind that each node has its own series of input/outputs like our earlier example of “Running”.
Game systems are similar. There are plenty of inputs you can change as a game designer. Though it’s simple enough to track in a vacuum (such as examining within just one mechanic or a small group), pushing a change through a game that has multiple systems interacting can be very difficult to wrap your head around. For example, Magic: The Gathering has a system where players are allowed to place one land from their hand onto the field each turn. While changing this value might seem like a minor thing (especially to non-Magic players), it would have major repercussions especially regarding land drop variance and mana curves becoming very wack.
To this end, I think it’s important to note that changing major things in systems isn’t a bad thing or even something that’s impossible to quantify. Just as weather wizards can predict whether storm clouds will form based on trends of atmospheric pressure (whatever that is), system designers should be able to make educated guesses on how changes will affect player behavior or mechanics. In practice, figuring out design space for a system is similar to figuring out design space for a very large, much more complicated group.
Design Size Space
A common distinction people make when talking about design space is size. X has so much design space! Y has very narrow design space. Z has “interesting” design space but it’s tough to fish out. And so on and so forth. Let’s go over some broad definitions to have language we can work with.
1. Wide
Something has wide design space if there are a huge number of ways you can tune it or add to it. It doesn’t even have to just be a wide range of numbers for a specific variable either. Something with wide design space is only ever really limited by project scope and the project’s overall goals. The copy abilities from the Kirby series is an excellent example of something with an incredibly wide design space. That might be cheating though, so let’s also use talent trees in… every game with a talent tree since Diablo II. While the concept and execution has been homogenized and beat to the death since, the origin and pliability of its original intention still rings true to this day. You can fill talent trees with tons of different nodes, lock certain nodes behind commitment, allow for mixing different trees, incentivize synergies, disincentivize anti-synergies, create milestones and keystones, etc.
Various skill trees in different video games.
Credit: Image sourced from GD Keys’ “Keys to Meaningful Skill Trees”
2. Narrow
A narrow design space usually means there’s not much flexibility without compromising some foundational structure such as aesthetic, identity, or balance. Magic famously has many mechanics with narrow design space, but the prime example I’ll give out is the Epic mechanic. Epic locks you out from playing more cards meaning anything with it needs a powerful effect that’s worth that immense trade-off. But something that powerful would also be extremely polarizing. If it’s competitively viable, it promotes stalling gameplay that might end up with counterspell wars after 20 turns or skipping over the back-and-forth players crave. If nonviable, Epic cards simply see no relevancy at all and exist only for nerds and blobs to ridicule in the future.
Each card with the Epic keyword mechanic. There have been no more cards with Epic released since 2005.
Credit: Wizards of the Coast and Scryfall
3. Medium
“Something wider than narrow, but more narrow than wide.”
A more helpful definition would be design space that has quite a bit of flexibility but ultimately a fairly clear end to the viable design space. The simplest example would be mana/energy/action resources in pretty much every game that has one. There’s only so much silliness you can get away with before it turns into excruciating bookkeeping that turns away more people than it brings in. As a result, the viable design space has some decent flexibility but has a pretty clear limit.
The elephant in the room is that most things exist within a narrow or medium design space by these definitions. But it’s important to remember that these terms are not value or moral judgements by any means. Many projects are a compilation of multiple things with design spaces of different sizes, each fulfilling their purposes to make the whole project greater than the sum of its parts. Minecraft is a great example of this concept. It has a huge amount of freedom when it comes to building since the player has access to many different blocks and creations, but its health and hunger systems are decidedly narrow.
A Small Note
The observation of a design space’s size necessarily changes with the context of what is being observed. In many cases, my examples are of ways to iterate upon mechanics, groups, and systems by manner of using those functions to create cards, effects, or incentives. However, figuring out something’s design space size could also include the designer’s ability to create challenges or enemies that interact with it in some way or how much creativity or flexibility is being given to a player.
Mario Maker 2 includes the capability of adding “Clear Conditions” when making levels.
Credit: Screenshot sourced from IGN
Observation, Analysis, Creativity
How does one harness the concept of design space to further their own goals? I mentioned earlier that being able to sense “design space” requires an amalgamation of several design skills… which I’ve outlined in this section’s headline. Of course, this is a distillation that doesn’t account for every nuance possible, but I think these three skills will get you past the finish line. Let’s go over what they are and how to utilize them.
1. Observe
This is a practice of recognizing what spaces of design has already been explored. For newer creations, this is obviously “impossible”. But, even still, you have to go through history (of your game(s), and of previous games that others have made) to figure out what roads have been tread. For example, I could create an entirely new mechanic for MonsterCon called Shifting—putting one card from the Reserve Zone at the bottom of your deck and replacing it with the top card of your deck—It’s new and I haven’t done that before, but it’s not new in the sense that it is a mechanic that falls under “card selection”. This way, rather than start with nothing, I’m starting with something.
While you’re observing, here are a few key things to look out for:
1a. Dependency - How functional is the thing you’re observing when it is alone? Does it function by itself? Does it naturally interact with other things? How extreme is it one way or the other?
For example, “dragon rush” in Dragon Ball FighterZ and throws in most 2D fighting games are mostly independent. However, they actually interact with a lot of different systems and mechanics. They tie into the aggressive/defensive relationship by overriding blocks, allow for skill expression in the form of “teching”, and fit into meta combo strings.
An example of codependency would be “super moves” in those same 2D fighting games. Unlike “dragon rush” or throws which are basic mechanics that are always accessible, super moves are explicitly locked behind “super meter”. How you gain meter tends to be different in each game but it usually involves interfacing with the game in a specific way (such as dealing damage). Though obviously part of the design, super moves are wholly dependent on other parts of the game and that makes it much tougher to innovate without stressing the rest of the balance environment.
1b. Reach/Impact - How much does the thing you’re observing affect other parts of the game design? Is it something that will drive players to take certain actions? Will its implementation affect future designs?
For example, how versatile and accessible aerial movement is in 3D platformers will necessarily change the goals of that game. If a character could fly freely then basic platforming is largely unnecessary. However, if the flight is conditional, challenges can be made for meeting those conditions. And so on and so forth.
One trend you can follow is Experience Point distribution throughout Pokémon games. It started off static and generally kept players lower leveled than gym leaders and boss fights unless they grinded. However, recent games have introduced dynamic exp gains as well as just a generally higher amount of exp overall.
Exp. Share (especially iterations after Pokémon X & Y) speeds up the process of leveling multiple Pokémon and crucially skips the need to fight with lower-level Pokémon to get experience.
1c. “Knobs” to Turn - What can you change about the thing you’re observing without changing it into something else completely? What’s the range of values you can utilize or what is the range of ways players can interact with it?
For example, Hades 2 has a Magick resource system and it is basically mana or MP for certain actions such as Omega moves. The basic knobs are starting Magick values, how much each action uses Magick, and methods of increasing Magick. They do have some fun spice though: Different methods of replenishing Magick, Hexes which require Magick usage to enable, and “priming” Magick by making a portion unusable.
2. Analyze
This step is more about figuring out whether you’ve exhausted the current design space you’ve laid out. How much more can you iterate on the same concepts you’ve been exploring? This is a bit self-explanatory and something you’ll probably be doing during the earlier observation stage. However, let’s still briefly cover it:
2a. Check Dependencies - How many more designs can you get while keeping it independent? If its design is dependent on something, how much more can you stress that dependency?
2b. Check Impact - How many more designs can you get without overwhelming other parts of the game?
2c. Check Knobs - How many more times can you turn knobs before you’ve exhausted all options?
3. Create
Let’s get this out of the way: Manifesting something that has not been created is tough. This part is especially tough because figuring out what you haven’t worked with will stress the parameters of the design space you’re trying to expand. For example, “special summoning” in Yu-Gi-Oh! seems innocuous enough. There are a billion ways to special summon something but explore something a little too out there—such as fusion summoning using materials that are milled by effects à la Tearlaments—and you begin stepping on toes. However, creating something exciting often coincides with power and/or complexity creep. With that in mind, here are a few design strategies you can use that are tastefully attributed to various actions of an iconic children’s toy.
Flick It - Stress the definition of the thing. For example, how does the thing work when something circumvents its intended trade-off?
This is a classic design space to explore and famously dangerous. Generally, I would avoiding designs that absolve consequential downsides and instead focus on alternative methods. For another Yu-Gi-Oh! example, Synchro Summoning versus Xyz Summoning. The basic premise is similar; bring out a bunch of monsters and use level modulation until it is just right then “combine” them to summon a big boi. However, Synchro Summoning has more flexibility in levels but requires a Tuner-type among your monsters whereas Xyz Summoning generally wants all monsters with the same level and does not require a Tuner.
Pull It - Stretch the definition of the thing. For example, how does the thing work when it's used somewhere it's not originally supposed to?
This one is a little odd to champion because it’s probably the one that creates the most new things out of each of these processes. A few examples would be “destroying cards that are already destroyed” or “discarding from the deck rather than a player’s hand” becoming banish/exiling and milling respectively. A more proper example would be along the lines of “this character has higher defense when near a teammate” being given to knightly characters who protect others. It’s entirely possible that this enables the knightly character to charge into battles with their teammates and be much more aggressive.
However, my favorite example of this is probably “Rocket Jumping”. In some First-Person Shooters, like Quake, the explosion from a rocket launcher moves your characters. However, if the explosion is angled correctly and combined with movement from a character’s jump, the explosion can add a lot more velocity to the jump to create a sort of super jump.
A diagram of how “rocket jumping” works in Quake 3.
Credit: Jan Pruce
Twist It - Apply the thing to other similar things. For example, how does the thing work when applied wholesale to another thing (similar or otherwise)?
At this point, “thing” has lost all meaning but I’ll try to power through this. It’s easy to think of each mechanic/group/system as having its own individuality, but we’ve already discussed how they coexist with others in the same ecosystem. These necessary similarities actually make it possible for you to transplant designs from one mechanic to another.
For example, the RPG genre is famous for its leveling progression. However, the tradition is that it is mostly characters themselves that level up and improve. However, apply the leveling progression to other aspects such as items, skills, or classes, and you’ve got yourself a match made in heaven.
Bop It - Apply the thing to an all-together different thing. For example, how does the mechanic work when being assimilated into a system or another group?
This is probably the most mind-bendiest one for myself. Essentially, you should reconsider an aspect you think is fundamental but is actually not. Simple examples that have found great success would be bringing RPG progression to real-time action combat games or bringing procedural terrain generation to open-world games.
Keyword counters from Magic: The Gathering are also a great example of this. There are plenty of counters in the game, some of which even have rules integration! Combining them with classic evergreen keyword mechanics is a simple twist that breathes life into things such as sorcery/instants granting keywords or generic counter interaction/support.
4. Temper
That’s right, I’ve snuck in another skill you should hone that wasn’t alluded to in the section title!
The previous three skills are all about creating a whole bunch of raw material. Finding out novel approaches is important, but understanding whether that approach is going to inhibit the project or open up avenues you’re striving for is just as, if not more, important. Here’s a food metaphor: You’ve foraged for a bunch of tasty foods, but now you’ve gotta sort out which ones will give you food poisoning, inedible ones, edible ones, and the delicious ones. Sometimes, inedible things can be used in a specific way to create an interesting result (for example, different woods imparting flavors while smoking food), but you should largely be focused on figuring edible food when starting out.
But what is viable design space and what is nonviable design space? It always depends on your project scope and goals, but you should broadly be considering how many resources you need to invest to explore that design space. I could have the goal of figuring out whether Epic from Magic: The Gathering has untapped design space that is fun and balanced, but the prospects are such that I would spend a ton of creative energy and time for something that is most likely not there. Even if I did find something, the chances of creating more than a few cards is virtually zero. In comparison, devoting resources to exploring Cycling would give me plenty to work with!
Various cards with Cycling that iterate on the keyword mechanic in various ways. This isn’t even all the ways they’ve explored so far!
Credit: Wizards of the Coast and Scryfall
Oftentimes it’s not about whether you can expand on something or add depth, but whether devoting time, energy, and resources to that specific avenue will add or detract from the project. Combat in Minecraft is simplistic, almost to a fault. But it’s almost guaranteed that adding some fancy shenanigans to combat would stress development with cascading effects on customers while also not adding anything the playerbase actually wants. By comparison, combat in Sonic Unleashed’s night time stages could use a great deal of tweaking! It’s entirely too slow and too simple which is a huge departure from the day time stages which are frenetic and have a great deal of complex inputs (for speedrunning, at least). There was probably an intention for contrast and variety, but the pendulum swung too far and instead polarized the experience.
Be bold with your creativity, but also pick your battles. Explore beyond the boundaries of your creativity, but make sure there’s ground underneath where you’re walking.
Maximizing and Minimizing Design Space
With all of that out of the way, let’s finally go over some practical tips for navigating design space. The main ways to go about it are maximizing iterations within design space and minimizing involvement in design space to fit the needs of the project.
Why Maximize?
Making the most of the design space you have access to is just good business. If something proves to be successful, giving people more of what they like is a natural convenience for all involved parties. It’s a little cynical for sure, but the customer is always right in matters of taste after all.
Maximizing within design space also takes a lot of pressure off from designers to create completely new innovations. Reiterating on an existing concept has a significantly lower hurdle than manifesting new, untested concepts while still being capable of creating similar levels of excitement. Of course, entirely new systems or modes of play would be fresh and exciting, but being able to breathe life into existing systems with incremental innovations or slight re-imaginings hits similar notes to nostalgia. Super Mario Odyssey is a great example of this. Mario’s movement options are very similar to his earlier 3D platforming excursions, but the admittedly small changes shake up a lot of the game feel for veterans. Diving into a thrown Cappy is just a good time for all!
An overview of different moves Mario has access to in Super Mario Odyssey. There are oldies and newbies alike!
Lastly, there’s an argument for cohesion in the project. Something that is bursting at the seams with a huge variety of crazy, innovative ideas seems like a great thing! Truthfully, that can actually be pretty overwhelming for all involved parties and it might actually have a side effect of making each individual idea seem disjointed. Some games do the shotgun approach very well such as the WarioWare series or the What Remains of Edith Finch, but games that do this successfully are far and few between. Instead, taking a core concept and maximizing within its boundaries can lead to a much more fulfilling experience. Take pretty much any Mario platformer or 80+ hour JPRG as an example of this.
What Maximize?
We’ve covered “observe, analyze, create, temper” as general strategies and practices for exploring and navigating design space. However, when it comes time to systematically iterate within design space, a little direction does go a long way. The three main things I look at when trying to squeeze every last bit of juice from something’s design space are: Input, Output, and Recontextualization.
Input
This is probably the most self-explanatory one. Generally, it is all about figuring which forms of input feed into the design space then figuring out the range of those inputs. Afterwards, make accommodations if necessary (most likely to the output).
Let’s cover guns in every first-person shooter ever. Press the “fire” button to shoot a bullet. The main input here is how the fire button is pressed. Can the button be held? Is shooting multiple bullets in succession contingent on multiple presses? Can pressing and holding the button be mixed in a sequence? Does pressing the button require a specific timing? There’s plenty to work from just this, but external factors can also affect the input. Aiming is a classic input, as is firing modes or randomness from accuracy/bullet spread. Heck, even projectile types or environmental factors that affect projectile qualities can shake things up.
Expanding the range of possible inputs necessarily has an effect on the rest of the game. Having several distinct inputs result in the same output can be neat in some circumstances, but making them affect the output in a meaningful way adds a lot more creative possibility for both the designer and player. In accordance to the previous example, it could be something simple such as “holding down the fire button” causing the gun to shoot automatically at a quick rate.
Output
Coming at the angle of “output” is a little special. There are three ways I go about it: Substitution, embracing variability, and working backwards.
Substitution is the idea of recognizing an input-to-output scenario and figuring out a substitute for the output that allows that scenario to still function. For example, rather than “holding down the fire button” causing automatic shooting, what if it instead had a charge shot function similar to Mega Buster from Megaman or spewed out a substance like Pyro’s Flamethrower from Team Fortress 2? This is also where character/item dynamics can be put on the forefront. Luigi often has similar (or exactly the same) controls as Mario but with some knobs turned such as less ground friction and different jump trajectories.
Embracing variability is designing situations in which the exact same input can cause different outputs. The extremeness of the range of output doesn’t have to be wild or anything. RNG-dependent systems such as die-rolling or accuracy/evasion in turn-based RPGs come to mind. But even scenarios that are extremely hard to control, such as accounting for bullet drop over large distances on an erratic moving target in a split-second in ARMA 3, can be considered in this camp. This can be difficult to tune since each player has their personal bias on how much “RNG BULLSHIT” they can tolerate, but this is a worthwhile scenario to consider if only because our monkey brains just love gambling cost-benefit analysis judgements.
It’s also very possible for the designer to recognize a specific output and mold a range of inputs to facilitate interaction around it. Let’s take the Gunzerker in Borderlands 2 for example: While Gunzerking, doing anything beside blasting on all cylinders would be wildly inefficient and also burn up valuable Gunzerking time. However, it also has some semblance of added depth because there’s some pre-planning involved with skill builds and gun setups. Additionally, Yu-Gi-Oh! is a king of this; and we’ll specifically cite their design philosophy from the Synchro era onward. Their designers recognized a core appeal of the game was special summoning exciting monsters using on-board materials and many effects and archetypes were molded to fit that sensibility.
Recontextualizing
The last thing to consider when maximizing iterations within design space is recontextualizing inputs and outputs. This creates an additional layer of depth on the shoulders of an existing input-to-output scenario. When done expertly, it leads to a great deal of innovation and unlocks more design space than you considered before you started!
Let’s use jumping as an example. It just allows a character to… jump. However, history has shown us that there’s a great degree of depth, even beyond modifying the involved input and output. There’s no better example in my mind than the leap from Donkey Kong to Mario Bros (and also Super Mario Bros). Jumping in the former was primarily a method of evasion whereas jumping in the latter additionally serves as an attack. This is something we take for granted these days, but I think it’s a perfect example of how a simple change creates a great deal of dynamism.
Left: Mario in Donkey Kong using jumping solely as a method of avoiding obstacles and traversing the level.
Right: Mario in Super Mario Bros. using jumping to defeat enemies.
Credit: Left screenshot sourced from “Cracking the Code of Kong”
“Haste” in Magic: The Gathering (or whatever knock-off another game might have, such as “Rush”) is a decidedly simple mechanic as well. There’s not much you can really do in terms of input-to-output without resorting to ridiculous amounts of wordiness or complications, so the design space is fairly narrow. Yet there is some to be found when recontextualizing why and how Haste matters. For example, whom is receiving Haste? On bigger bodies, it’s quite threatening but on smaller bodies, it’s more of a scrambly play. Yet Haste can still be given to cards with “tapping costs”. Very specific signals such as “when this creature attacks” can be given to cards as a huge signpost saying “GIVE THIS THING HASTE”.
At this point, the delineation between modifying input and output is blurred beyond recognition. But hopefully, this gives you some insight on how to start toying around with every variable with some degree of intentionality. However, just like I advocate tempering exploration of design spaces, I think knowing best practices for minimizing a project’s involvement in design spaces is a great boon for any designer.
When Minimize?
There are plenty of reasons why a designer should minimize their project scope and plenty of reasons why they should limit how much design space they explore for any given thing. We’ll disregard concepts that have a narrow design space since that is fairly self-evident, but copy abilities such as the ones found in the Kirby series don’t have a conceptual end. In that case, why doesn’t every Kirby game have infinite copy abilities? Although Kirby 64: The Crystal Shards even explored the concept of holding two copy abilities to fuse them, the truth is that mining design space until it’s barren or running on fumes is not a great practice; the novelty and fun factor is often completely gone by the time you’re strip mining. Budgets are not infinite and time is always ticking. Beyond the practical reality of it, minimizing the design space being explored does have creative benefits. Two common adages stick out for me: “Less is more,” and “restrictions breed creativity”. And even beyond that, I’ve got a small list for you.
Problematic - Sometimes the design space of something beyond the surface-level will lead to issues that break the game, usually balance or complexity levels. The easiest example I can give is the usage of any graveyard/discard-based interaction in most 1v1 dueling card games. This group of mechanics has a fairly wide design space, but stretching the output range to anything beyond moving one or a few cards at a time with strict costs is likely to tear competitive (and truthfully, even casual) play apart. As a result, you’ll often see this group of mechanics be heavily restricted to the point of seeming like it has narrow design space.
Distracting - The presence of something necessarily draws attention from other things. If A is the most important aspect of the project, giving more attention to B is placing less emphasis on the most important thing, A. This isn’t always the case since seasoning or sauces can make food stand out greatly, but it’s a matter of knowing when too much seasoning or sauce is being applied. Monster Hunter Rise is home to Rampage Quests, a type of tower-defense-styled mission where turret defenses are setup and a horde of monsters try to break through walls.
The wackier side of Monster Hunter Rise. While multiple monsters in the same area has been a thing for a long while (and even a major component of Worlds AND Rise respectively), the volume of monsters as well as ways of engaging them being so dramatically different left the alternative quest mode with a lot of negative feedback.
Credit: Screenshot sourced from THEGAMER’s “Monster Hunter Rise: All Kinds Of Quests Explained”
This is a very wild departure from the “core fun” of Monster Hunter which is likely the point; gotta introduce some variety so players don’t get bored, right? Unfortunately, these quests are given enough of a spotlight and development that it ruins the whole game (and greatly diminishes enjoyment) for a part of the playerbase. The Rampage Quests are a seasoning that overstayed its welcome and they’re pretty much forgotten in the game’s expansion and widely considered a black mark by the fan community.
Running Out of Reserves - While creative work is technically endless, the well of accessible and viable creative work is limited by budget and time. This concept extends to what is possible to work with within design space. At some point, all the low hanging fruit of iteration will be plucked and novel interpretations will require much more time and money to discover.
Additionally, if a design space is continually mined, it will eventually need to compromise on its foundational structure. Done enough, it either falls apart and creates—for lack of a better phrase—slop, or, optimistically, transforms into something new.
These two concepts are inextricably linked and are often the underlying reason for creepy design boogeymen: Power creep, complexity creep, and feature creep. While these creepers are a necessary part of design evolution, they are also a huge drain on financial and creative resources.
Scarcity Brings Intrigue - This is the most cynical reason but scarcity has a very strong connotation with value and novelty. The idea of potential, for whatever design you have, is sometimes what draws an audience. Creating an evocative and fun mechanic, faction, or system but only using a minimum can inspire intrigue. “Will there be more of it? What else could be done with it? Will other cool stuff that’s similar come out?”
How Minimize?
Specify - Oftentimes, over-exploring design space is a symptom of having design guidelines be too broad or unspecific. Everything being designed should ideally have an intentional place and how you decide what is viable needs to evolve to fit the project. When you touch upon design space, you should figure out how deep you want to dive into it. You don’t need the exact answer right away; this process is always a work-in-progress. But clarity in this aspect will grant you greater intentionality and focus, leading to a more engaging design in the end.
Trim the Excess - Speaking from experience, there’s absolutely zero chance you need EVERYTHING you can think of in your design. The creative process for most people is similar to panning for gold among dirt and other minerals. However, this process often discovers iron pyrite or, as it’s better known, fool’s gold. Your creative process will inevitably come up with a bunch of cool, shiny things and it’s fine to keep them around. However, when it’s time to choose only a select few, you’re best served by being ruthless and trimming the non-gold when possible.
The End Times
One of the reasons I wanted to take on this topic isn’t because it’s a core skill all game designers should have. I alluded to it briefly in “The 101”, but “design space” as a concept and the strategies and tools I discussed here have very broad applications. This ultimately is an exercise in discovering what your possible actions and plans are so you have the best possible chance of picking one that serves your goals.
The next time you’re planning an outing with friends, you might recognize how travel distance or schedules can restrain possible plans. Maybe when you want to add a twist to a recipe, you figure out what parts actually have a bit of leeway in preparation and execution. Personally, when I was making comics, I recognized the eventual format it would be posted (Instagram posts) and thought of ways to work with and around it. What size would each post be? Since most people would be swiping to go from image to image, how could I tune the content and compositions to be suitable? How could I do layouts so it was readable on mobile devices? There (was) a max of 10 images per post, so what plots and comics could I make within only those 10 images? And so on and so forth.
I’ve also got a companion piece in the oven where I yap about design space of a variety of different mechanics/systems in games. You can find it at this link: www.blobspike.com/blogspike/2024/11/29/mini-studies-design-space
With that, I think I’ve sufficiently covered a deeper understanding of design spaces, different methods of approaching design within those parameters, and ways to be practical about tackling design space within a project’s scope.
Ciao,
blobspike