Microdesafios semanales [Programacion]

yo estoy intentando diamond square y perlin noise #66

Yo estoy en pausa ahora mismo, que tengo que ponerme al día de otras cosillas, a ver si el domingo puedo pegar el último empujoncito y dejar listo algo decente.

#49 Cuando esté todo listo os colgaré el proyecto entero (ya veré si lo hago vía repositorio u os paso un zip) y que os divirtáis poniendo verde mi código.

Por ahora tengo justo lo que dice el enunciado, un mapa aleatorio, pero me gustaria que tenga algo más de lógica que un simple (50%), y si ya soy capaz de meterle a un personaje con físicas, mejor que mejor

#67 #72 #76 No tenía ni idea de esos algoritmos, gracias por nombrarlos. Yo siempre he trabajado con mis propios algoritmos para cualquier cosa y, la verdad, nunca me he planteado ni he necesitado buscar si había unos ya hechos para utilizarlos. Si tengo tiempo miraré a ver como funcionan porque lo cierto es que lo poco que acabo de mirar no me he enterado de nada.

No me he apuntado por dos motivos, el primero es porque quiero terminar mi actual proyecto cuanto antes y por lo tanto no quiero dedicar tiempo a otra cosa y, el segundo es, precisamente, que en mi actual proyecto la generación procedural está a la orden del día ya que todo, TODO (menos la GUI) se genera en tiempo real para reducir al máximo el tamaño del proyecto. En algunos casos a partir de valores establecidos por mi y en otros de manera aleatoria para reducirme trabajo.

Un ejemplo son los "mapas" de selección de nivel, que aquí os muestro:

Se que parece muy psicodélico pero este finde o la próxima semana ya os presentaré el proyecto para que veais en que consiste. No es nada raro, aunque pediré opiniones.

Disclaimer: Sorry por el tocho que se viene...

Generación Mapa Procedural

Bueno, lo que llevo haciendo desde el jueves por la noche es un sistema de generación de un mundo 3D basado en cubos, estilo Minecraft. Para la generación de los biomas y/o restricciones he preferido calentarme la cabeza,no tirar de los métodos habituales,simplificarlo un poco (Obviamente ha quedado peor, que lo que existe, que funciona, por algo está). A continuación voy a tratar de explicar un poco los pasos a seguir. Partiré de donde lo dejé en #59, con los tiles creados, así cómo la lógica del rellenado de la región de forma puramente aleatoria. Básicamente pues, lo que tenemos es una región 3D rellena a base de cubos tal que así:

Los pasos que he diseñado en el algoritmo son los siguientes:

• Rellenado de la región.

• Búsqueda de vecinos.

• Aplicación custom-pseudoalgoritmo de restricciones.

• Aplicación custom-pseudoalgoritmo de "biomas"

• Destrucción de los tiles TyleTipe.Air (Aire)

• Busqueda de los tiles de "Tierra" que debieran ser de Hierba por su condición y resolución de los cambios.

(El rellenado de la región no lo voy a explicar, básicamente recorro todo el espacio de dentro con un triple bucle for y voy rellenando sin control xD)

Búsqueda de vecinos

Una vez finalizado el rellenado de la región, tengo todos los cubos instanciados y ocupando su huequecito en memoria, dejándolos sin protección ante mis maldades. Cada cubo tiene implementado un método que hace que se busquen los vecinos que tiene "inmediatamente" al lado. Para cada cubo 3D tenemos, 999 cubos . Es decir, 27 'vecinos'. PERO el la posición central que la ocupa el propio cubo que busca el vecino no la contamos, por lo que cada cubo podrá llegar a un máximo de 26 vecinos. Ilustro un poco:

*Esto representa el volumen que comprueba cada Cubo para determinar sus vecinos, estando el cubo que realiza la comprobación en el centro del volumen

