Gerador de caverna bidimensional aleatório

Prefácio

Se você está com preguiça de cuidar do seu tempo, fazendo um nível para o seu jogo, então você veio ao lugar certo.

Este artigo mostrará em detalhes como você pode usar um dos muitos outros métodos de geração usando o exemplo de terras altas e cavernas. Vamos considerar o algoritmo Aldous-Broder e como tornar a caverna gerada mais bonita.

No final da leitura do artigo, você deve obter algo parecido com isto:

Teoria

Montanha

Para ser honesto, a caverna pode ser gerada a partir do zero, mas será de alguma maneira feia? No papel de "plataforma" para a colocação de minas, escolhi uma cadeia de montanhas.
Essa montanha é gerada de maneira simples: tenhamos uma matriz bidimensional e uma altura variável , inicialmente igual à metade do comprimento da matriz na segunda dimensão; nós apenas passamos pelas colunas e preenchemos algo com todas as linhas da coluna para um valor de altura variável , alterando-o com uma chance aleatória para cima ou para baixo.

Caverna

Para gerar as próprias masmorras, escolhi - como me pareceu - um excelente algoritmo. Em termos simples, pode ser explicado da seguinte forma: mesmo se tivermos duas (talvez dez) variáveis X e Y e uma matriz bidimensional de 50 por 50, atribuímos a essas variáveis ​​valores aleatórios em nossa matriz, por exemplo, X = 26 e Y = 28 . Depois disso, realizamos as mesmas ações várias vezes: obtemos um número aleatório de zero a

$$

$$Número de variáveis ​​* 2$$

, no nosso caso, até quatro ; e então, dependendo do número que caiu, mudamos
nossas variáveis:

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; } 

Então, é claro, verificamos se alguma variável caiu fora dos limites do nosso campo:

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

Após todas essas verificações, fazemos algo nos novos valores X e Y para nossa matriz (por exemplo: adicione um ao elemento) .

 array[X, Y] += 1; 

Preparação

Para simplificar a implementação e a visualização de nossos métodos, desenharemos os objetos resultantes? Estou tão feliz que você não se importa! Faremos isso com o Texture2D .

Para funcionar, precisamos apenas de dois scripts:

ground_libray é o que o artigo irá girar em torno. Aqui nós geramos, limpamos e desenhamos

ground_generator é o que nosso ground_libray usará

Deixe o primeiro ser estático e não herdará nada:

 public static class ground_libray 

E o segundo é normal, apenas não precisaremos do método Update .

Além disso, vamos criar um objeto de jogo no palco, com o componente SpriteRenderer

Parte prática

Em que consiste?

Para trabalhar com dados, usaremos uma matriz bidimensional. Você pode levar uma variedade de tipos diferentes, de byte ou int , para Color , mas acredito que isso será melhor:


Explicarei isso pelo fato de nos permitir salvar nossa matriz e modificá- la, se necessário.

Maciço

Antes de começarmos a gerar a montanha, designemos o local onde a armazenaremos .

No script ground_generator, escrevi isso:

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

ground_size - o tamanho do nosso campo (ou seja, a matriz será composta por 16384 elementos).
ground_libray.block [,] ground - este é o nosso campo de geração.
O Texture2D myT é o que basearemos .


Vamos criar o primeiro método no script ground_libray:



Agora vamos para ground_generator e escreva isso no método Start :

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

Inicializamos a variável ground, uma vez que precisava ser feita .
Depois, sem explicação, envie-o para ground_libray .
Então nós geramos a montanha.

Por que não consigo ver minha montanha?

Vamos agora desenhar o que temos!

Para desenhar, escreveremos o seguinte método em nossa ground_libray :


E, é claro, quando terminar, vamos para ground_generator e adicionamos isso:

  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 ); 

Mas não importa o quanto desenhemos nossa textura, no jogo podemos ver apenas colocando essa tela em algo:

O SpriteRenderer não aceita o Texture2D em nenhum lugar , mas nada nos impede de criar um sprite a partir dessa textura - Sprite.Create ( textura , retângulo com as coordenadas do canto inferior esquerdo e superior direito , a coordenada do eixo ).

Essas linhas serão chamadas de as mais recentes, adicionaremos o restante acima do método de pintura !

Mina

Agora precisamos preencher nossos campos com cavernas aleatórias. Para tais ações, também criaremos um método separado em ground_libray . Gostaria de explicar imediatamente os parâmetros do método:

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

Agora vamos adicionar esta linha ao nosso ground_generator :

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

Você pode instalar o script ground_generator como um componente em nosso objeto e verificar como ele funciona!

Correção de caverna

Você já reparou que, nessa visão, a caverna não parece a melhor? Muitos detalhes extras (talvez você pense diferente) .

Para se livrar das inclusões de alguns # 4d4d4d , escreveremos este método em ground_libray :


Em seguida, basta adicionar a seguinte linha ao nosso ground_generator :

 ground_libray.clear_caves(ref ground); 

Como podemos ver, a maioria das partículas desnecessárias simplesmente desapareceu.

Adicione um pouco de cor

Nossa montanha parece muito monótona, acho chata.

Vamos adicionar um pouco de cor. Adicione o método level_paint ao ground_libray :

Desvantagens

Suponha que tenhamos um campo de 1024 a 1024, precisamos gerar 24 cavernas, cuja espessura das bordas será 4 e o tamanho é 80.000.

1024 * 1024 + 24 * 64 * 80.000 = 5.368.832.000.000 de operações.

Este método é adequado apenas para gerar pequenos módulos para o mundo do jogo, é impossível gerar algo muito grande por vez .