Adding detail to Procedurally Generated Terrain

[BlueSin]

So my team and I are creating a 2D game that has procedurally generated terrain similar to Terraria and Starbound. We used this tutorial to create our map: Unity Voxel Terrain. It look alot of different methods and effort, but we have the map generation part working just fine.

The problem is when it comes to detail, detail of the caves and terrain contour for example. Take these 2 screenshots of our terrain, the first is a map overview, and the second is more zoomed in:

As you can see we have all different shapes of stone patches (light grey), dirt patches, caves (dark grey). You can even see we have the map divided into layers composed of different materials. Now with that said, lets take a snippet of a Terraria map as another example:

The difference in detail is night and day between the two, but I could just be being picky. Some things we couldn’t even imagine how to do, for example the floating islands. But my biggest concern in particular is the terrain contour and cave detail. In the Terraria example it seems as though they have some perlin worms and possibly overlapping caves. But we can’t seem to find solid data on how to create perlin worms. Also note the greenish dungeon looking area, and even the shapes of some of the biomes such as desert which has diagonal edges.

All of these are puzzles to us, that we are having some issues resolving. We are using the Unity PerlinNoise method to generate our terrain. Does anybody have any tips, tricks, etc. to get our terrain generation looking more like Terraria?

[Vanamerax]

The builtin Mathf.PerlinNoise is a bit limited to the things you can create with it. There are lots of different types of noise that you can combine in many interesting ways. I’d suggest you look up the C# port of libnoise. It has a lot of different types of noise implemented and also gives you some hints how to combine them.

[bigmisterb]

Perlin worms:

