Hi,
It came to my attention that terrain generation was a hot topic at the moment in the development of Thrive, and that the developers are still considering options on how to do it.
Since I’ve been dabbling with it myself, I wanted to share some code I made for my own projects. It’s probably close to whatever is used in other games, I suppose (in games like No Man’s Sky or, for those of my generation, a very old game called Unicycle). So, nothing original here, but at least it’s homemade !
This code uses C++. Consider it an open source option and still a draft, although a functioning one. Please also note that this is an example in two dimensions. It would need further adaptation to suit a 3D environment.
First, here’s a picture. On the top left corner, this is what the planet looks like on the planet selector screen, when you launch a new game. To the right is the terrain as it is generated in-game .
The main thing to understand here is that the terrain isn’t stored as a map, but rather as a few parameters that are passed on to a function dedicated to generating the terrain in real time. The main advantage is that it’s seemless : you can zoom into a portion of terrain forever if you want to ; or zoom out as your microbe turns into a brachiosaurus.
All you need is a class (I called mine World) with two public functions :
- A function to generate the world for the first time :
void generate(int seed);
- And a function you can run everytime you need to render or interact with terrain :
double getAltitude(double longitude);
The getAltitude(longitude) function will accept a coordinate in radians passed as an argument, and will return a double that you can then relate to any relevant measuring unit (centimeters, meters, kilometers…). However, it’s important that the longitude (the X coordinate) be expressed in radians (between 0.0 and 2*PI). You’ll find out why.
Your class will also have some private members, all of which (except the random generator itself) will be randomized in the “generate(seed)” function:
- a RN Generator. I’m using the standard C++ library one :
std::default_random_engine _rNGenerator;
- an array of floats/doubles to store some random “noise” :
QVector<double> _outline;
(I’m using a custom class that comes with QtCreator but any standard C++ array will do the job).
- an integer to store the number of hills :
int _nbHills;
- a float or double to store the maximum altitude :
double _mountainMaxHeight;
- an integer to adjust the general smoothness of the terrain :
int _smoothness;
- a couple more double values that will store the coordinates of your “mountains” :
double _mountainOffset1;
double _mountainOffset2;
Now let’s take a look at the first function in world.cpp - the generator/initializer
Step 1.
First, you need to clear up your array of “noise” (in case you’re re-generating an existing instance), seed your generator and set up some random distributions :
void World::generate(int seed){
_outline.clear(); //Or the standard C++ variant
_rNGenerator.seed(seed);
//Terrain features
std::uniform_real_distribution<double> terrainOutlineDistribution(0.0, 1.0);
std::uniform_int_distribution<> nbHillDistribution(0, 12);
std::uniform_real_distribution<double> mountainMaxHeightDistribution(MOUNTAIN_MIN_HEIGHT, MOUNTAIN_MAX_HEIGHT); //Set those as #defines
std::uniform_int_distribution<> smoothnessDistribution(MIN_SMOOTHNESS, MAX_SMOOTHNESS);
std::uniform_real_distribution<double> mountainOffsetDistribution(0.0, 2*PI);
Step 2.
Initialize your members with some random values. So many seeds… so many worlds !
int i;
for(i=0;i<360;i++)
{
_outline.push_back(terrainOutlineDistribution(_rNGenerator)); //Or standard C++ variant
}
_nbHills = nbHillDistribution(_rNGenerator);
_mountainMaxHeight = mountainMaxHeightDistribution(_rNGenerator);
_smoothness = smoothnessDistribution(_rNGenerator);
_mountainOffset1 = mountainOffsetDistribution(_rNGenerator);
_mountainOffset2 = mountainOffsetDistribution(_rNGenerator);
}
That’s it for the first function. Now let’s take a look at the second function - the operational one, used for rendering, collisions, biome detection… and everything else.
Step 3.
The first half of the function can be very confusing. It’s actually the part that cares about micromanaging your terrain’s curves. Remember the array of “noise” that we filled with values between 0.0 and 1.0 ? We know that the longitude given as an argument can be located somewhere between two of those “dots”.
However, if we consider the slope between two of those “dots” as a straight line, we’ll end up with a landcape that looks like a broken line or polygonal chain (See figure #2). Instead, we want to locate that coordinate on a smooth curve connecting two dots.
Here’s the code for that part of the function. It starts by using a custom function that makes sure the angle given as a parameter falls within [0 ; 2*PI[.
double standardCoordinate(double longitude)
Then it converts the angle to degrees because our array of noise has a size of 360. You can adjust this value to your liking but make sure to change it in the other function as well.
The “double World::standardCoordinate(double angle)” function is an standalone function (I made it static), and goes as follows :
double World::standardCoordinate(double coordinate)
{
//Converts coordinate in radians to an equivalent value within [0;2*PI[
double a = coordinate * 1000000;
double b = (2*PI) * 1000000;
a = int(a)%int(b);
b = a/1000000;
if(b<0.0)
b = (2*PI)+b;
return b;
}
And now the plat de résistance, the getAltitude function itself :
double World::getAltitude(double longitude)
{
//longitude is converted to degrees
double location = (standardCoordinate(longitude)/(2*PI))*360.0;
double progressOnCurve = location - floor(location);
double minHeightFactor;
double maxHeightFactor;
double heightFactor;
if(floor(location) == 359) //This is for the last meridian of your world, that needs to be connected to the first
{
if(_outline[359]<=_outline[0]) //going uphill
{
if(progressOnCurve <= 0.5) //first half
{
maxHeightFactor = (_outline[359]+_outline[0])/2;
minHeightFactor = _outline[359];
heightFactor = minHeightFactor + (maxHeightFactor-minHeightFactor)
* (1 - (sqrt((1-(2*progressOnCurve))) + (1 - sqrt((1-(2*progressOnCurve)))) * (1-(2*progressOnCurve))));
}
else //second half
{
maxHeightFactor = _outline[0];
minHeightFactor = (_outline[359]+_outline[0])/2;
heightFactor = minHeightFactor + (maxHeightFactor-minHeightFactor)
*(sqrt(2*(progressOnCurve-0.5)) + (1 - sqrt(2*(progressOnCurve-0.5))) * (2*(progressOnCurve-0.5)));
}
}
else //going downhill
{
if(progressOnCurve <= 0.5) //first half
{
maxHeightFactor = _outline[359];
minHeightFactor = (_outline[359]+_outline[0])/2;
heightFactor = minHeightFactor + (maxHeightFactor-minHeightFactor)
* (sqrt(1-(2*progressOnCurve)) + (1 - sqrt(1-(2*progressOnCurve))) * (1-(2*progressOnCurve)));
}
else //second half
{
maxHeightFactor = (_outline[359]+_outline[0])/2;
minHeightFactor = _outline[0];
heightFactor = minHeightFactor + (maxHeightFactor-minHeightFactor)
* (1 - (sqrt(2*(progressOnCurve-0.5)) + (1 - sqrt(2*(progressOnCurve-0.5))) * (2*(progressOnCurve-0.5))));
}
}
}
else
{
if(_outline[floor(location)]<=_outline[floor(location)+1]) //going uphill
{
if(progressOnCurve <= 0.5) //first half
{
maxHeightFactor = (_outline[floor(location)]+_outline[floor(location)+1])/2;
minHeightFactor = _outline[floor(location)];
heightFactor = minHeightFactor + (maxHeightFactor-minHeightFactor)
* (1 - (sqrt((1-(2*progressOnCurve))) + (1 - sqrt((1-(2*progressOnCurve)))) * (1-(2*progressOnCurve))));
}
else //second half
{
maxHeightFactor = _outline[floor(location)+1];
minHeightFactor = (_outline[floor(location)]+_outline[floor(location)+1])/2;
heightFactor = minHeightFactor + (maxHeightFactor-minHeightFactor)
*(sqrt(2*(progressOnCurve-0.5)) + (1 - sqrt(2*(progressOnCurve-0.5))) * (2*(progressOnCurve-0.5)));
}
}
else //going downhill
{
if(progressOnCurve <= 0.5) //first half
{
maxHeightFactor = _outline[floor(location)];
minHeightFactor = (_outline[floor(location)]+_outline[floor(location)+1])/2;
heightFactor = minHeightFactor + (maxHeightFactor-minHeightFactor)
* (sqrt(1-(2*progressOnCurve)) + (1 - sqrt(1-(2*progressOnCurve))) * (1-(2*progressOnCurve)));
}
else //second half
{
maxHeightFactor = (_outline[floor(location)]+_outline[floor(location)+1])/2;
minHeightFactor = _outline[floor(location)+1];
heightFactor = minHeightFactor + (maxHeightFactor-minHeightFactor)
* (1 - (sqrt(2*(progressOnCurve-0.5)) + (1 - sqrt(2*(progressOnCurve-0.5))) * (2*(progressOnCurve-0.5))));
}
}
}
Step 4.
The last part of the function is much shorter than the first one. In the previous stage, the function has left you with a “heightFactor” value which falls between 0.0 and 1.0. It has made sure that two longitudes that are close to each other will also return two altitudes which are close to each other, connected with a nice, smooth slope. You could stop here and have the function return the “heightFactor” value. It will work, but will look like a very dramatic landscape. So what we need now are some mitigating factors that will be used as “filters” to add variety and a natural feel to our terrain.
For stability, I only choose factors (values that we will multiply our “heightFactor” with) between 0.0 and 1.0. This is to guarantee that our final result also stands between 0.0 and 1.0.
Hills and mountains are best simulated using the cosinus and sinus functions. This is also why I chose to express the X coordinate as an angle in radians in the first place. Here I won’t go too far into the details. You can see I used several “layers” of terrain manipulation. This is highly customisable as long as you design microfunctions in the [0.0 ; 1.0[ range. Be aware, however, that the more you stack em, the lower you terrain will be (0.5 times 0.5 times 0.5… tends towards 0.0).
Finally, you just need to multiply that [0.0 ; 1.0] value by whatever the maximum height or base unit is in your world : height of the screen (in pixels), of the terrarium, of the atmosphere, etc…
double smoothness = _smoothness;
return (heightFactor/smoothness+((smoothness-1)/smoothness))
*((cos(longitude*_nbHills)+1)/8+0.75)
*((cos(longitude-_mountainOffset1)+1)/4+0.5)
*((cos(longitude-_mountainOffset2)+1)/4+0.5)
*_mountainMaxHeight;
}
As far as rendering is concerned, adapting this to your graphic engine should not be too big of a challenge. It’s pretty straightforward. In the first picture I posted - the planet editor, altitude is added to the radius of a circle. That circle is then translated into a series of points, passed on to the rasterizer. In the next example, altitude dictates the Y coordinate of the points in the terrain outline.
In the picture I posted you have noticed that the terrain has water, grass and snowy tops. This has been achieved by stating key altitudes as #defines in the world class header file. In my configuration, for example, sea level is 1000 meters high. Tundra is 1500 meters high. I find it easier not to mix this aspect with the shape of the terrain itself. Using #defines also allows for later rescaling through trial and error
I’de be happy to give more details if that contributes to the advancement of the game. Also, you might have some ideas regarding land generation in Thrive, or bits of code to share. This can be discussed here I suppose, if there is not yet a dedicated topic.
