Generación procedural de circuitos de carreras - Parte 2 | Race Track Procedural Generation - Part 2

Español | English

Esta va a ser la 2da parte de una serie de Posts en donde explico como crear pistas de carreras generadas aleatoriamente. La primer parte la pueden encontrar en mi blog.

En la parte anterior, había definido la siguiente estructura lógica que iba a utilizar el algoritmo de geneación:

1. Generar un elemento de forma aleatoria
2. Si ese elemento es una recta, seguir de largo, si es una curva, girar
3. Repetir 1-2 hasta tener una cierta cantidad de elementos
4. Buscar la forma de el último elemento con la posición inicial

Esta manera fue descartada, ya que había muchas cuestiones a tener en cuenta, como las rotaciones de las distintas partes y como estas influyen a las siguientes.

Así también como el hecho de que no era capaz de indicar el tamaño del mapa, ya que cada vez que se generaba, se creaba un camino hacia un sentido aleatorio, de esta forma no se podía limitar a que el mapa ocupe "10 unidades del eje Y".

Por eso que decidí cambiar la idea, teniendo primero una "grilla" que si puedo dimensionar y luego eligiendo las partes que van a ser usadas para la pista. Entonces el algoritmo se modificó a que recorra la siguiente secuencia:

1. Crear una grilla de dimensiones X  e Y indicadas.
2. Seleccionar los nodos eligiendo lugares aleatorios de la grilla
3. Unir los nodos.

Esta idea de nodos esta pensada a base de Grafos:

En donde para generar el circuito, elijo cuantos nodos quiero que existan y luego busco la manera en la cual pueda unirlos (generar las aristas) de formas aleatorias, para que de una misma posición de nodos, pueda tener distintas variantes.

Por ahora estoy en la etapa 2. Estoy creando la forma en la cual se puedan elegir los nodos de forma aleatoria sin repeticiones y en lo posible que no estén juntos.

En la imagen se pueden ver: Los parámetros para la creación de la grilla, la grilla con sus elementos en gris y los nodos seleccionados aleatoriamente en rojo.

Lo siguiente es indicarle a las posiciones que se eligieron que van a representar nodos. Luego de eso, empieza la etapa 3 de pathfinding, en la cual a partir de esos puntos, hay que crear las formas de unirlos para generar los circuitos.

-L 

-------------------------------------------------------------------------------------------------------------------------

English

This is going to be the second part of a series of Posts where I explain who to create procedural generated racing tracks. You can find the first part on my blog.

On the previous part, I've defined the next series of steps that were going to be part of the generator algorithm:

1. Generate a random element
2. If that element is a straight line, move forward, if it is a curve, turn
3. Repeat 1-2 until there are a certain amount of elements
4. Find the way to join the final position with the starting position

This way was thrown away, as there were too many things to take into consideration, like the rotations of the different parts and how they influence on the next parts.

As well as the fact that I wasn't able to set the size of he map, because every time the map was generated, a different path as created, so I couldn't limit the size map by saying that the map should be "10 units on the Y axis".

That's why I decided to change the idea, using a grid which in fact I can set the size and then selecting the parts that are going to be used for the track. So the algorithm changed to follow the next steps.

1. Create a grid of X and Y dimensions.
2. Select the nodes by selecting a random positions of the grid.
3. Join the nodes

This node-idea was thought thinking of Graphs:

Where to generate the track, I choose how many nodes I want and then I find the way to join them together (generate the edges) in random ways, so the same set of positions of nodes can generate different variatons.

Right now I'm on stage 2. I'm creating the way in which I can select the nodes from the random positions of the grid without repeating and if possible, not side by side.

On the image it can be seen: The parameters for the creating of the grid, the grid with its grey elements and the nodes, randomly selected in red.

The next step is to indicate to those positions that were chosen that they will represent nodes. After that, the 3 stage begins, pathfinding. In which I'll have to create different ways to join the nodes to generate the racing tracks.

-L