I have previously talked about level generation that can produce infinite terrain, a simple method for generating levels that satisfy puzzle solution constraints, and levels composed of pre-designed, self-contained sections.

The Pattern

The puzzle pieces approach to level generation relies on pre-designed modules that are combined according to local constraints: Modules boundaries are labelled with a “connection type”, and like puzzle pieces, only modules with compatible connection labels can fit together. For example, a module with an road exiting to the right can be placed to the left of a module with an road to the right, so the roads will connect.

I made these literal “puzzle pieces” (based on the platformer tileset “Candy Land” by MadByte from opengameart.org) to illustrate the concept further. There are three kinds of connectors I will call “cave wall“, “water“ and “open land“. Only puzzle pieces with fitting connectors can be out together.

The puzzle piece/module pattern looks similar to the “deck of cards” approach mentioned above, but instead of self-contained “rooms”, the generated level consists of open, interconnected puzzle pieces that fit together.

Boundaries between modules do not have special significance to gameplay (in the deck of cards pattern, each room must be solved individually before the player can move on), and module boundaries are not emphasised by the game. There are different kinds of connections between modules (in the deck of cards pattern, there is one kind of doorway only).

Ideally, the juxtapositions of different modules lead to different gameplay dynamics: If the main challenge of the game lies within individual modules, and the module boundaries are clearly visible, you lose the main advantage of this method, and turn the level into a sequence of a small number of disconnected sections, instead of a large space of possible combined levels. In the generated platformer level above, you can see how the two cave levels look very self-contained, while the second level, shown below here, looks much more organic.

Maze Generation

You can combine two-dimensional maze generation algorithms, on a coarser scale, with puzzle pieces. This ensures that every module in your level is reachable.

You can also pre-generate parts of the level based on a more purposeful algorithm and then fill the rest with random modules that fit into the existing connections.

Complete Tiling

If you want to make sure that you can easily tile a 2D or 3D level without complex constraint solving techniques or backtracking, you must design modules for all possible combinations of connection labels. Otherwise you can “paint yourself into a corner“ and generate “gaps“ that cannot be filled by any existing module. In the example above, there is no module that connects a “cave wall“ to a “water“ edge, but since the modules exist in only one dimension, this is not a problem.

Complete tilesets can also be combined with gradient noise to produce biomes or terrain shapes which serve as module connection types: http://www.cr31.co.uk/stagecast/wang/blob_g.html

With complete tile sets, you can start at any point and greedily, incrementally fill in tiles at any position.

Roads

If you restrict certain tile types, you can enforce global constraints by satisfying local connection constraints. For example, on a 2D rectangular tile grid, if you only allow tiles with one road entry and one road exit (i.e. no crossings, T-junctions or dead ends), then every consistent tiling consists of only loops. If you start with only two dead ends and fill the edges of the map with non-road tiles, and only use the tiles mentioned above, the two dead ends are guaranteed to be connected in every solution.

Games