public void FindNeighbour (Vector3 globalpos)
	{
		//Position Values Storage
		float x = globalpos.x;
		float y = globalpos.y;
		float z = globalpos.z;

	/* check 26 neighbours and ourselves */
	/* This line check with an Sphere of Sqrt(2) radius,
	 * from each cube position, if it collides with any collider */
	Collider[] hitColliders = Physics.OverlapSphere(this.transform.position, 1.41f);

	/* For loop in order to add the "Tile3D" component to local neighbour list*/
	for(int i = 0; i < hitColliders.Length;i++)
	{
		//Check if colllider does not return null value 
		if(hitColliders[i] != null)
		{
			//Check id collider does not take in count the floor collider
			if(hitColliders[i].gameObject.name != "Floor")
			{
				/*Check if we are not taking in count ourselves (we compare both NB list
				 * since we will never have the same NB list for two or more Tile3D component*/
				if(hitColliders[i].gameObject.GetComponent<Tile3D>().NB != this.NB)
				{
					//Finally we add the Component to the NB list.
					NB.Add(hitColliders[i].gameObject.GetComponent<Tile3D>());
				}
			}
		}
	}
}

De esta forma, cada Cubo/Tile, en su componente Tile3D tendrá una lista de sus vecinos.

Aplicación custom-pseudoalgoritmo de restricciones

