Procedural Plate Tectonics

Last time we covered noisy layering in order to make biomes. This was done relatively arbitrarily though and we saw weird biomes like tundras being in the middle of deserts. This is obviously something we don't want to happen so we need to make a better procedural algorithm to make biomes.

I've decided to take this whole thing a step further. Instead of using simplex noise to determine heights like we did last time, we're going to procedurally make plate tectonics. To those of you who don't remember 9th grad science, the Earths out shell is made of a serious of plates that move very very slowly. However, over millions of years this movement causes many landforms that we know today, like mountains! In theory, procedurally generating some plates and then simulating their movement could generate very interesting and realistic landmasses. 

So how do we go about generating plates? Well I thought of two different methods that could work. The first one is slightly more complicated. For this, we choose an arbitrary number of plates and a starting point. From there a neighboring block is chosen and added to the plate. This is then looped through all the plates until there are no more empty spaces. Let's take a look at the code quickly.

We can see from the code that we first keep track of all the empty spaces, then choose random distinct starting points for reach plate. Then we loop through each plate, get a random neighbor and try to add it to the plate list. This process is pretty slow and these take a while to generate. However, once it finishes and we colorize each plate, we get an image like the one below.

I had really high expectations for this algorithm to work and I was less than pleased with the results. We can see we get very long plates like the light-blue in the middle. I was hoping for a more "blobby" plate like actual Earth plates. While I'm sure this method could be modified to give more desirable results, it's still pretty slow so I decided a new approach.

Attempt two took a slightly different but similar approach. First I choose an arbitrary number of points to be the plate "centers." From there, I checked every point on the graph and colorized it based on the closest "tectonic center." The code for this is drastically easier to understand.

As you can see it's actually quite simple to do this. Just some simple loops and checking. ( It should be noted that this is NOT the best way to do this by any means. This is a brute force method. There are much better algorithms like Fortune's Algorithm that do this much faster than me. ) What this generates is called a Voronoi diagram where each point is colored based on its closest reference point.

When we run this we get a picture like below.

While this looks interesting, I'm still not 100% happy with how it will work for plates. For one, looking at a real map of plates, they do not have such straight lines. These are "blobbier" though which I am happy about.

Turns out making procedural plates is harder than I thought it would be. I may re-visit this or go with the Voronoi diagram, I've not decided yet. Either way, we will be combining this with many other procedural algorithms so this is just a starting place. We still have a long way to go!

As usual the code can be found here. Thanks for reading.

Noise Layering

Now that we've covered a variety of different noise algorithms, we can start to actually put them to use. Noise algorithms can be used for a large variety of things and many noise algorithms with different seed can be used with one another to give interesting designs.

This is what we will be doing today. We are going to use 3 simplex noise algorithms, all with different seeds, to create a "world" with different biomes. These 3 noise algorithms will be a heightmap, a heatmap, and a rainfall map. The heightmap will determine 1 of 5 possible options. Lake, beach, biome, mountain, or snow-topped mountain. 

If the heightmap makes it a biome, we need to determine the different biomes based on the heat and rainfall at a select point. This is where the image below comes into play.

We can see on this image that the amount of rain and the temperature determine what the biome is. It gives us 10 possible biomes to choose from and each biome corresponds to a specific color in our final image.

Let's take a look at how this is actually done.

We can see that this part is quite simple. We supply a width and a height and every point on there we get the simplex noise 3 times. One for height, one for wetness, and the last for temperature. We then call the method GeneratePoint with the 3 values returned and this is what makes the biome colors. Let's take a look at that method.

GeneratePoint is quite a simple method as you can see. We first check the height to make one of our 5 possible height options. Then we use the wetness and temperature to make the biomes their own unique colors.

Below you can see an example output of what our algorithm created.

This is our biome map! It is by no means perfect, or even accurate to how the real world works but it shows how we can use noise layering to create new and interesting outputs!

The method we use here, however, is completely random, which makes for some strange results. For example there's "tundra" biomes ( turquoise color ) in the middle of a "desert" biome ( orange-ish - yellow color ). This should never happen in real life but because of the randomness of this it does.

This is actually similar ( albeit much less complex ) to how some games like Minecraft generate their worlds, so hopefully this gives some insight into that.

This method obviously needs some improvements and we will work on it in future variations. But in the meantime I hope you learned something. As usual the code is on GitHub here.