This post is the second in our series on procedural generation in game design. The first post covered how game developers need to make judgement calls, using lessons from Failbetter Games Sunless Seas Sunless Skies as examples. In this post we look to elaborate on some takeaways using another example.
In 2016, indie studio Hello Games launched their game “No Man’s Sky.” Media coverage was tremendous. Sony Interactive Entertainment helped to promote and publish the game, and expectations were high. The promise was that the player would travel a universe consisting of no less than 18 quintillion (that’s 18 zeros!) planets—all of which are procedurally generated real-time only when the player visits them! Some who still knew the classic 1984 science-fiction exploration game “Elite” or one of its successors were thrilled by the thought of playing a game that is even vaster and more immersive—and all of this with up-to-date graphics and gameplay.
When the first version of the game came out, excitement soon changed to disappointment, although some praised the game for its technical achievements. Yes, you could travel a virtually unlimited number of planets with plenty flora and fauna. But there was a problem: users felt that these planets looked similar and the gameplay was repetitive. One user wrote on a No Man’s Sky discussion board on July 31, 2018: “I have seen quite a few planets now in the starting galaxy Euclid and they really get boring after a while because the procedural generation is quite the same all the time” (link).
What Went Wrong?
Before I continue I would like to mention that the game went through an evolution by means of multiple updates that included adding a multiplayer component, improving on the graphics (the actual algorithms for procedural generation were improved), changing the user interface, adding a VR option, and some other things—which led the game to indeed get much more favorable reviews. But let’s now look at what happened with the original release.
While there were a number of issues with the original release (including that features were missing that had been announced to be part of the game), it seems that the uniformity of the game content and the repetitive experience were a core problem. In this blog I thus want to look at one of the key challenges involved in using procedural tools (or, what I broadly understand to be “autonomous design tools”)—the tension between the danger of producing boring repetitive design on the one hand, and the promise of generating potentially creative content at unprecedented scale and speed on the other.
On the one hand, these tools are deterministic systems—they are algorithms whose output depends on the input they receive. Albeit, No Man’s Sky’s game space (those quintillions of planets) is created at run-time, it is still deterministic. This determinism even holds true for approaches that have the word “random” in them (like pseudo random number generation, which, not coincidentally, also has the word “pseudo” in it). However, some of these systems provide output based on a variety of input variables that cannot possibly anticipated by human designers—their outcomes are complex to the extent that humans may thus indeed perceive them as “creative.” Moreover, they do so at unprecedented scale and speed. No human could handcraft 18 quintillion planets!
So—how do developers handle this tension? Through our research we have identified a number of strategies designers use to navigate this tension. One category of such strategies is what we call “architectural structuring.”
The key is that using procedural tools is always in relation to fundamental, broad architectural choices designers and game architects make. Good games are not only creative, but there are other important aspects such as their gameplay stability (e.g., you don’t want a game to be an entirely different game every time you restart it) and overall playability. Here are some key design strategies:
- Structuring for coherence: While players want variety in content, they still don’t want widely differing experiences each time the play. Structuring for coherence thus means to define rules that create a sense of consistency. The key outcome of this design strategy is to combine content variety with consistent user experiences. For instance, in a game called “Sunless Sea,” worlds are generated that allow users to become experienced in playing the game over time. This would not be possible if there was no coherence from one instance of playing the game to another.
- Structuring for procedural completion: In many games, there is a manually crafted basis, or structure, of the game world, and procedural generation helps to complete the design (which effectively can mean that most of the actual content is procedurally generated). A key outcome of this design strategy is thus to allow for much greater magnitude of the work and also improved efficiency of the creative talent involved. In Star Citizen, for instance, broad areas (up to the level of planets) are defined and then filled procedurally.
- Structuring for navigating granularity: Designers may manually design different elements of the game environment at different levels of abstraction—tools then fill in the gaps. The key outcome of this design strategy is—in alignment with that of “structuring for procedural completion”—to scale the magnitude of work and offer greater efficiency to creative talent. However, here the focus is also on adding more flexibility in designing general (more abstract) and more specific game elements. In Star Citizen, for instance, the map architecture (i.e., the planet architecture) involves different levels of granularity.
- Structuring for novelty: This design strategy involves arranging different modular operators and interfaces in such way that the tool maintains clear limits (we want output that follows certain rules), but also allows for variety in user experience. The key outcome is thus more novelty in procedurally generated content. In Sunless Skies (the successor to Sunless Sea), for instance, the map architecture was adjusted based on the experiences from Sunless Sea in a way that fosters content variety by using a particular structure in terms of overlapping regions to foster a rich, more varied user experience.
Procedural content generation is already helping generate open worlds and unprecedented scale and with lots of variety. However, this new approach to design is not only a technical solution—understanding how designers and their specific design choices interact with these systems is fundamental. Following from this thought, another fundamental practice is “injecting variety”—when designers take whatever an autonomous design tool has generated and then do their magic. But this I will attend to in another blog.
Seidel, S., Berente, N., & Gibbs, J. (2019). Designing with Autonomous Tools: Video Games, Procedural Generation, and Creativity. Proceedings of the Fortieth Conference on Information Systems, Munich, Germany.