Random 2D Cavern Generator

Foreword

If you are too lazy to take care of your time, making a level for your game, then you have got to the right place.

This article will tell you in detail how to use one of the many other methods of generation using the example of mountainous terrain and caves. We will consider the Aldous-Broder algorithm and how to make the generated cave more beautiful.

Upon completion of reading the article you should have something like this:

Theory

Mountain

To be honest, the cave can be generated from scratch, but this will be somehow ugly? In the role of a “platform” for mine placement I chose a mountain range.
This mountain is generated quite simply: let us have a two-dimensional array and a variable height , initially equal to half the length of the array in the second dimension; we will simply walk along its columns and fill in all the lines in the column to the value of the variable height , changing it with a random chance up or down.

Cave

For the generation of the dungeons themselves, I chose - it seemed to me - a great algorithm. In simple language, it can be explained as follows: let us have two (maybe even ten) variables X and Y , and a two-dimensional array 50 to 50, we give random variables to these variables within our array, for example, X = 26 , and Y = 28 . Then we do the same actions a number of times: we get a random number from zero to

$$

$$Number of Variables * 2$$

in our case up to four ; and then, depending on the number that falls out, we change
our variables are:

switch (Random.Range(0, 4)) { case 0: X += 1; break; case 1: X -= 1; break; case 2: Y += 1; break; case 3: Y -= 1; break; } 

Then we, of course, check if any variable falls out of our field:

  X = X < 0 ? 0 : (X >= 50 ? 49 : X); Y = Y < 0 ? 0 : (Y >= 50 ? 49 : Y); 

After all these checks, we are doing something in the new values ​​of X and Y for our array (for example, we add one to the element) .

 array[X, Y] += 1; 

Training

Let us, for ease of implementation and clarity of our methods, will we draw the resulting objects? I'm so glad you don't mind! We will do this with Texture2D .

For work we need only two scripts:

ground_libray is what the article will revolve around. Here we both generate, and clean, and draw

ground_generator is what will use our ground_libray

Let the first be static and will not be inherited from anything:

 public static class ground_libray 

And the second is normal, only the Update method is not needed.

Also let's create on the scene a game object, with the SpriteRenderer component

Practical part

What is it all about?

To work with the data we will use a two-dimensional array. You can take an array of different types, from byte or int , to Color , but I think that this would be best done:


I will explain this by the fact that it will allow us to both save our array and modify it if necessary.

Mountain range

Let's, before we begin to generate the mountain, we will designate the place where we will store it .

In the ground_generator script , I wrote this:

  public int ground_size = 128; ground_libray.block[,] ground; Texture2D myT; 

ground_size is the size of our field (that is, the array will consist of 16384 elements).
ground_libray.block [,] ground - this is our field for generation.
Texture2D myT is what we will draw on.


Let's create the first method in the ground_libray script:



Now let's go to the ground_generator and write this in the Start method:

  ground = new ground_libray.block [ground_size, ground_size]; ground_libray.generate_mount(ref ground); 

We initialize the ground variable once it needed to be done .
After no explanation, we send it to ground_libray .
So we generated a mountain.

Why don't I see my mountain?

Let's draw now what we have done!

For drawing we will write in our ground_libray this method:


And, of course, at the end we go to the ground_generator and add this:

  ground = new ground_libray.block [ground_size, ground_size]; ground_libray.generate_mount(ref ground); //   ground_libray.paint(ground, ref myT); GetComponent<SpriteRenderer>().sprite = Sprite.Create(myT, new Rect(0, 0, ground_size, ground_size), Vector3.zero ); 

But no matter how much we draw on our texture, in the game we can see it only by putting this canvas on something:

SpriteRenderer does not accept Texture2D anywhere , but nothing prevents us from creating a sprite from this texture - Sprite.Create ( texture , rectangle with coordinates of the lower left corner and upper right , axis coordinate ).

These lines will be called up to date, we will finish everything else above the paint method!

Mines

Now we need to fill our fields with random caves. For such actions, we will also create a separate method in ground_libray . I would like to immediately explain the parameters of the method:

 ref block[,] b -     . int thick -    int size -         Color outLine -   

Now let's add this line to our ground_generator :

 ground_libray.make_cave(ref ground, 2, 10000, new Color(0.3f, 0.3f, 0.3f)); 

You can install the ground_generator script as a component on our object and check how it works!

Cavern Correction

You did not notice that in this kind of cave does not look the best way? Too many extra details (you may think otherwise) .

To get rid of some # 4d4d4d blotches, we will write this method in ground_libray :


Then we simply add this line to our ground_generator :

 ground_libray.clear_caves(ref ground); 

As we can see - most of the unnecessary particles just gone.

Add some paint

Our mountain looks very monotonous, I find it boring.

Let's add some paint. Add the level_paint method to the ground_libray :

disadvantages

Suppose that we have a field of 1024 by 1024, we need to generate 24 caves, the thickness of the edge of which will be 4, and the size will be 80,000.

1024 * 1024 + 24 * 64 * 80000 = 5,368,832,000,000 operations.

This method is only suitable for generating small modules for the game world; it is impossible to generate something very large at a time .