public void Generar(Assets.Casilla[,] casillas)
{
for (int x = 0; x < casillas.GetLength(0); x++)
{
for (int z = 0; z < casillas.GetLength(1); z++)
{
if (casillas[x, z] != null)
{
if (casillas[x, z].recursoPosible == true && casillas[x, z].pisos is null)
{
if (casillas[x, z].isla.recursos != null)
{
if (casillas[x, z].isla.recursos.Length > 0)
{
float alturaCasilla = casillas[x, z].posicion.y;
List <GameObject> recursosIsla = new List <GameObject>();
foreach (GameObject recursoIsla in casillas[x, z].isla.recursos)
{
Recurso recursoIslaDatos = recursoIsla.GetComponent <Recurso>();
if (alturaCasilla >= recursoIslaDatos.alturaMinima && alturaCasilla <= recursoIslaDatos.alturaMaxima)
{
recursosIsla.Add(recursoIsla);
}
}
int azarRecurso = Random.Range(0, recursosIsla.Count);
Recurso recurso1 = recursosIsla[azarRecurso].GetComponent <Recurso>();
int azarPoner = Random.Range(0, 100 + (int)alturaCasilla * 20);
if (azarPoner <= recurso1.porcentaje)
{
GameObject recurso2 = Instantiate(recursosIsla[azarRecurso]);
recurso2.transform.SetParent(casillas[x, z].prefab.transform);
recurso2.transform.localPosition = casillas[x, z].recursoPosicion;
int azarRotacion = Random.Range(0, 365);
recurso2.gameObject.transform.Rotate(Vector3.up, azarRotacion, Space.World);
casillas[x, z].recurso = recurso2;
casillas[x, z].recursoID = azarRecurso;
casillas[x, z].recursoPuesto = true;
if (recurso1.subrecursos != null)
{
MostrarSubrecursos(recurso1);
}
}
}
}
}
}
}
}
}
private bool VerificarPoner(Assets.Casilla[,] casillas, int x, int z)
{
if (Limites.Comprobar(x, 2, Escenario.instancia.tamañoEscenarioX) == true && Limites.Comprobar(z, 2, Escenario.instancia.tamañoEscenarioZ) == true)
{
if (casillas[x, z] != null)
{
if (casillas[x, z].posicion.y > 1f)
{
return(true);
}
}
}
return(false);
}
private int VerificarRampa1Rotacion270(int x, int z, float altura, Assets.Casilla[,] casillas)
{
if (Limites.Comprobar(z - 1, 2, Escenario.instancia.tamañoEscenarioZ) == true)
{
if (casillas[x, z - 1] != null)
{
if (Escenario.instancia.CalcularIDFinal(casillas[x, z - 1].id) < 5 && casillas[x, z - 1].idDebug != 99)
{
Assets.Isla isla = casillas[x, z - 1].isla;
Assets.Casilla rampa = new Assets.Casilla(5, 270, new Vector3(x, altura, z));
rampa.isla = isla;
rampa.idDebug = 99;
Escenario.instancia.PonerCasilla(rampa);
return(1);
}
}
}
return(0);
}
private int VerificarEsquina2Rotacion180(int x, int z, float altura, Assets.Casilla[,] casillas)
{
if (Limites.Comprobar(x + 1, 2, Escenario.instancia.tamañoEscenarioX) == true && Limites.Comprobar(z + 1, 2, Escenario.instancia.tamañoEscenarioZ) == true)
{
if (casillas[x + 1, z + 1] != null && ComprobarCosta(casillas[x + 1, z]) == 1 && ComprobarCosta(casillas[x, z + 1]) == 1)
{
if (Escenario.instancia.CalcularIDFinal(casillas[x + 1, z + 1].id) < 5 && casillas[x + 1, z + 1].idDebug != 99)
{
Assets.Isla isla = casillas[x + 1, z + 1].isla;
Assets.Casilla esquina = new Assets.Casilla(6, 180, new Vector3(x, altura, z));
esquina.isla = isla;
esquina.idDebug = 99;
Escenario.instancia.PonerCasilla(esquina);
return(1);
}
}
}
return(0);
}
public void Generar(Assets.Casilla[,] casillas, Assets.Isla islaCero, Assets.Objeto[] herramientas)
{
int x = ((int)islaCero.coordenadasMinimas.x + (int)islaCero.extensionMaxima.x) / 2;
int z = ((int)islaCero.coordenadasMinimas.y + (int)islaCero.extensionMaxima.y) / 2;
if (casillas[x, z] != null)
{
Vector3 posicion = casillas[x, z].prefab.gameObject.transform.position;
casillas[x, z].recursoPosible = false;
if (casillas[x, z].id != 0)
{
posicion.y = posicion.y + 1f;
}
Jugador.Movimientos.instancia.transform.position = posicion;
}
if (herramientas != null)
{
if (herramientas.Length > 0)
{
int i = 0;
while (i < herramientas.Length)
{
Jugador.Inventario.Inventario.instancia.AñadirObjeto(herramientas[i]);
if (i == 0)
{
Jugador.Inventario.Inventario.instancia.SeleccionarObjeto(i);
Jugador.Inventario.Inventario.instancia.EquiparBoton(true);
}
i += 1;
}
}
}
}
//-------------------------------------
private void VerificarHuecos(int x, int z, float altura, Assets.Casilla[,] casillas)
{
if (Limites.Comprobar(z + 1, 2, Escenario.instancia.tamañoEscenarioX) == true && Limites.Comprobar(z - 1, 2, Escenario.instancia.tamañoEscenarioZ) == true)
{
if (ComprobarCosta(casillas[x, z + 1]) == 2 && ComprobarCosta(casillas[x, z - 1]) == 2)
{
Assets.Isla isla = casillas[x, z + 1].isla;
Assets.Casilla plano = new Assets.Casilla(0, 0, new Vector3(x, altura + 0.5f, z));
plano.isla = isla;
Escenario.instancia.PonerCasilla(plano);
}
}
if (Limites.Comprobar(x + 1, 2, Escenario.instancia.tamañoEscenarioX) == true && Limites.Comprobar(x - 1, 2, Escenario.instancia.tamañoEscenarioZ) == true)
{
if (ComprobarCosta(casillas[x + 1, z]) == 2 && ComprobarCosta(casillas[x - 1, z]) == 2)
{
Assets.Isla isla = casillas[x + 1, z].isla;
Assets.Casilla plano = new Assets.Casilla(0, 0, new Vector3(x, altura + 0.5f, z));
plano.isla = isla;
Escenario.instancia.PonerCasilla(plano);
}
}
if (Limites.Comprobar(x + 1, 2, Escenario.instancia.tamañoEscenarioX) == true && Limites.Comprobar(x - 1, 2, Escenario.instancia.tamañoEscenarioX) == true && Limites.Comprobar(z + 1, 2, Escenario.instancia.tamañoEscenarioZ) == true && Limites.Comprobar(z - 1, 2, Escenario.instancia.tamañoEscenarioZ) == true)
{
if (ComprobarCosta(casillas[x + 1, z]) == 2 && ComprobarCosta(casillas[x, z + 1]) == 2 && ComprobarCosta(casillas[x - 1, z - 1]) == 2)
{
Assets.Isla isla = casillas[x + 1, z].isla;
Assets.Casilla plano = new Assets.Casilla(0, 0, new Vector3(x, altura + 0.5f, z));
plano.isla = isla;
Escenario.instancia.PonerCasilla(plano);
}
}
}
public void GenerarCasillas(Assets.Casilla[,] casillas, Assets.Isla[] islas, int limitesMapa)
{
LimpiarDatos(islas);
foreach (Assets.Isla isla in islas)
{
List <Vector3> listado = new List <Vector3>();
int montañasGenerar = (int)isla.extensionMaxima.x / 10 * (int)isla.extensionMaxima.y / 10;
int intentosGeneracion = montañasGenerar;
int i = 1;
while (i <= intentosGeneracion)
{
float alturaCasilla = (int)Random.Range(3, isla.alturaMaxima);
int posicionX = (int)Random.Range((int)isla.coordenadasMinimas.x + limitesMapa, (int)isla.coordenadasMinimas.x + (int)isla.extensionMaxima.x - limitesMapa);
int posicionZ = (int)Random.Range((int)isla.coordenadasMinimas.y + limitesMapa, (int)isla.coordenadasMinimas.y + (int)isla.extensionMaxima.y - limitesMapa);
bool añadir = true;
foreach (Assets.Casilla casilla in casillas)
{
if (casilla != null)
{
if (Enumerable.Range((int)(casilla.posicion.x - alturaCasilla), (int)(casilla.posicion.x + alturaCasilla)).Contains(posicionX))
{
if (Enumerable.Range((int)(casilla.posicion.z - alturaCasilla), (int)(casilla.posicion.z + alturaCasilla)).Contains(posicionZ))
{
añadir = false;
if (intentosGeneracion >= 0)
{
intentosGeneracion -= 1;
i -= 1;
}
}
}
}
}
if (Limites.Comprobar(posicionX, 2, Escenario.instancia.tamañoEscenarioX) == false || Limites.Comprobar(posicionZ, 2, Escenario.instancia.tamañoEscenarioZ) == false)
{
añadir = false;
}
if (añadir == true)
{
listado.Add(new Vector3(posicionX, alturaCasilla, posicionZ));
int desplazamiento = 0;
while (alturaCasilla >= 1)
{
int planos = (int)Random.Range(0, 4 + desplazamiento);
if (desplazamiento > 0)
{
int j = 0;
while (j <= planos)
{
int x = 0;
int z = 0;
int azar = (int)Random.Range(0, 12);
if (azar == 1)
{
x = 1 + (int)(desplazamiento * 2);
z = 1 + (int)(desplazamiento * 2);
}
else if (azar == 2)
{
x = 1 + (int)(desplazamiento * 2);
z = -1 - (int)(desplazamiento * 2);
}
else if (azar == 3)
{
x = -1 - (int)(desplazamiento * 2);
z = 1 + (int)(desplazamiento * 2);
}
else if (azar == 4)
{
x = -1 - (int)(desplazamiento * 2);
z = -1 - (int)(desplazamiento * 2);
}
else if (azar == 5 || azar == 6)
{
x = 2 + (int)(desplazamiento * 2);
z = Random.Range(-desplazamiento, desplazamiento);
}
else if (azar == 7 || azar == 8)
{
x = -2 - (int)(desplazamiento * 2);
z = Random.Range(-desplazamiento, desplazamiento);
}
else if (azar == 9 || azar == 10)
{
x = Random.Range(-desplazamiento, desplazamiento);
z = 2 + (int)(desplazamiento * 2);
}
else if (azar == 11 || azar == 12)
{
x = Random.Range(-desplazamiento, desplazamiento);
z = -2 - (int)(desplazamiento * 2);
}
if (azar > 0)
{
if (alturaCasilla == 1.5f || alturaCasilla == 2f)
{
for (int origenX = posicionX + x - 1; origenX < posicionX + x + 2; origenX++)
{
for (int origenZ = posicionZ + z - 1; origenZ < posicionZ + z + 2; origenZ++)
{
if (Limites.Comprobar(origenX, 2, (int)isla.extensionMaxima.x) == true && Limites.Comprobar(origenZ, 2, (int)isla.extensionMaxima.y) == true)
{
if (casillas[origenX, origenZ] == null)
{
listado.Add(new Vector3(origenX, alturaCasilla, origenZ));
}
}
}
}
}
else if (alturaCasilla == 1f)
{
for (int origenX = posicionX + x - 2; origenX < posicionX + x + 3; origenX++)
{
for (int origenZ = posicionZ + z - 2; origenZ < posicionZ + z + 3; origenZ++)
{
if (Limites.Comprobar(origenX, 2, (int)isla.extensionMaxima.x) == true && Limites.Comprobar(origenZ, 2, (int)isla.extensionMaxima.y) == true)
{
if (casillas[origenX, origenZ] == null)
{
listado.Add(new Vector3(origenX, alturaCasilla, origenZ));
}
}
}
}
}
else
{
if (Limites.Comprobar(posicionX + x, 2, (int)isla.extensionMaxima.x) == true && Limites.Comprobar(posicionZ + z, 2, (int)isla.extensionMaxima.y) == true)
{
listado.Add(new Vector3(posicionX + x, alturaCasilla, posicionZ + z));
}
}
}
j += 1;
}
}
alturaCasilla -= 0.5f;
desplazamiento += 1;
}
}
i += 1;
}
CopiarDatos(listado, isla.id);
}
}
public void Generar(Assets.Casilla[,] casillas, float altura)
{
Assets.Isla isla = null;
int rango = 3;
for (int x = 0; x < casillas.GetLength(0); x++)
{
for (int z = 0; z < casillas.GetLength(1); z++)
{
if (casillas[x, z] == null)
{
bool poner = false;
if (poner == false)
{
poner = VerificarPoner(casillas, x - rango, z - rango);
if (poner == true)
{
isla = casillas[x - rango, z - rango].isla;
}
}
if (poner == false)
{
poner = VerificarPoner(casillas, x - rango, z);
if (poner == true)
{
isla = casillas[x - rango, z].isla;
}
}
if (poner == false)
{
poner = VerificarPoner(casillas, x, z - rango);
if (poner == true)
{
isla = casillas[x, z - rango].isla;
}
}
if (poner == false)
{
poner = VerificarPoner(casillas, x + rango, z - rango);
if (poner == true)
{
isla = casillas[x + rango, z - rango].isla;
}
}
if (poner == false)
{
poner = VerificarPoner(casillas, x - rango, z + rango);
if (poner == true)
{
isla = casillas[x - rango, z + rango].isla;
}
}
if (poner == false)
{
poner = VerificarPoner(casillas, x, z + rango);
if (poner == true)
{
isla = casillas[x, z + rango].isla;
}
}
if (poner == false)
{
poner = VerificarPoner(casillas, x + rango, z);
if (poner == true)
{
isla = casillas[x + rango, z].isla;
}
}
if (poner == false)
{
poner = VerificarPoner(casillas, x + rango, z + rango);
if (poner == true)
{
isla = casillas[x + rango, z + rango].isla;
}
}
if (poner == true)
{
Assets.Casilla plano = new Assets.Casilla(isla.casillas[0].id, 0, new Vector3(x, altura, z));
plano.isla = isla;
Escenario.instancia.PonerCasilla(plano);
}
}
}
}
}
public void Generar(Assets.Casilla[,] casillas, float altura)
{
for (int x = 0; x < casillas.GetLength(0); x++)
{
for (int z = 0; z < casillas.GetLength(1); z++)
{
if (casillas[x, z] == null)
{
VerificarHuecos(x, z, altura, casillas);
}
}
}
for (int x = 0; x < casillas.GetLength(0); x++)
{
for (int z = 0; z < casillas.GetLength(1); z++)
{
if (casillas[x, z] == null)
{
int ocupado = 0;
//-------------------------------------
if (ocupado == 0)
{
ocupado += VerificarEsquina3Rotacion90(x, z, altura, casillas);
}
if (ocupado == 0)
{
ocupado += VerificarEsquina3Rotacion270(x, z, altura, casillas);
}
if (ocupado == 0)
{
ocupado += VerificarEsquina3Rotacion0(x, z, altura, casillas);
}
if (ocupado == 0)
{
ocupado += VerificarEsquina3Rotacion180(x, z, altura, casillas);
}
//-------------------------------------
if (ocupado == 0)
{
ocupado += VerificarEsquina2Rotacion90(x, z, altura, casillas);
}
if (ocupado == 0)
{
ocupado += VerificarEsquina2Rotacion270(x, z, altura, casillas);
}
if (ocupado == 0)
{
ocupado += VerificarEsquina2Rotacion0(x, z, altura, casillas);
}
if (ocupado == 0)
{
ocupado += VerificarEsquina2Rotacion180(x, z, altura, casillas);
}
//-------------------------------------
if (ocupado == 0)
{
ocupado += VerificarRampa1Rotacion180(x, z, altura, casillas);
}
if (ocupado == 0)
{
ocupado += VerificarRampa1Rotacion0(x, z, altura, casillas);
}
if (ocupado == 0)
{
ocupado += VerificarRampa1Rotacion270(x, z, altura, casillas);
}
if (ocupado == 0)
{
ocupado += VerificarRampa1Rotacion90(x, z, altura, casillas);
}
//-------------------------------------
if (ocupado == 0)
{
Assets.Casilla plano = new Assets.Casilla(Escenario.instancia.casillasDebug.Length - 1, 0, new Vector3(x, altura + 0.25f, z));
Escenario.instancia.PonerCasilla(plano);
}
}
}
}
}
public void Start()
{
if (Partida.Gestor.instancia.nuevaPartida == true)
{
int alturaMaxima = 1;
foreach (Assets.Isla isla in islas)
{
if (isla.alturaMaxima > alturaMaxima)
{
alturaMaxima = (int)isla.alturaMaxima;
}
tamañoEscenarioX = tamañoEscenarioX + (int)isla.extensionMaxima.x * 3;
tamañoEscenarioZ = tamañoEscenarioZ + (int)isla.extensionMaxima.y * 3;
}
casillas = new Assets.Casilla[tamañoEscenarioX, tamañoEscenarioZ];
if (aleatorio == true)
{
Vectores.instancia.GenerarCasillas(casillas, islas, limitesMapa);
}
int k = 0;
float altura = alturaMaxima;
int tope = (int)alturaMaxima * 2;
while (k < tope)
{
altura -= 0.5f;
if (altura <= 1f)
{
break;
}
try
{
GenerarNivel(altura);
}
catch (Exception fallo)
{
Debug.Log(fallo);
k -= 1;
}
k += 1;
}
//----------------------------------------------------------
if (llano == true)
{
Llano.instancia.Generar(casillas, altura);
}
if (agua == true)
{
altura -= 0.5f;
Agua.instancia.Generar(casillas, altura);
}
if (colocarJugador == true)
{
ColocarJugador.instancia.Generar(casillas, islas[0], herramientasJugador);
}
if (recursos == true)
{
Recursos.instancia.Generar(casillas);
}
}
}