05-02. Search for life

This is a fun little programme that creates a universe of planets for us to explore.

Games like no Man's sky use a concept known as procedural generation to create the planets in the game.

Instead of storing all the data for the planets, instead it uses sequences of numbers to determine what the planet will be like.

And since the sequence is always the same, the same planets are generated every time the player visits them.

In the early days of video games, when computers had very little memory, this allowed vast worlds to be created using only a tiny amount of storage.

as always, we'll start with our boilerplate.

In a moment, we'll write a subprogram to probe a planet.

But first we'll start in the main programme by asking the user to enter a number for a planet.

We'll make this an integer with int and store it in a variable called planet.

As inputs are strings, we also cast this to an integer.

These aren't real catalogue numbers, just whole numbers.

Then we want a probe to send back a report of what it found on the planet.

So this will be a string identified as report, and it will be assigned to be what is returned from the subprogram probe of the planet.

Next, we want to output the report using console writeline, concatenating the text with the variable report.

Okay, now the fun part.

Let's programme the probe.

Define a subprogram staticstringprobe with the parameter of the planet number.

Here we're going to return a string which will be our report.

We need a random number generator to get a sequence of numbers, but this time we'll give it a seed, which is the number of the planet.

This means that every time we ask for a random sequence, we'll get the same set of random numbers for that planet, meaning its characteristics will not change.

We have random planets, but what's on the planet will be deterministic.

In this programme, we're going to use an array that's a set of variables, all with the same identifier.

Previously we used a list, but in this programme we won't need to add or delete items from the list.

So an array is easier.

String, open and close brackets.

We're not going to define the number of elements.

Here.

Creature is assigned to be an array containing lizards, humanoids and insects.

Next, the colours will have red, green and blue.

The characteristics will be shy, angry and docile.

This is all the data that our programme needs.

Giving values to the elements when array is declared is called enumerating the array.

Okay, Our lifeform will be a random creature from the creature array either index zero, a lizard, index one, a humanoid or index two insects.

So lifeform becomes a random integer.

Open bracket between zero and three, close bracket.

Remember, random numbers go from the bottom number but don't include the top number.

So essentially this is a number between 0 and 2 matching the indexes in the array.

We'll repeat this for the specimen, which is the colour and behaviour, which is the characteristic.

It may seem odd to be using different variable names here, but it's so the next part of our programme is easier to read and understand.

Our report will be blank until it's written.

So report becomes an empty string.

Report is then assigned to be the colour of the specimen.

So what's actually happening here is that the specimen is a random number between 0 and 2, so it becomes the element at that index from the colour array.

In other words, if specimen is one, then colour specimen is green because.

Because the numbers start at zero, we will now add that to the report.

So report is itself plus a comma and a space plus the random characteristic.

We'll do the same for the type of creature.

And finally we'll finish the sentence we've created in the variable report with on the planet, so it makes sense.

The report can now be returned back to the main programme.

So let's break this down.

Planet is a number that the user can choose.

This is used as the seed for the random number generator.

So we always get the same random sequence for the chosen planet.

We generate three random numbers between 0 and 2 representing the creature, the colour and the characteristic.

We use these numbers to look up the text data, in the creature colour and characteristic arrays.

We join all this together into a single sentence.

Let's give the programme a run.

Planet 34 has green docile insects.

But if we run the programme again, we can see that planet 34 still has green docile insects, even though we never stored the data about a planet.

Probes find red shy humanoids on Planet 36.

There's another important computing concept here.

Our planets are just numbers and our creatures and their characteristics are ultimately just numbers too, from the deterministic sequence, or what is known as procedural generation in the games industry.

So the only thing that really mattered was the numbers and what they corresponded to in the arrays.

Nothing else about our universe was important.

Planets just exist.

They don't orbit, they don't have suns, there's no solar systems.

In fact, they're not planets at all, really.

This is known as abstraction, only including the necessary details and, leaving out the unnecessary details when solving a problem.