First, devise a brush. Something like a simple method that erases, or adds voxels based on a point and radius. You could even design it based on a texture, where the texture is either black or white, (black would remove, white would ignore) You could also add in a feature that changes voxels on the edge of the brush to something, or based on something. A perlin worm is a worm with a general direction. That direction steps 1 or more based on your settings and the direction changes based on Perlin noise values. So, X,Y would add Perlin of RandomX, RandomY. (the default perlin gives you a number that is zero to 1 I think. So you would subtract 1 and multiply it by some factor for variation.

[rrh]

I was just watching this the other day, it’s the creators of Sir, You Are Being Hunted and they mention some stuff about procedurally generated landscapes that might inspire you:

Procedurally generated content in Sir, You Are Being Hunted: a Unite Nordic 2013 presentation

Comparing your exmple to the Terraria map, I think you should try to vary the depth of the layers slightly more. Also use different scale of noise for each layer. But yeah, it looks like a lot of the caverns are carved out by something moving along and erasing as it goes, rather than just perlin noise.

Probably do a broad-level approach, like divide the map into large sections, (let’s say triangles) then have the triangles assigned random terrain types. Perhaps some terrains have restrictions, like it must be a triangle within this distance of the surface, or it must have five adjacent triangles. Then for all these triangles you run a different algorithm based on terrain type. Maybe some of the terrain types are basically the same, but then they add a special cavern in the middle of the region and then create a tunnel to the surface.

[bigmisterb]

I am replying to your PM here:

OK, first, a worm is nothing but p1 to p2 where you draw (or undraw) each 1 unit given a radius. This makes a worm (or bores a tunnel) radius wide X distance.

Once you get this, next add radius over distance, so say we go from p1 to p2 where the radius changes from r1 to r2 over that distance. In general, I would just go from r1 to zero. This just draws the tunnel and tapers it down.

Hint, you can calculate the distance remaining by first capturing the total distance between p1 and p2 and comparing it to the current distance between p1 and p2. (stating that you advance p1 towards p2. i.e. p1 = Vector2.MoveTowards(p1, p2, 1); ) see code below.

Next, add some noise to this. Using PerlinNoise, you can add variety to either the radius, or the position. Radius is simple, just add the noise by the radius. (radius += noise * (radius * 0.5f); ) Position is fairly easy. To do so, you will need to know the Cross of the vector. (see below) Now it is simply a matter of adding the cross to the position by an amount -1 to 1. (noise * 2 -1 or just noise if you are using noiseLib).

Note, when you start your noise addition to position, always temper the start point. So your noise should gradually raise from 0 to full strength over the first quarter of your tunnel. Not doing this simply starts the new tunnel offset the noise amount from the origin, which is what we don’t want.

OK, so now, if you go from 0 to 100 units away, and fade your radius from 10 to 0, add noise for vertical movement and minor noise for radius movement, you will get a perlin worm.

Yet more advanced:
Now, lets look at branches. Decide up front how many branches you want, then as you draw the worm, you get to point 0.333 (for random sake) and you add another worm that shoots either up or down. (again, use the Cross, or aCross from below). you can then add some trickery, such as the RandomDirection() below to make it where they are not all just 90 degree angles. Then just multiply that by the distance you want to go (could be random or based off the original distance, or distance remaining in the tunnel.) and call the same function that made the worm to start. You could also branch this one too. however, I would add a variable in on the function that will limit the number of branches. (say, the number of branches from this one -1) This way you don’t get into a never ending loop while creating them. Eventually, they just wont spawn more branches. Lastly, radius should go from the current (or maybe less than the current) to zero over that distance.

// use this to get your original distance
// float sqrDist = (p2 - p1).sqrMagnitude;


// current percentage of motion
float CurrentPercent(Vector2 p1, Vector2 p2, float sqrDist){
	return (p2-p1.sqrMagnitude) / sqrDist;
}

// rotate the direction counter clockwise 90 degrees
Vector2 Cross(Vector2 p1, Vector2 p2){
	Vector2 dir = (p2-p1).normalized;
	return new Vector2(-dir.y, dir.x);
}

// rotate the direction clockwise 90 degrees
Vector2 aCross(Vector2 p1, Vector2 p2){
	Vector2 dir = (p2-p1).normalized;
	return new Vector2(dir.y, -dir.x);
}

Vector2 RandomDirection(Vector2 normal){
	return (normal * 2 + Random.insideUnitSphere).normalized;
}

[bigmisterb]

Oh, also, you had asked about using the position of the point as a reference to the noise. If you haven’t figured it out by now. (which you should) the noise is very jagged at a 1x1 ratio, so you need to increase the points which you pull from. (or develop a scaling)

So tunnel that begins at 100x100 gets it’s noise from 1x1 so your scaling is 0.01f.

Also, in order to mix things up, I always use an offset (usually I just use a Random.insideUnitCircle (or Sphere if you are using libNoise) and multiply that by 10000 or so. This always gives me good results because it is not always coming from the same area. (yes, x and y values for your perlin generator)

[BlueSin]

This is going to sound ridiculous but uh…how do I create a radial brush whose size I can control on demand? I haven’t ever had to do anything like that before, and when I try to Google the solution all I find is solutions involving System.Drawing and ellipses, nothing actually stating how. The only way I could think of is to create a manual brush like this:

int[,] wormBrush = new int[5, 5]
{
0, 0, 1, 0, 0
0, 1, 1, 1, 0
1, 1, 1, 1, 1
0, 1, 1, 1, 0
0, 0, 1, 0, 0
};

Other than that, I found a solution last night that creates the worms, they are looping around on themselves and traversing the map happily now. But altering their size would be an awesome addition. Here is the worm code I created, tell me what you think:

private void CreateWorm(ref BlockData[,] blocks, TerrainType terrain)
    {
        Vector2 wormDirection = new Vector2(
            Mathf.Floor(UnityEngine.Random.Range(-1f, 1f)),
            Mathf.Floor(UnityEngine.Random.Range(-1f, 1f)));
        int wormLifetimeMax = UnityEngine.Random.Range(50, 101);
        int currentWormSteps = 0;
        Vector2 currentWormPosition = new Vector2(
            Mathf.Floor(UnityEngine.Random.Range(0f, dimensions.x)),
            Mathf.Floor(UnityEngine.Random.Range(0f, dimensions.y)));

        while (currentWormSteps < wormLifetimeMax)
        {
            // The amount of steps the worm will take this turn
            int moveAmount = UnityEngine.Random.Range(5, 11);

            // Until we have taken the appropriate number of steps, loop
            for (int currentStep = 0; currentStep < moveAmount; currentStep++)
            {
                // Validate worm position and punch blocks
                if (!ValidPosition(currentWormPosition, 1, ref blocks, terrain))
                    return;

                // Move the worm
                currentWormPosition += wormDirection;

                // Increase worm steps
                currentWormSteps++;
            }

            // Will the worm move a negative amount?
            bool isNegativeX = false;
            bool isNegativeY = false;

            // Decide if the worm will move a negative amount
            if (UnityEngine.Random.Range(0, 2) == 1)
                isNegativeX = true;
            if (UnityEngine.Random.Range(0, 2) == 1)
                isNegativeY = true;

            // Create a new direction based on random perlin
            if (isNegativeX  isNegativeY)
            {
                // Get a new random perlin direction
                wormDirection = new Vector2(
                -Mathf.RoundToInt(PerlinNoise.GetNoise(UnityEngine.Random.value, UnityEngine.Random.value, 0)),
                -Mathf.RoundToInt(PerlinNoise.GetNoise(UnityEngine.Random.value, UnityEngine.Random.value, 0)));
            }
            else if (isNegativeX)
            {
                // Get a new random perlin direction
                wormDirection = new Vector2(
                -Mathf.RoundToInt(PerlinNoise.GetNoise(UnityEngine.Random.value, UnityEngine.Random.value, 0)),
                Mathf.RoundToInt(PerlinNoise.GetNoise(UnityEngine.Random.value, UnityEngine.Random.value, 0)));
            }
            else if (isNegativeY)
            {
                // Get a new random perlin direction
                wormDirection = new Vector2(
                Mathf.RoundToInt(PerlinNoise.GetNoise(UnityEngine.Random.value, UnityEngine.Random.value, 0)),
                -Mathf.RoundToInt(PerlinNoise.GetNoise(UnityEngine.Random.value, UnityEngine.Random.value, 0)));
            }
            else
            {
                // Get a new random perlin direction
                wormDirection = new Vector2(
                Mathf.RoundToInt(PerlinNoise.GetNoise(UnityEngine.Random.value, UnityEngine.Random.value, 0)),
                Mathf.RoundToInt(PerlinNoise.GetNoise(UnityEngine.Random.value, UnityEngine.Random.value, 0)));
            }
        }
    }

The terrain is looking better already, especially when you zoom in and traverse the tunnels as a player it feels much better now. We still have adjustments to make though, the worms are moving a little too diagonal for my liking, so once I figure out this radial brush thing I will try your theory (although it feels a bit over my head lol). Check it out, using the worms to create air, dirt, and stone, in addition to perlin generated stone and dirt patches.

[bigmisterb]

I am looking for 1 method… wherever it may be… it is the single method that sets the block to a type, or disables it.

Other than that, a brush is easy to create. Very simple statement:

float radius = 5;
float dist = radius * radius;
Vector2 position = Vector2(0,0);
for(float y = -radius; y<radius; y++){
	for(float x = -radius; x<radius; x++){
		if(new Vector2(x,y).sqrMagnitude < dist)
			SetTerrain(position.x + x, position.y + y, terrainType);
	}
}

[BlueSin]

Ah, yes sorry that method is very messy since I barely managed to cobble it together. Very long as well as it is inefficient. Should help now that I have the brush code now.

Here it is, updated using your radius code:

private bool ValidPosition(Vector2 position, ref BlockData[,] blocks, TerrainType terrain, float radius)
    {
        // float radius = 5;
        float dist = radius * radius;
        // Vector2 position = new Vector2(50, 50);
        for (float y = -radius; y < radius; y++)
        {
            for (float x = -radius; x < radius; x++)
            {
                if (new Vector2(x, y).sqrMagnitude < dist)
                {
                    if (position.x + x >= dimensions.x - 1 || position.x + x <= 0)
                        return false;

                    if (position.y + y >= dimensions.y - 1 || position.y + y <= 0)
                        return false;

                    blocks[(int)position.x + (int)x, (int)position.y + (int)y].Terrain = terrain;
                }
            }
        }

        return true;
}

Edit: So I implemented the radius, it works beautifully. I am sorry to say your explanation of how to create a worm though went right over my head. Looking at the code I have now though, what can I do to get worms like these:

Also here is what I have now:

[BlueSin]

Sorry for the double post here but I managed to solve the problem. I believe that I was just burned out yesterday and couldn’t think anymore. I had this up and running within an hour of coming in today. Check out the worms now:

Thanks everybody for your help and suggestions, they were all well received and appreciated. The newly recoded combination of the new worms, new caves, new patches, and new contour make this look almost spot on Terraria. Thanks all!

[DrSnake]

So why don’t you post your result / the working code?

[Moshu]

I would be very thankful for the working code or an example of how you got this working in the end. : )

[321Alex]

Has anyone ever done something like this in a 3D space?

[TheFrontline]

@321Alex

Has anyone ever done something like this in a 3D space?

No but I can only imagine it would just take another axis because if you notice these only mention 2 of the 3.