Discovery Scanner 1 - Creating a Galaxy with Dr Anthony Ross 

I’m very fond of behind-the-scenes looks at how generative systems work. Because of their nature, it can be hard to make definitive statements about aspects that aren’t clearly showing their structure.

So I’m quite happy that the Frontier Developments team have started doing livestreams where they talk about how the game works, particularly server-side things that you can’t observe directly in the game. Like how the galaxy generator works.

While there have been dozens of attempts to simulate galaxies (going right back to Frontier: Elite) it is harder than it looks. The sheer scale of the generator poses some surprising issues getting the math to work. To say nothing about making it look good.

The generator in Elite: Dangerous goes way beyond the rolling-on-tables approach that the original Elite pioneered. While I’m aware of some other attempts to simulate planetary formation, this is the only one I know of that made it into a finished game. (Other than, I suppose, Universe Sandbox.)

The video is a great behind-the-scenes glimpse at how the different systems interact to create a history and context for the stars, and then use that history to directly influence the planets that get created. Which is how the generator is able to come up with so many physically plausible but entirely surprising star systems.

I doubt that a human, trying to implement an expert system for generating planets would come up with quite as many interesting features in these combinations. Double-planet pairs, complex ballets of multi-star systems, moons with orbits measured in minutes: there are a lot of functional-according-to-the-simulation things floating out in space that a designer would have tossed as implausible.

That’s one of the advantages of using a simulation or something like a neural net to generate to a spec: you have the advantage of the machine being willing to try off-the-wall creative ideas without caring if they sound plausible, as long as they fall inside the constraints. The trick is to specify the metric you actually want to measure.

Procedural Generation in the Elite Series

There’s a reason why the Elite series has been a central part of the procedural generation conversation. Not just because they were early examples of its application, but because their popularity meant that people studied how they worked in great detail.

Ian Bell released the source code for the original Elite on his website (which I suspect greatly helped the game’s visibility outside of Europe). So we know exactly how Elite generated its galaxy--including its names, economies, and descriptions--which has contributed to many other procedural generators.

The Frontier Elites use a more complex generator, and studying the techniques used is illustrative of how procedural generators have developed. Where the Elite galaxy map was generated all at once, the Frontier galaxy is divided into sectors, each of which is generated from a seed and the density information from the master galaxy map texture. Sectorizing generation like this is useful if you want to extend a generator indefinitely.

The system generation in Frontier works statistically: given a random seed, it rolls metaphorical die on a number of tables, picking numbers that are within the bounds of probability. This is a common approach: Elite uses something similar for picking government types and economies, and here it’s extended to the physical characteristics of the star systems, starting with the chances for each type of star.

A few star systems are predefined, overriding part or all of the generator. This includes Earth, of course, but also the many real-world stars included in the game. Combining scripted data with procedural generation is another useful technique to remember: it’s okay if some things aren’t procedural.

The planet generator is nested within the system generator. And within that there are calls to generate stations, spaceports, and other details. Nesting generators like this is, of course, another useful technique, chaining the output of one system into the input of another.

The name generator is another significant legacy of Elite: constructing sounds from pairs of characters in a Markov-like fashion, it influenced other generators. The Frontier games extend this to naming planets and starports, using tables of name-parts similar to the functionality of the “goat soup” string that described each planet in the original Elite.

Another technical detail is the way numbers are stored. While not technically a generative problem, people do occasionally want to procedurally generate things on vastly differing scales. They inevitably run into floating point issues, because the typical way to store numbers for computation work by throwing away precision, which can easily lead to your trees drifting randomly off of your planets. The Frontier games use a custom-coded scaled word variable; today there are a number of techniques to address this so long as you are aware that it’s an issue that needs to be solved.

Statistical generation has been a common approach since at least the early days of D&D random tables, but it isn’t the only possible method. And, indeed, the fourth Elite game, Elite: Dangerous, has introduced a completely different approach to star system generation, which we’ll discuss in due course.