Spelunky lays out a path for the player to follow, similar to the solve-then-generate method, and populates that path with connected modules that form a corridor to the exit. The other modules may or may not be connected to the rest of the level, and can sometimes only be accessed by spending bombs or ropes. Modules are further customised by adding traps, loot and monsters. (http://makegames.tumblr.com/post/4061040007/the-full-spelunky-on-spelunky)

Torchlight I&II (https://www.runicgames.com/blog/2011/05/20/making-the-world-of-torchlight-ii/)

Eldritch starts by generating a maze in 3D. Then the generator removes some maze walls, and populates the resulting grid with predesigned modules. (http://www.gdcvault.com/play/1022110/Level-Design-in-a-Day)

Aesthetics

Map generation based on puzzle piece modules allows the game designer to exert a high amount of control over the generated maps. Maps can be varied, challenging, and unpredictable, while requiring only a moderate amount of pre-designed content.

Puzzle-piece-based levels can guide the player along a path, but still feel open, organic and non-linear. By obscuring module boundaries, e.g. by not always putting walls at module boundaries, or loot dead in the center, we can draw attention away from the generation algorithm and toward the scale at which gameplay is happening.

In my previous post I have explained the terms ontogenetic (top-down, feature-based) and teleological (bottom-up, simulationist) procedural generation.

I have argued that in most cases, the additional effort both in terms of programming or balancing the initial state of the simulation and in terms of computation time spent on simulationist generation is not worth the gains in detail and fidelity. In any case, an equal amount of effort could be spent on adding detail to a feature-based generator.

Two main differences set stories apart from other kinds of generated content: Narrative economy and the causal, temporal nature of storytelling. While narrative economy works in favour of a top-down feature-based approach to storytelling, the temporal and causal nature of stories favour simulationism.

Stories in Time

In artifacts like level maps, the product of a simulation-based generator is only the result of the final simulation step, and each state depends only on the immediately previous one. Stories don’t work like that: They unfold over time, and step by step follow a chain of connected events. If the main attraction of a story were its outcome, readers would always skip to the ending of books, and writers would not need to bother writing the parts before that.

Each simulation step moves the story forward. Because of that, intermediate simulation steps can be tremendously useful to storytelling. Story generators can generate a story by simulating step by step the world of a story, and describing what happened.

Two early story generation systems relied on a rather simulation-driven approach:

Michael Lebowitz’ 1984 UNIVERSE system for storytelling uses the same simulation algorithm both for character generation and storytelling: UNIVERSE generates interesting soap-opera-style storylines based around the interrelations of an ensemble cast. The two main goals of UNIVERSE are consistency and coherence in the generated stories. Consistency means that the stories and characters are free from internal contradiction, and coherence means that story events don’t just happen at random, or for no discernible reason, but arise from previously established facts in the story. Through simulated interactions between characters, they acquire shared histories and motives that motivate and explain their later behaviour in the story.

The TALE-SPIN system by James Meehan  (1977) generated fable-like stories about animals living together in a forest. While the system used planning or constraint-solving algorithms to generate character actions, these plans were not driven by narrative concerns, but by the goals and knowledge state of the respective characters. Characters could be wrong in their beliefs about the world, or take actions to get more information about known unknowns.

Narrative Economy

You almost never see people going to the bathroom in movies -  with some notable exceptions like Pulp Fiction, in which major plot events happen while Vincent Vega is sitting on a toilet - and if you see somebody doing a mundane action like eating breakfast, going to bed, or reading the newspaper, it either serves as a backdrop for a more interesting plot point, or as a set-up for later events - for example a busy family eating breakfast together gives an opportunity to put all the characters together at a table and introduce them, or explain why the lot of them were together when the main plot started to unfold.

Even though most stories, be they movies, books or told in other forms, do not directly depict or mention such mundane events, it is usually implied that they still happen. Characters still need to eat, sleep, and do their taxes. In accordance with to the Gricean Maxims, stories only communicate to the audience only that which the audience does not already know or assume to be the case. On top of that, stories focus on topics and events that are unlikely, unusual, novel, or just generally interesting in some way.

Creating Drama

If a storytelling system wants to emphasize novel and unusual events, it must first generate such events, so it can talk about them. The need to create interesting situations is at odds with fine-grained simulation, consistency and coherence, as most events in an iterated simulation are not very interesting by virtue of occurring regularly.

A storytelling system should start and end the story in a way that allows the central conflict to develop and be resolved. It should not include long passages of exposition or childhood events of the protagonist, and it should end the story soon after the conflict is resolved. The story should follow a dramatic arc.

A simulation-based storytelling system can exercise some amount of narrative economy by omitting mundane events that occur inside the simulation from the generated story text, and focusing on the more interesting parts. Alternatively, the system can bias random chance events and character decisions towards more interesting outcomes, within the bounds of coherence and consistency. This is also the approach taken by UNIVERSE.

TALE-SPIN more or less failed at narrative economy, often producing rather repetitive stories about animals trying, and failing at, multiple successive strategies to find food. Although the world of TALE-SPIN models animals with  mundane goals like finding food, it is capable of simulating theory of mind, competition and social interaction in pursuit of these goals. Unfortunately, TALE-SPIN does not include these details in the story text. Thus, a situation that could have been described as “Henry the hare knew that Brian the bear was fishing for salmon at the river, but Brian had a mean streak and was not to be trusted. Henry decided to seek out Olly the owl on the hill for advice instead.“ simply becomes “Henry went up the hill“.

 Top-Down Drama Generation

Feature-based story generation systems like William Wallace Cook’s Plotto, outlined in his 1926 book of the same name, maintain narrative economy, create a story arc, and focus on an interesting subject matter through top-down design. For example, Plotto contains the following situation:

A, poor, is in love with wealthy and aristocratic B * A, poor, in love with wealthy B, pretends to be a man of wealth

This situation sounds by itself at least a little interesting and noteworthy. Each of these plot points fits into an overall structure of a central conflict, and can be combined with other conflicts that have preceded or been caused by it. The Plotto book has a table of central conflicts, protagonists and plot points, and rules for how to combine them.

Since Plotto was a book intended for novelists and screenwriters, and not a computer program, it was the end user’s task to write the actual text of the novel, stage- or screenplay. Eventual inconsistencies could always be caught and corrected by a human editor. Likewise, the balance of detail against narrative economy is in the hands of a human author.

The MINSTREL system tries to follow a high-level plot outline by fleshing out the structure with adapted events from a library of previous stories. By drawing upon events from previous stories, it retains the level of drama of the story corpus, but sacrifices consistency and coherence: Story elements are not causally connected in an underlying simulated model. Instead, they are retrieved and adapted by an analogical process, based on superficial similarity.

Conclusion

Although top-down procedural generation is often better suited for level generation, bottom-up simulation is well suited to generate stories. Detailed simulation can produce stories that make sense: They are internally consistent, and no story development feels out of place. Feature-based or top-down methods can build dramatic arcs, but rely on user-supplied plot structure.

If you want to generate compelling stories with a bottom-up simulation approach, you need a model of the reader, a model of dramatic tension, or a way to enforce a plot structure, in addition to a model of the world your story is set in.

Links:

http://wikis.sub.uni-hamburg.de/lhn/index.php/Story_Generator_Algorithms

Gricean Maxims: https://en.wikipedia.org/wiki/Cooperative_principle

Tale-Spin: https://grandtextauto.soe.ucsc.edu/2006/09/13/the-story-of-meehans-tale-spin/

More on Tale-Spin: http://blog.kenperlin.com/?p=2068

Universe: https://grandtextauto.soe.ucsc.edu/2008/03/05/ep-72-universe/

Plotto: https://www.brainpickings.org/2012/01/06/plotto/, http://www.npr.org/2012/02/19/146941343/plotto-an-algebra-book-for-fiction-writing, http://prosecco-network.eu/blog/generating-new-stories-plotto

Minstrel: https://games.soe.ucsc.edu/sites/default/files/lessons_learned_from_RR_of_M-AAAI2012.pdf

Tropes Discussed: http://tvtropes.org/pmwiki/pmwiki.php/Main/NarrativeFiligree, http://tvtropes.org/pmwiki/pmwiki.php/Main/TheLawOfConservationOfDetail, http://tvtropes.org/pmwiki/pmwiki.php/Main/NobodyPoops, http://tvtropes.org/pmwiki/pmwiki.php/Main/Asspull

One of the most confusing terminology conventions in game development is the distinction between “ontogenetic“ and “teleological“ generation. It is the other way round than you would think, based on some historic accident. If you hear the explanation for the names, it will make some sense, but you might still get it wrong the next time.

Feature-Based Generation

also known as:

• Ontogenetic (in the PCG Wiki)
  
• Top-Down (coined by Amit Patel of Red Blob Games)

Feature-based generation generates instances of concepts based on player-facing characteristics.

For example, if you want to generate a height map, you can start with a flat world and directly add features like mountain ranges, ravines, valleys, and rivers. This is what many games do to create terrain.

To generate a story, you can generate story features or plot points like a protagonist, a nemesis, a love interest, the hero’s goal, and a third act twist.

To generate a swing tune, you generate swing rhythm (drums), take a melody for saxophone, write a walking bassline according to the constraints of he melody to be played on the double bass, and create a piano accompaniment based on genre-typical chord progressions.

All procedural generation patterns previously mentioned in this blog, especially drawing cards from a deck, infinite landscape, and inverse puzzle generation, fall under the category of top-down procedural generation. In general, most constructive, combinatorial/grammer-based, noise functions or constraint-based procedural generation techniques are in top-down category.

Examples:

• Minecraft
• Spelunky
• Sunless Sea
  
• NetHack

Simulation-Based Generation

also known as:

• Teleological (in the PCG Wiki)
  
• Bottom-Up (coined by Amit Patel of Red Blob Games)

Simulation-based generation generates instances of concepts by simulating the process that creates these things in the real world.

If you want to generate a height map in the simulation-based way, you can simulate plate tectonics, volcanic eruptions and lava flow, rain and erosion.

To write a story the simulation-based way, you can create a bunch of characters, give each of them their own goals and problems to overcome, and simulate the actions they would take to reach their goals.

If you want to write music, the simulation-based approach falls flat. There is no simple, naturally occurring mechanism that reliably produces music.

Examples:

• Dwarf Fortress
  
• Universe, a soap opera story generation system built for research (http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.956.3501)
• Tale-Spin, an earlier research project that generates fable-like stores about animals in a forest (http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.74.173)
  
• World Engine (http://world-engine.org, picture related)
  

Comparison

Adapting the generator

Feature-Based generation is fast and allows the designer a large amount of control over the result. If you want more mountains in your game, or higher mountains, or to space your mountains farther apart, you can just do that.

Simulation-Based generators are comparatively harder to tweak. Although there might be a way to change the starting conditions of plate tectonics so that mountains are higher, it is not always obvious which parameter should be changed, and if that change has other, unintended consequences.

Naturalism

If you want landscapes too look natural, you can use a simulation-based algorithm to describe these natural processes: If you don’t know how to describe the distribution of tree species or the shape of a forest canopy, you can just simulate the growth of a forest: Trees grow more when they get more sun, trees grow toward the sun, trees produce seeds that usually don’t travel far away, taller and more exposed trees are more susceptible to wind and lightning.

On the other hand, you could just put beeches together in a forest, birches at the edges, cluster aspen together, and put oak trees on open fields. Then you jiggle the tree models so that their 3D models don’t intersect and you will get something that looks like a forest.

Computation Time

Simulation processes often take several order of magnitude longer than top-down generation of objects based on similar representations. Putting tall grass on tiles of a map with a certain random chance is quite fast, but simulating plant growth on a map might require you to iterate over all tiles of a map thousands of times. You can quickly build paths that connect buildings, or simulate how people would walk from house to house and trample down grass.

Feature-based generation is almost always faster.

Constraints

Feature-based algorithms can be designed to incrementally build something that satisfies a constraint (e.g. reachability, winnability, recoverability) by starting from a simple base that satisfies this constraint and then iteratively adding features so that the constraint is preserved. For example, a dungeon generator that produced fully connected dungeons can start with a single room, and iteratively add more rooms, connecting each room with the existing dungeon. A generator could employ a constraint solver that ensures that a level is always beatable, or use a mixed approach that by first satisfying the constraints (inverse puzzle generation) and then adapting the content in a constraint-preserving manner.

Simulation-based systems can sometimes iteratively satisfy constraints in a manner similar to dynamic programming: By locally, iteratively satisfying certain constraints. Usually, however, simulations will not satisfy global constraints.

When to Simulate

Available Game Mechanics: When your game mechanics already simulate water flow, plant growth, or similar processes, you can simulate these systems for a couple of cycles to populate the level.

Complicated Emergence: When the process that creates the thing you want to generate is simple and straightforward to describe, but the outcome is harder to describe. Sometimes, you don’t even know what properties a generated instance should have, but by copying the process that creates it in the real world, you can get many of the emergent properties fro free!

When to Model Features

Fine-grained Control: If you want to tweak your generator to create different versions of a concept, to produce different levels difficulty, to put more or less of a resource in certain locations, you should use feature-based generation.

Extra-Diegetic Constraints: If your generator should produce assets that satisfy a single, global constraint, like solvable puzzles, you should write a top-down generator with that constraint in mind.

Human-Made Objects: Human-made artifacts are usually designed and crafted in a top-down manner anyway, so any simulation of the process that designs clothing, music, tools, or houses would be a simulation of a top-down design process anyway.

On-Demand Generation: Since simulation-based algorithms take longer  than incremental, feature-based algorithms. Simulation-based incremental generation of terrain can lead to weird artifacts at chunk boundaries.

http://pcg.wikidot.com/pcg-algorithm:teleological-vs-ontogenetic

http://simblob.blogspot.de/2010/06/teleological-vs-ontogenetic-map.html

A multi-player game idea for 5 to 10 players, based on our Ludum Dare entry Nessie: Quest for Fame.

In the jam game, your objective was to become Internet famous as Nessie, by having tourists take photos of you, without getting caught by Jacques Cousteau and losing all your mystery. In the multi-player version, the roles of the tourists and Jacques Cousteau are also played by humans.

One player plays as Nessie, one plays as Jacques Cousteau, the rest play as tourists. Tourists can take pictures of Nessie and upload them to an in-game “twitter clone”, where every player can see the pictures taken by the others.

When a tourist takes a picture of Nessie, he gets two points and Nessie gets one. After Nessie had her picture taken, she is on a cooldown timer for twenty-five seconds, during which she cannot gain points. Tourists move slowly and must stay on dry land, or use bridges and ferries to move across the lake. Tourists have name tags floating over their heads. After a tourist has taken a photo, he cannot gain points for another ten seconds. Nessie usually moves just slightly faster than the tourists, but can “sprint” underwater for a limited time.

Cousteau can see all photos shared by the tourists. Cousteau accelerates quickly, and moves faster than Nessie at her slow speed, but much slower than her sprinting. If Cousteau comes clone enough to Nessie to tag her with a tracking beacon, only he gains ten points and wins the round. If Cousteau wins, the other players don’t gain the points they scored by taking photos in this round. If no tourist takes a photo of Nessie, Cousteau gets three points and wins the round.

If Nessie gets to (3n-1) points, where n is the number of tourists, she gets another (n+1) bonus points for winning the round. If a tourist gets to ten points, he wins the round and becomes Nessie in the next round, and Nessie becomes Cousteau.

If Nessie wins the round, she stays as Nessie, and the tourist with the most points becomes Cousteau.

If Cousteau wins the round, he becomes Nessie, and the tourist with the most points becomes Cousteau in the nest round.

The first player to gain 65 points wins.

1 pixel should be around 2.5-3 m in-game

Nessie is not drawn to scale, should be around 5-8m

Genre: RPG Parody, Management Simulation

You are the mayor of a small town with a church, a town hall, a blacksmith, and many farmers. You can build more farms, trade produce for gold, explore the forest, expand the town, and build fortifications. You can build advanced facilities like a library or a tavern, and mine ores and minerals for advances crafting.
Unfortunately, you can’t defend yourself from the wolves, rats, gnomes, trolls and orcs that live in the magical forest your town is surrounded by.

That’s where the travelling adventurers come in! You can’t really control them, but you can create quests like “Kill five wolves and bring me their pelts!” and reward successful adventurers with gold and rare weapons. You can let them stay in a tavern in return for solved quests, and give them weapons that will complement their build and make them more effective. If you give too dangerous quests to unexpected adventurers, they will die. If you give hard quests for limited reward, adventurers will be less likely to come. Adventurers will demand a higher reward if quests have proven dangerous in the past. On the plus side, if an adventurer dies after finishing 80% of the quest, you don’t have to pay him.

Once an area has been cleared, you can build fortifications and garrison a night watch and militia, but guards will not venture out of fortified areas. Deep woods, mountains and swamps cannot be fortified.

You must expand your town by giving quests!

Winning Condition: Kill the Evil Necromancer/Grow your town/Build a cathedral

Losing Condition: Get overrun by wolves

This pattern is so ubiquitous that I almost overlooked it. Many Roguelike-like games use different level generation algorithms for different levels. Games that follow the “Deck of Cards“ procedural generation formula (Enter the Gungeon, Isaac, A Wizard’s Lizard) employ different design principles for the “cards“ on each level.

Nuclear Throne:

1. Desert: Open areas connected by bottlenecks, many slow enemies
2. Sewers: Narrow corridors, charging enemies
3. Scrapyard: Open areas connected by corridors, ranged enemies
4. …

Spelunky:

1. Mines: Ladders, some enemies, closed spaces, horizontal layout
   
2. Jungle: More difficult traps/enemies, pools of water, horizontal layout
   
3. Ice Caves: Floating islands, open space
4. …

In Terraria, you have to solve tasks and fight bosses in different biomes in a fixed order. Different biomes follow different layouts/generation algorithms. This can be most clearly seen in boss areas like the Crimson, which is connected to the surface, The Dungeon with its long vertical tunnels connecting a complex network of corridors, and the Jungle Temple, which has a single serpentine path with long horizontal stretches from the entrance to the Boss fight.

The progression of level generators serves multiple purposes:

1. It breaks up the monotony and serves as a marker of progress, as further areas look so different from where you started. Because of differently shaped space, the game feel also feels different.
   
2. It gives different enemies/puzzles time to shine. Certain enemies would be too easy or too hard in narrow tunnels, or vice versa.
3. It prevents weird looking terrain and interactions between extreme conditions.
4. It groups enemies, terrain and set pieces together thematically.
5. It gives you time to prepare for later, harder levels.
   

Gamification - The Skinner Box

Gamification is not actually a way to make games, but a method of adding certain game mechanics to non-game systems. Points, levels, achievements, random loot or in-game currency are often adapted to gamify a task with positive reinforcement. These are commonly found in role-playing games, where they can add an element of progression and growth to an otherwise story-driven game with little room for player learning and skill improvement.

Every time a player interacts with the system in a “good“ way, he gets rewarded with a small amount of score points. More important or more difficult tasks result in more points. Level-up events at score milestones ensure that the score does not become a meaningless number - Getting to “Level 30 (Awesome Wizard)“ feels much more satisfying than just gaining the 10 points that push the score of the threshold.

Social features like customizable avatars, public profiles and friend referral bonuses can create peer pressure to provide additional incentive to gain more points, and help spread the gamified systems spread “virally” through a circle of friends.

Energy systems or similar rewards for continued usage of the system and regular completion of tasks drive long-term user engagement and retention. For example, users can get bonus points or achievements for interacting with the system or completing a task every day for a week. Alternatively, users could receive bonus points for completing the first task of a new day, which incentivises them to use the system daily, and habituates them to integrate it into their daily routine.

Gamification reinforces good behaviour.

Mechanics as Metaphor - Framing and Emotion

Mechanics-as-Metaphor game design makes the gameplay a conceptual metaphor for a certain topic. Instead of pushing the player to behave a certain way, it makes him experience the topic from a certain point.

The mechanics becomes the source domain of this conceptual metaphor, this way the player can transfer his experiences playing the game to the target domain, the underlying topic. The player character is deliberately chosen to create feelings about the game world that survive the transfer to the target domain.

Conceptual metaphors usually use basic and well-understood concepts like cardinal directions, containers, plants and fights as source domains to explain more abstract target domains like career, love or arguments. The source domains have a strong embodied component, but in addition to immediate physical experience, cultural factors may shape our mental models too (see “Metaphors We Live By” by Lakoff and Johnson, page 57).

Game mechanics are often based in the same easily grasped domains. Even if the in-game entities are abstract shapes without cultural significance, their interplay a) elicits an emotional response and b) is easy to understand. The contextualisation of the game mechanics - the game’s theme or framing - also provides context for the emotional response.

In order to play the game, players have to adopt the game’s framing. They must think of the game’s goal as their own goal, and view entities that impede their progress towards that goal as enemies, at least while they play the game. Players who reject the game’s framing, or draw conclusions contrary to the game’s message might not even lose the game, but just stop playing.

Mechanics-as-Metaphor lets players experience a point-of-view.

http://www.necessarygames.com/my-games/loneliness/flash

http://rodvik.com/rodgames/marriage.html

http://www.digra.org/wp-content/uploads/digital-library/06276.36533.pdf

Simulation - Insight into Models

The techniques for persuasive games described above can be uncharitably described as exploiting implementation details in our brains: operant conditioning, habituation, basic emotions.

Simulation Games can make a point through reason and logic. If they clearly state their assumptions (or axioms and inference rules), players can start a simulation in a state they agree with and let the simulation work out the implications.

For example, in SimCity unemployment increases crime and decreases tax revenue, increased police spending decreases crime, and lower taxes increase employment. Under the right conditions, a city can flourish with a low tax rate, low unemployment and low police spending. An unexpected economic crisis - in SimCity, this could be represented by Godzilla destroying the commercial district of the city - can create situations that require increased police spending, and thus higher taxes, leading to even more unemployment.

SimCity does not allow players to build residential homes, shopping malls or factories directly, instead they can allocate residential, commercial or industrial areas. If they allocate too much, residents will live in sparsely populated residential areas, wasting infrastructure. Infrastructure like roads, power lines and police stations can only cover a small area.

The assumptions behind SimCity are straightforward: Players can use SimCity to examine problems issues emerging from these assumptions like recessions and urban sprawl.

The “Parable of the Polygons“ also simulates cities. It is an interactive implementation oh Thomas Schelling’s work on segregation. Individual residents can move if they don’t like their neighbors. The simulation shows that segregated neighborhoods can result from the aggregation of individual preferences, without any institutional discrimination.

If players don’t agree with the axioms of the simulation - if the rules are incomplete or even contrary to their experience - they will not accept the conclusions. But if they do, they can see the results for themselves, and seeing is believing.

Simulation shows how a situation would play out and lets players explore strategies

Open Source SimCity: https://github.com/SimHacker/micropolis

Parable of the Polygons: http://ncase.me/polygons/

http://www.gamesforchange.org/play/september-12th-a-toy-world/

Unlike a level generator, which runs once before the level starts, an AI director runs all continuously while the player is inside it and playing. The A.I. director tries to fill an existing level with challenges and sometimes gives aid to the player to keep the difficulty (or tension, drama, excitement) at an even pace.

Like a stage director, the director is unseen behind the scenes, and puts actors and props on stage. The director is mainly concerned with the player’s experience, it usually focuses on the part of the level the player is currently occupying. Players can’t see the places where they are not, so they can still get the impression of an expansive, populated level.

Examples

A simple director, like the one in Risk of Rain by Hopoo Games, places enemies into a level near the player according to simple rules. While the overall difficulty level rises continuously, it spawns groups of monsters at regular intervals, based on the current difficulty budget. http://riskofrain.wikia.com/wiki/Enemies_%26_Bosses#The_Director

In this Risk of Rain screenshot, you can see a Boss (the big one), elite monsters (in orange any yellow), and regular monsters (like the bluish-grey Rock Golem on the far right). When it can afford the difficulty budget, the director will prefer spawning elite monsters over regular monsters. Bigger monsters like Rock Golems cost more difficulty points, so waves of tough monsters will be smaller in number to compensate.

More complex instances of directors try to put the player in a certain emotional state: They can use the player state (e.g. health, ammunition, inventory), progress or movement speed and a history of recent emotional events (e.g. taking damage, dealing damage, picking up loot) to estimate the current emotional state and create a situation that will lead to the desired emotional response. Left 4 Dead, a survival action game by Valve Software, had popularized the term “AI Director”. The L4D director does not continuously keep the pressure level to create a flow-like state. Instead, it holds off on spawning waves of enemies until the situation is under control, creating cycles of anticipation, excitement, action, victory and relaxation. http://www.valvesoftware.com/publications/2009/ai_systems_of_l4_mike_booth.pdf

The Level Generator of Cloudberry Kingdom by Pwnee Studios has been described as an AI director, but is at most an edge case. It has an adaptive difficulty and a model of what makes a platformer level interesting: Rhythm, Variety and Challenge. Yet the level generator does not interact with the player or game state once the level is generated. http://www.gamasutra.com/view/feature/170049/how_to_make_insane_procedural_.php

Rimworld by Ludeon Studios is a construction and management simulation game set on a colony in space. It focuses on detailed simulation and the relationships between the colonists. It is like a mixture of “The Sims“ and “Don’t Starve“.

The “Storyteller” can at any time start a scripted event like a supply drop, an alien attack or the visit of a traveling merchant. Different storytellers exist to support different play styles: One provides a slow ramp-up in challenge in drama, one mostly leaves the player alone, and one creates mostly randomly both good and bad events.

The storytellers take the state of the colony, most importantly the number of colonists, into account when choosing events to trigger. They aim to not wipe out the colony completely, but to make expansion past a certain point harder, and keep the colony at the size that works best with the game: Too many colonists, and the player loses track of their characters and interpersonal drama.

http://rimworldwiki.com/wiki/AI_Storytellers

Further Reading: Drama through Gameplay

MDA

http://www.cs.northwestern.edu/~hunicke/MDA.pdf

TL;DR: Game mechanics (rules and goals) create through their interactions dynamics (strategies and incentives) which in turn lead to the aesthetics (how you feel during play).

Player Story

http://hitboxteam.com/designing-game-narrative

TL;DR: What players remember as the story of a game is not only the “story“ in the cut scenes, but also the story of their own gameplay.

Eskil Steenberg’s Pivot Model

http://news.quelsolaar.com/#post90

https://www.youtube.com/watch?v=5Jb6Ecj7t8U

TL;DR: Drama happens when game dynamics change.

Flow

https://en.wikipedia.org/wiki/Flow_(psychology)

TL;DR: You stay in the zone when the thing your doing is easy enough so you don’t get stuck, but hard enough so it won’t get boring.

The Pattern

The AI director is a system that runs in the background and influences the game state at runtime. The director does not directly interact with the player. The director creates items, enemies, weather conditions, or events like earthquakes and surprise visits from relatives. The director has the task to keep the game interesting and to put the player into a certain emotional state. The director aims to keep the game in the “interesting” part of the state space.

An A.I. director provides the aesthetics of Narrative and Challenge.

Procedurally generated levels may differ wildly in difficulty. Parts of a level could be easily traversable, while some choke points require careful maneuvering. Extreme formations are nice to look at from far away, but hard to get through. Cliffs, trap doors or jump pads are traversable in only one direction.

If you give the player a way to knock down walls, dig tunnels or build bridges, your terrain generation can be more “realistic“ (or earth-like, simulationist, bottom-up), but still solvable.

In Spelunky, terrain that is in the way can be destroyed with bombs, and holes in the terrain can be climbed over with ropes. Both bombs and ropes are very scarce resources. Most levels can be completed without spending bombs or ropes, but bombs can clear the ways to additional items and treasure, or destroy traps and enemies.

In Minecraft, only the surface of the world is accessible, and the primary mechanic is destroying and placing the blocks that make up the terrain. The resources you need to build pickaxes are abundant. Most of the resources are buried in the ground. You can dig your way everywhere, but you may want to explore existing caverns because that’s a faster way of discovering resources than digging.

In Worms Armageddon, most weapons will destroy the terrain, but you can use your turn to dig tunnels or to build roofs and bridges.

Other games may have resources like smart bombs (to clear the screen and give some breathing room during a wave of enemies) or invincibility potions to give the player an option when they are in a tight spot, but bombs in Spelunky turn the awkwardness of the level generator into a Game Mechanic!