There’s an old dream in game design. It drives the design of games like SimCity, Dwarf Fortress, Tropico, The Sims, and Prison Architect. I like to call it the Simulation Dream.
In 1996, Starr Long, the associate producer of Ultima Online, talked about the game before release:
“Nearly everything in the world, from grass to goblins, has a purpose, and not just as cannon fodder either. The ‘virtual ecology’ affects nearly every aspect of the game world, from the very small to the very large. If the rabbit population suddenly drops (because some gung-ho adventurer was trying out his new mace) then wolves may have to find different food sources (e.g., deer). When the deer population drops as a result, the local dragon, unable to find the food he’s accustomed to, may head into a local village and attack. Since all of this happens automatically, it generates numerous adventure possibilities.”
That’s the Simulation Dream – the idea of making a complex simulation of a story world, which creates fascinating emergent stories as powerful as those you might write yourself. The idea bursts with potential. And it appears everywhere. Early in the development of BioShock, that game had an ecology too. There were three parts to it. Splicers would hunt Gatherers, who were in turn guarded by Protectors. The player was supposed to interact with and manipulate this ecology to survive.
But these dreams shattered. After its release, Richard Garriott said of Ultima Online:
“We thought it was fantastic. We’d spent an enormous amount of time and effort on it. But what happened was all the players went in and just killed everything; so fast that the game couldn’t spawn them fast enough to make the simulation even begin. And so, this thing that we’d spent all this time on, literally no-one ever noticed – ever – and we eventually just ripped it out of the game.”
The same happened on BioShock. While BioShock retained some valuable vestiges of its simulation-heavy beginnings, the game as released was really a heavily-scripted authored story. There was no systemic ecology at all. It worked fantastically as a game – but it wasn’t a deep simulation.
The problem is that simulations with a lot of moving parts quickly become complex in the intimidating academic sense. There are so many pieces interacting that the game can easily become too much to understand, predict, or play with. All the interesting stuff in the game ends up lost in the silicon, inaccessible to the human players’ understanding.
And that’s really the key – making complex simulated events accessible to human understanding. Which brings us to a nerdy idea I like to call the Player Model Principle.
The Player Model Principle
The Player Model Principle is this:
The whole value of a game is in the mental model of itself it projects into the player’s mind.
We make a simulation in computer code. That is a computer model of some situation – a dwarven fortress, a prison, and so on. But that is not the only model of that situation designers need to worry about. There is another model of that fortress or prison – the mental model in the player’s mind, which the player constructs while playing the game. Designers create the Game Model out of computer code, while the player creates their own Player Model by observing, experimenting, and inferring during the play.
In play, the Game Model is irrelevant. Players can’t perceive it directly. They can only perceive the Player Model in their minds. That’s where the stories are told. That’s where dilemmas are resolved. So the Game Model we create is just a pathway through which we create the Player Model in the player’s mind.
The Player Model Principle indicates a source of risk. Namely, anything in the Game Model that doesn’t copy into the Player Model is worthless. That’s what happened with the ecologies in Ultima Online and BioShock. They didn’t enter the Player Model and so degraded into noise. This is a fairly obvious risk and is common in game design – all designers have seen players not understand a piece of their game.
But the Player Model Principle also implies an amazing opportunity. What if we could put something in the Player Model without implementing it in the Game Model? What if we could make the player perceive some event or relationship or meaning that wasn’t even there?
The advantages are obvious. We wouldn’t have to build it or test it. And it wouldn’t add any complexity burden to the game. While this sounds exotic, it actually happens all the time. It’s called apophenia.
Apophenia is seeing meaningful patterns in random or meaningless data. For example, look at this wall socket. What do you see? A face! And not just a face. But a face with a confused, perhaps pained expression. Why do you see that? There is no such personality here. But we perceive it all the same. It’s how we’re wired as human beings.
That ability to perceive personality and intent is a deep-seated human ability. It happens below conscious awareness, the same way you can look at a room and understand it as a 3D space without thinking about it. The only knowledge of the room you have is a 2D projection of it on your retinas. But some silent processor in your brain generates the perception of a 3D environment. In the same way, we effortlessly perceive minds and intentions. It’s why ancient peoples perceived spirits in rocks, water, sun and moon.
Apophenia is powerful and varied. Consider these Michotte demonstrations, named after the researcher who explored them in the mid-20th century.
But none of those emotions are in the game. The Sims 3 has a very simple computer model of social interactions which does not really depict deep human emotions like jealousy and anger. We perceive these things through apophenia – the same way we perceive a small ball fleeing from a large one.
Now the player takes control of the story. He hatches an evil plan involving a cheap stove, poor cooking skills (which cause fires), and wooden chairs.
And the plan works.
This story was co-authored between the player and the game. The game simulated some simple event (attraction between redhead and roommate), and the player ascribed meaning to it (jealousy and frustration) the same way he might have for the Michotte balls, even though that emotion was not actually in the simulatiion. The next part of the story was cued by him when he orchestrated the murder. The game simulated the logistics of firey deaths, but the sense of sorrow and revenge was, again, ascribed completely by the player. Most of this story is apophenia – present of the Player Model, absent from the Game Model.
It’s hard to see obvious ways to make players imbue meaning into a game that the game doesn’t actually have. But survey the products that do it well and you see patterns.
Borrow archetypes from real life and fiction
Use the archetypical jealousy plot, the evil stepmother, the good king, the classical hero. This saves exposition since the player already knows the stock character or situation you’re hinting at. This makes it easy for players to fill in absent details.
Allow players to project themselves into the game.
When a virtual character has your name pasted on, it is easy to imbue that character with motivations that are relevant to you. The same goes when the player projects in their friends, house, and so on, into the game. The Sims gains massively from this.
Create uncertain situations with human-relevant values in the balance
This is storytelling 101, but it bears mentioning. The simulation has to create situations that are worthy of being called stories. That means something important has to be in the balance, and the outcome has to be uncertain. Human values must be at stake.
Human values are things like life/death, alone/together, wealth/poverty. The game should revolve around things that affect these human-relevant values, and not descend into a dry simulation of traffic networks or production lines. Such simulations may be intellectually interesting, but will not generate effective stories because they are emotionally hollow.
Express or imply simple, pure, primal emotions
Annoyance is less interesting than fury because of the difference in intensity. Melancholic existential hipster sadness is less accessible than grief over a dead child because that grief is simpler, more relatable, and more primal. If the game has no opportunities for characters to feel such emotions, it is unlikely to generate good apophenic stories. Stories are built from primal feelings, so the subject matter of the simulation must create situations where characters would feel primal emotions.
Drowning in Complexity
So we’ve covered the benefits of apophenia. But we still haven’t solved the problem that killed the ecologies in Ultima Online and BioShock. How do we handle complexity? For apophenia to work, players have to see and understand interesting things happening. And this can easily prevented if they’re drowning in complexity.
Think of a simple system, like orbiting planets. For the most part, each planet only has a relationship with the sun around which it orbits.
If you want to tell a story about each planet, it’s easy. You just look at its one relationship and talk about that. So the Earth orbited… and it orbited… and it orbited. The problem is that while this story is easy to see and easy to tell (satisfying the Player Model Principle), it is also quite dull. We need more interactions, more variation, more unpredictability. We need more complexity.
Now imagine we’ve made a simulation of a village. Each of the hundred villagers has a relationship with each of the others – father, friend, enemy, lover, or acquaintance. Each can work at the fishing pond, the market, the field, the mill. Each can satisfy their own needs at the tavern, in bed sleeping, at the outhouse. The water can flood the field. The outhouse can spill into the market and contaminate it, causing sickness, overloading the hospital, making the doctor work too hard, leading to divorce. It sounds like the Simulation Dream. But there’s another problem now. The connections multiply until the whole system appears as a gigantic hairball of complexity.
Such a system could support some very interesting stories. I just told you one of them. The catch is that it will constantly break the Player Model Principle. With so many relationships, it becomes very hard for players to understand cause and effect in the system, so those stories end up buried and unobserved.
What we want to do is create systems that are smaller and simpler than these giant hairballs, yet have more interesting, comprehensible interactions than simple systems like orbiting planets. What we really want is not a system that is complex, but a system that is story–rich. Story-richness is a term I invented for this article, and a concept that I keep in mind while doing simulation design. It has a simple nerdy mathematical definition.
Story-Richness: The percentage of interactions in a game that are interesting to the player.
Consider every interaction in the game – every crop harvested, every path walked, every work spoken by a character. Of all the interactions happening in the game, what percent are part of an emotionally meaningful story? In a successful game, this percentage is high. Much of what you observe will be part of a story. In a poor game, it is quite low.
Interestingly, real life and most fictional worlds are not story-rich! Most days for most people on Earth or in Middle Earth are quite mundane. It’s only very rarely that someone has to drop the Ring into Mount Doom. Follow a random hobbit in Hobbiton, and you’ll be bored soon. It reminds me of an old war simulation MMO, where players sometimes had to drive a truck for hours just to reach the front line. Yes, we know war is 99% boredom interspersed with moments of terror, but a game about it should not be.
This means that a simulation game can’t be a faithful simulation of its subject matter! It has to be a narratively condensed, intensified version of that village, fortress, or prison. And it has to seem true to the source material without being true to that source material. The Simulation Dream just got harder.
Like apophneia, the sources of story-richness are difficult to see. But there are some patterns. The basic principle is to avoid uninteresting events and create more interesting ones.
Choose the minimum representation that supports the kinds of stories you want to generate
This is a complex piece of advice that I’ll try to unpack by example.
Imagine we’re making a simulation game and trying to decide how to model food in that game. How many classes of food do we put in? We have lots of options
- All of them! Cheese, venison, beef, chicken, broccoli, barley, corn, beer, water, juice, and so on. Hundreds of options, each acting slightly differently.
- Categories by type: Meat, vegetables, liquid.
- Categories by quality: High-quality, medium-quality, low-quality.
- One: Food is food.
- Zero: Food is not modelled and nobody eats.
Which do you choose?
Choose the minimum representation that supports the kinds of stories you want to generate.
The above sentence is fairly dense, so I’ll try to unpack it.
Consider the kinds of stories you want to generate in your game. To what degree are they about food? If you’re making a simulation of a New World colony in 1550, food will be important because starvation is a key driver of many stories in such a setting. The threat of hunger is, one way or another, part of most of the stories in such a setting. So you’d probably want a pretty nuanced food model. In such a game, the difference between seal blubber and vegetables could be important, because a diet of only seal blubber leads to scurvy during the winter, which leads to death. Human values are at stake!
However, if your game is a prison sim, you could make a strong case for not simulating food, or for simulating it in the simplest possible way. Because prison stories are not typically about food. Watch Oz or The Shawshank Redemption and few of the plotlines revolve around who is eating tasty bacon and who is eating cheap rice. A complex food simulation in such a game is likely to just add a lot of systems and noise that don’t contribute anything to the stories players care about. This complexity would be better added to the systems for gang membership, shiv combat, or friendship.
In general, lean on the simple side. You don’t have to simulate that much. The game is a co-author, not an author. It just need to hint at what is going on – the player’s apophenia will fill in details.
Use hair complexity for cheap fictional flavor
Hair complexity is my term for pieces of the simulation that don’t affect anything outside themselves.
I call it hair complexity because it sticks off the main ball of relationships without feeding back into it, like the hair on your head. Such hair complexity can be ignored by players who don’t wish to deal with it, while more interested or skilled players can pay attention and get its full flavor. It’s like the flavortext in a card game.
- In Dwarf Fortress, each dwarf has an appearance. These appearances do nothing, but help players form mental images.
- In Prison Architect, prisoners have criminal histories. They do nothing (so far), but they add flavour if you want to watch a certain prisoner.
- In The Sims, sims have conversation topics represented by images in speech bubbles. For the most part, these topics don’t matter. They could talk about sailing or sports; it makes no difference. What matters is that they are talking and their relationship score is improving. But players can, if they wish, watch the stream of images and imaging a thread of conversation leading from money to cars to a mutual friend.
- It was mentioned to me at a conference that hair simulations (e.g. Tomb Raider) are, ironically, hair complexity, since they don’t affect anything else in the game. Har har.
Hair complexity is cheaper to design. And since it doesn’t feed back into the larger game system, it doesn’t add complexity – just a bit of interface burden.
Eclipse Colony design case study: Crop Growth
Let’s put this into practice and look at a small example of a simple system design problem from my game Eclipse Colony. I faced this problem in early May 2013. Get ready for design nerdiness – we’re about to do some heavy analysis on what seems like a simple problem.
Currently, plants just grow on a timer and can be harvested when the timer expires. But it’s odd that plants yield the same regardless of whether they’re exposed to vacuum or not. I’d also like some notion of farmers tending plants to help them grow and yield more. Fix these issues.
In this situation I wrote several candidate designs to choose between before I decided on a path. Here they were:
Option 0 – Skip it
- Do nothing. Let plants grow the same on the same timer anywhere.
Analysis: Option 0 should always be there. There are always a lot of things we could work on in a simulation game. We could make a better friendship system. We could add animals or new weapons or wild plants. We could improve world generation. We could differentiate cultures, make a religious belief system, or add more nuances to the combat model. You have to be sure that what you’re doing is actually somewhere near the top of that gigantic priority list, because it’s easy to get tunnel vision. In this case, I decided that crop growth was worth working on because starvation is a big part of life in this fictional space colony. Furthermore, the missing behaviors had been bothering me in a direct and present way during playtests. It was a problem crying for a solution.
Option 1 – The yield variable
- Each plant has a variable called yield.
- When the plant is harvested, the amount of food that appears is based on yield.
- Each time a farmer tends the plant, yield increases. Once tended, plants can’t be tended again until a certain time has passed.
- Damage to the plants reduces yield.
- Being left in vacuum reduces yield.
Analysis: I liked this system at first because it seems to reflect the fiction well. But there’s a big caveat: a new variable (yield) is undesirable complexity. Also, how will yield work for wild, unfarmed plants in the future? Will they even have it? How does it interact with more normal damage from fire or explosions? Do plants also have a health variable? The added complexity and edge case ambiguities made this seem a poorer choice.
Option 2 – Use the growth timer
Remember that plants already have a timer that counts down until they’re finished growing.
- Each tending operation speeds the plants towards finishing growth.
- Damage to the plants reverses their growth.
- Being left in vacuum reduces plant growth.
Analysis: The simplicity of this is good because it doesn’t require any new variables. But this doesn’t capture reality – real plants don’t just grow slower when deprived of care or when damaged. They grow poor harvests, but they still flower around the same time. This system could lead to absurd situation like crops being slightly damaged repeatedly and just never becoming harvestable. Or plants being very well-cared for and being harvestable on a weird accelerated schedule.
Option 3 – Re-use the health variable
- Plants have the standardized health variable.
- Final harvest output is proportional to the plants’ health.
- Plant health steadily decreases at all times (due to insects etc.)
- Plants are damaged by vacuum and normal damage sources like fire.
- Tending plants is essentially repairing their health.
Analysis: There are no new variables or interfaces, which is good. It captures the essence of the idea well enough. It even expresses the rotting of grown plants, since they lose health over time after they finish growing. This seems like the minimal representation that captures the subject matter and supports the stories I want the game to co-author with the player.
I ultimately decided to re-use the health variable. But even this could still change as the game gets tested more.
The Simulation Dream Reborn
It seems like maybe we killed the Simulation Dream. You can’t just simulate a super-complex world because players won’t understand it. And even if you did, it would be boring, because even Middle Earth isn’t very story rich.
But the Simulation Dream lives on. We just know we have to approach it very carefully. We can’t blindly simulate everything, because most things are boring and people can’t understand over-complex systems anyway. We have to carefully craft a condensed system of simple, understandable hints that cue players’ apophenia to do the heavy lifting of ascribing emotion and meaning. We have to make sure that system projects well into the Player Model. And we have to make sure that much of what happens in it concerns powerful, primal human emotions, not logistical details.
But if we do all that, I think the Simulation Dream is still in our reach.
My Twitter: @TynanSylvester
My book: O’Reilly.
This article was previously posted on Gamasutra where it got some good discussion.