Aquí básicamente, asigno un porcentaje de aparición a cada tile según el % de terreno ( en relación a la ALTURA de la región ) en el que se encuentre.
Debido a la longitud, voy a poner un ejemplo, una imagen que he hecho desempolvando "Fotochó" y ya os imaginais el resto xD...

	void CreateConstraints ()
	{
		//If this tile is over the 80% of the terrain, it will be ALWAYS Air.
		if(this.gameObject.transform.localPosition.y >= mapr.transform.localScale.y - (mapr.transform.localScale.y*.2))
			this.Type = TileType.Air;

	//If this tile is at or  under the 10% of the terrain..
	if(this.gameObject.transform.localPosition.y <= mapr.transform.localScale.y - (mapr.transform.localScale.y*.9))
	{
		//Random.value always return a random value(juejj) between 0.0f and 1.0f;
		if(Random.value <= .90f) 
			this.Type = TileType.Water; //90% Water
		else
			this.Type = TileType.Stone; //10% Stone
	}
             ...
             ...
             ...

Ilustro: (Se aceptan criticas acerca de los porcentajes xD)

Aplicación custom-pseudoalgoritmo de "biomas"

Bueno, aquí básicamente lo que he hecho ha sido,realizar comprobaciones. Cada cubo comprueba de qué tipo son sus vecinos. Cada comprobación "añade uno" al contador de vecinos. Por ejemplo:

El cubo situado en (4,5,8) tiene:
Aire: 4
Tierra:6
Piedra: 6
Agua: 10

En función de los resultados obtenidos, calculo el porcentaje que representa dentro de la nube de vecinos. Por ejemplo, si tiene 13 de los 26 vecinos son Agua, almaceno que el 50% de los vecinos son del tipo Agua. Posteriormente, utilizo ese porcentaje, como probabilidad de que el cubo que realiza la comprobación se convierta transforme a cubo de ese mismo tipo. Para el mismo ejemplo, el cubo que realiza la comprobación, ahora tiene un 50% de probabilidades de convertirse en Agua puesto que el 50% de sus vecinos lo son.

En cuanto al código chustero..:

	private void CreateBiomes()
	{
		/* First at all, see the freQ of the Types in each Tile neighbourhood */
		int WatC = 0,AirC = 0,StoC = 0,DirC = 0;
		foreach(Tile3D t3 in NB)
		{
			//check if null
			if(t3 != null)
			{
				//Check if neighbour type is Air.
				if(t3.Type == TileType.Air)
				{
					//We are not counting the 20% of Air at the top of the region, in order to prevent TONS OF AIR tiles
					if(t3.transform.localPosition.y < mapr.transform.localScale.y - (mapr.transform.localScale.y*.2))
				   		AirC++;

			}
			if(t3.Type == TileType.Stone) //if stone
				StoC++;
			if(t3.Type == TileType.Dirt) //if dirt
				DirC++;
			if(t3.Type == TileType.Water) //if water
				WatC++;		

	
		}
	}
	/*********************************************************************/
	/* Once que have the amount of tyles of every type, we assing a percentage */
	watP= WatC/26.0f;
	AirP= AirC/26.0f;
	StoP= StoC/26.0f;
	DirP= DirC/26.0f;
	/**********************************************************************/

	//Calculate rand value and checks
	float rand = Random.value; 
	if(rand >= 0.0f && rand <= watP)
	{
		this.Type = TileType.Water;
	}
	if(rand > watP && rand <= watP+AirP)
	{
		this.Type = TileType.Air;
	}
	if(rand > watP+AirP && rand <= watP+AirP+StoP)
	{
		this.Type = TileType.Stone;
	}
	if(rand > watP+AirP+StoP && rand <= watP+AirP+StoP+DirP )
	{
		this.Type = TileType.Dirt;
	}

}

Ya tenemos los "biomas" mejorados, para que se formen grupos 'grandes' del mismo tipo de material.

Destrucción de los tiles TyleTipe.Air

No tiene ningún misterio. Cada tile comprueba su material y si es Aire. Se inmola ( muahahahah) y mi memoria me lo agradece...

void DisableAir ()
	{
		//IF I AM FUCKING AIR,THEN FUCK YOU IM LEAVING
		if(this.Type == TileType.Air)
			DestroyImmediate(this.gameObject);
	}

Por último...

Busqueda de los tiles de "Tierra" que debieran ser de Hierba por su condición y resolución de los cambios

Aquí básicamente comprobamos si estamos justo debajo del primer tile superior de aire, es decir, en la superficie. Además, siempre que un tile de tierra no tenga ningún bloque más en toda la altura de la región, será Hierba, de lo contrario, Tierra ( Quiero modificar esta para que si hubiere construcciones rarunas tambien pudiera haber hierba, ya la tengo pensada más o menos como...)

void FixGrass ()
	{
		//since 80% and above will be always AIR, if im DIRT, im actually Grass
		if(this.Type == TileType.Dirt && this.gameObject.transform.localPosition.y >= mapr.transform.localScale.y - (mapr.transform.localScale.y*.3))
		{
			this.Type = TileType.Grass;

	}
	else
	{	
		//if im Dirt..
		if(this.Type == TileType.Dirt)
		{
			//We throw a Raycast "region.scale.y" meters in order to check if we have any block over our position.
			RaycastHit hit;
			Ray ray = new Ray(this.transform.localPosition,Vector3.up);
			//if we have some block, then i'll be always dirt.
				if (Physics.Raycast(ray,out hit, mapr.transform.localScale.y))
				{
					this.Type = TileType.Dirt;
				}
				//if not, im going to be a nice grass tile.
				else
					this.Type = TileType.Grass;
		}
			
	}
}

Y eso es todo. Sorry again por el tocho

Resultado

Esta tarde/noche generaré algún video para que veais como se mueve (ha mejorado muy mucho-bastante el tema FPS ). Haré algo "jugable" para que navegueis por el mundo y enseñaré varios escenarios distintos ( distintas dimensiones ), por ahora, y para no cargarme Mediavida, solo una foto de un 'chunk' pequeñito.(si me da tiempo hasta mañana por la noche mejoraré los materiales :3 )

Para ser un algoritmo homemade no ha quedado tan mal xD, pero existirán 300.000 mejoras, empezando por usar técnicas/algoritmos que ya existen para estas cosas...pero así es más divertido!

Saludos!

Pues vista la hora que es, ya puedo dar por aparcado el proyecto, he hecho unos sprites muy monos con unas enredaderas que iban a ser las escaleras... Y tenía pensado un sistema de generación de plataformas a partir de nodos bastante curioso, pero que no acababa de funcionar...

Así que no me ha dado tiempo de implementar todo el rollito de la generación de plataformas, ni ningún tipo de personaje ni na de na.

Voy a ponerme con "Mi proyecto principal" a ver si puedo dejar algo listo hoy, y una vez que lo tenga, limpio el mini reto para no colgarlo con todo el merder de funciones que no he llegado a usar.