public bool ComprobarCasilla3(Assets.Casilla casilla, float altura, int rotacion)
{
if (casilla != null)
{
if (ComprobarLimiteX((int)casilla.posicion.x, limitesMapa) == true && ComprobarLimiteZ((int)casilla.posicion.z, limitesMapa) == true)
{
if (casilla.posicion.y == (altura + 0.5f))
{
if (casilla.rotacion == rotacion)
{
if (coloresGeneracion == false)
{
if (casilla.id == 3)
{
return(true);
}
}
else
{
if (CalcularIDFinal(casilla.idDebug) == 3)
{
return(true);
}
}
}
}
}
}
return(false);
}
public bool ComprobarVacio(Assets.Casilla casilla)
{
if (casilla != null)
{
if (ComprobarLimiteX((int)casilla.posicion.x, 3) == true && ComprobarLimiteZ((int)casilla.posicion.z, 3) == true)
{
if (casillas[(int)casilla.posicion.x, (int)casilla.posicion.z] != null)
{
return(false);
}
}
}
return(true);
}
//-------------------------------------
private int ComprobarCosta(Assets.Casilla casilla)
{
if (casilla == null)
{
return(1);
}
else
{
if (casilla.idDebug == 99)
{
return(1);
}
else
{
return(2);
}
}
}
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);
}
//-------------------------------------
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 override void AtacarInput()
{
if (recetaConstruccion == null || vistaPrevia == null || puedeUbicarConstruccion == false)
{
return;
}
GameObject objetoConstruir = recetaConstruccion.prefab;
Vector3 coordenadas = vistaPrevia.transform.position;
if (vistaPrevia != null)
{
if (recetaConstruccion.tipo == Assets.Tipos.Construccion.Suelo || recetaConstruccion.tipo == Assets.Tipos.Construccion.Pared)
{
Coordenadas coordenadas2 = vistaPrevia.gameObject.GetComponent <Coordenadas>();
if (coordenadas2 != null)
{
Assets.Casilla casilla = Escenario.Generar.Escenario.instancia.casillas[coordenadas2.x, coordenadas2.z];
if (casilla != null)
{
if (recetaConstruccion.tipo == Assets.Tipos.Construccion.Suelo)
{
if (casilla.pisos == null)
{
casilla.pisos = new List <Assets.Piso>();
}
Assets.Piso piso = new Assets.Piso();
piso.suelo = recetaConstruccion.prefab;
casilla.pisos.Add(piso);
}
else if (recetaConstruccion.tipo == Assets.Tipos.Construccion.Pared)
{
if (casilla.pisos != null)
{
if (casilla.pisos.Count > 0)
{
Assets.Piso piso = casilla.pisos[casilla.pisos.Count - 1];
piso.pared = recetaConstruccion.prefab;
}
}
}
}
}
}
}
Instantiate(objetoConstruir, coordenadas, vistaPrevia.transform.rotation);
int i = 0;
while (i < recetaConstruccion.costes.Length)
{
int j = 0;
while (j < recetaConstruccion.costes[i].cantidad)
{
Inventario.Inventario.instancia.QuitarObjeto(recetaConstruccion.costes[i].objeto);
j += 1;
}
i += 1;
}
recetaConstruccion = null;
Destroy(vistaPrevia.gameObject);
vistaPrevia = null;
puedeUbicarConstruccion = false;
rotacionLibreEjeY = 0;
}
public void Update()
{
if (vistaPrevia != null && recetaConstruccion != null)
{
if (recetaConstruccion.tipo == Assets.Tipos.Construccion.Libre)
{
if (puedeRotar == true)
{
rotacionLibreEjeY = rotacionLibreEjeY + rotacionVelocidad * Time.deltaTime;
if (rotacionLibreEjeY > 360)
{
rotacionLibreEjeY = 0;
}
}
if (Time.time - ultimaUbicacionTiempo > ubicacionActualizacionVelocidad)
{
ultimaUbicacionTiempo = Time.time;
Ray ray = camara.ScreenPointToRay(new Vector3(Screen.width / 2, Screen.height / 2, 0));
RaycastHit hit;
if (Physics.Raycast(ray, out hit, ubicacionMaximaDistancia, ubicacionLayerMask) == true)
{
vistaPrevia.transform.position = hit.point;
vistaPrevia.transform.up = hit.normal;
vistaPrevia.transform.Rotate(new Vector3(0, rotacionLibreEjeY, 0), Space.Self);
VistaPreviaUbicar(vistaPrevia);
}
}
}
else if (recetaConstruccion.tipo == Assets.Tipos.Construccion.Suelo)
{
if (Time.time - ultimaUbicacionTiempo > ubicacionActualizacionVelocidad)
{
ultimaUbicacionTiempo = Time.time;
Ray ray = camara.ScreenPointToRay(new Vector3(Screen.width / 2, Screen.height / 2, 0));
RaycastHit hit;
if (Physics.Raycast(ray, out hit, ubicacionMaximaDistancia, ubicacionLayerMask) == true)
{
GameObject objeto = hit.collider.gameObject;
if (objeto != null)
{
Assets.Casilla casilla = null;
int x = 0;
int z = 0;
if (objeto.GetComponent <Coordenadas>() != null)
{
Coordenadas coordenadas = objeto.GetComponent <Coordenadas>();
x = coordenadas.x;
z = coordenadas.z;
casilla = Escenario.Generar.Escenario.instancia.casillas[x, z];
}
if (casilla != null)
{
if (casilla.construccionPosible == true && casilla.recursoPuesto == false)
{
if (casilla.posicionesSuelo != null)
{
if (casilla.posicionesSuelo.Count > 0)
{
bool enseñar = true;
Vector3 posicion = casilla.posicionesSuelo[0];
if (casilla.pisos != null)
{
if (casilla.pisos.Count > 0)
{
posicion.y = 2f * casilla.pisos.Count;
if (casilla.pisos.Count > 1)
{
if (casilla.pisos[casilla.pisos.Count - 1].pared is null)
{
enseñar = false;
}
}
}
}
if (enseñar == true)
{
vistaPrevia.transform.localPosition = posicion;
vistaPrevia.transform.up = hit.normal;
vistaPrevia.transform.SetParent(casilla.prefab.transform);
Coordenadas coordenadas = vistaPrevia.gameObject.AddComponent <Coordenadas>();
coordenadas.x = x;
coordenadas.z = z;
VistaPreviaUbicar(vistaPrevia);
}
}
}
}
}
}
}
}
}
else if (recetaConstruccion.tipo == Assets.Tipos.Construccion.Pared)
{
if (Time.time - ultimaUbicacionTiempo > ubicacionActualizacionVelocidad)
{
ultimaUbicacionTiempo = Time.time;
Ray ray = camara.ScreenPointToRay(new Vector3(Screen.width / 2, Screen.height / 2, 0));
RaycastHit hit;
if (Physics.Raycast(ray, out hit, ubicacionMaximaDistancia, ubicacionLayerMask) == true)
{
GameObject objeto = hit.collider.gameObject;
if (objeto != null)
{
Assets.Casilla casilla = null;
int x = 0;
int z = 0;
if (objeto.GetComponent <Coordenadas>() != null)
{
Coordenadas coordenadas = objeto.GetComponent <Coordenadas>();
x = coordenadas.x;
z = coordenadas.z;
casilla = Escenario.Generar.Escenario.instancia.casillas[x, z];
}
if (casilla != null)
{
if (casilla.pisos != null)
{
if (casilla.pisos.Count > 0)
{
if (casilla.pisos[casilla.pisos.Count - 1].suelo != null && casilla.pisos[casilla.pisos.Count - 1].pared == null)
{
Vector3 posicion = casilla.posicionesParedes[casilla.pisos[casilla.pisos.Count - 1].posicionPared];
//Altura-----------------
if (casilla.pisos != null)
{
if (casilla.pisos.Count > 2)
{
posicion.y = (2f * casilla.pisos.Count) + 0.5f - 2f;
}
else if (casilla.pisos.Count == 2)
{
posicion.y = casilla.pisos.Count + 0.5f;
}
}
//Rotacion---------------
if (puedeRotar == true)
{
float rotacionTemp = rotacionLibreEjeY;
rotacionLibreEjeY = rotacionLibreEjeY + rotacionVelocidad * Time.deltaTime;
Debug.Log(string.Format("{0} {1}", rotacionLibreEjeY, rotacionTemp));
if (rotacionLibreEjeY != rotacionTemp)
{
casilla.pisos[casilla.pisos.Count - 1].posicionPared += 1;
if (casilla.pisos[casilla.pisos.Count - 1].posicionPared > 0)
{
casilla.pisos[casilla.pisos.Count - 1].rotacionTemp = 90;
}
}
if (casilla.pisos[casilla.pisos.Count - 1].posicionPared > 3)
{
casilla.pisos[casilla.pisos.Count - 1].posicionPared = 0;
casilla.pisos[casilla.pisos.Count - 1].rotacionTemp = 90;
rotacionLibreEjeY = 0;
}
}
if (casilla.pisos[casilla.pisos.Count - 1].rotacionPared != (casilla.pisos[casilla.pisos.Count - 1].rotacionTemp * casilla.pisos[casilla.pisos.Count - 1].posicionPared))
{
vistaPrevia.transform.Rotate(new Vector3(0, casilla.pisos[casilla.pisos.Count - 1].rotacionTemp, 0), Space.Self);
casilla.pisos[casilla.pisos.Count - 1].rotacionPared = casilla.pisos[casilla.pisos.Count - 1].rotacionTemp * casilla.pisos[casilla.pisos.Count - 1].posicionPared;
}
vistaPrevia.transform.localPosition = posicion;
vistaPrevia.transform.SetParent(casilla.prefab.transform);
Coordenadas coordenadas = vistaPrevia.gameObject.AddComponent <Coordenadas>();
coordenadas.x = x;
coordenadas.z = z;
VistaPreviaUbicar(vistaPrevia);
}
}
}
}
}
}
}
}
}
}
private void Casillas(Datos partida)
{
Escenario.Generar.Escenario.instancia.casillas = new Assets.Casilla[partida.escenario.tamañoEscenarioX, partida.escenario.tamañoEscenarioZ];
int i = 0;
while (i < partida.casillas.Length)
{
GameObject prefab = null;
int idCasilla = 0;
Assets.Isla isla = null;
if (partida.casillas[i].idIsla != 9999)
{
foreach (Assets.Isla isla2 in Gestor.instancia.islas)
{
if (partida.casillas[i].idIsla == isla2.id)
{
foreach (Assets.Casilla casilla in isla2.casillas)
{
if (partida.casillas[i].idCasilla == casilla.id)
{
prefab = casilla.prefab;
idCasilla = casilla.id;
isla = isla2;
}
}
}
}
}
else
{
Assets.Casilla agua = Escenario.Generar.Escenario.instancia.casillasDebug[Escenario.Generar.Escenario.instancia.casillasDebug.Length - 1];
prefab = agua.prefab;
idCasilla = agua.id;
}
if (prefab != null)
{
Vector3 posicionFinal = partida.casillas[i].coordenadas.ObtenerVector3();
int x = (int)posicionFinal.x;
int z = (int)posicionFinal.z;
if (partida.escenario.casillasEscala != 0.5f)
{
posicionFinal.x = (posicionFinal.x + posicionFinal.x * (partida.escenario.casillasEscala * 1.5f)) - (partida.escenario.tamañoEscenarioX / (partida.escenario.casillasEscala + 0.5f));
posicionFinal.y = posicionFinal.y + posicionFinal.y * (partida.escenario.casillasEscala * 1.5f);
posicionFinal.z = (posicionFinal.z + posicionFinal.z * (partida.escenario.casillasEscala * 1.5f)) - (partida.escenario.tamañoEscenarioZ / (partida.escenario.casillasEscala + 0.5f));
}
GameObject casilla2 = Instantiate(prefab, posicionFinal, Quaternion.identity);
casilla2.gameObject.transform.Rotate(Vector3.up, partida.casillas[i].rotacion, Space.World);
casilla2.gameObject.transform.localScale = new Vector3(partida.escenario.casillasEscala, partida.escenario.casillasEscala, partida.escenario.casillasEscala);
Assets.Casilla casilla3 = new Assets.Casilla(idCasilla, partida.casillas[i].rotacion, partida.casillas[i].coordenadas.ObtenerVector3());
casilla3.id = idCasilla;
casilla3.prefab = casilla2;
casilla3.prefab.gameObject.layer = LayerMask.NameToLayer("Terreno");
Escenario.Generar.Escenario.instancia.casillas[x, z] = casilla3;
if (isla != null)
{
casilla3.isla = isla;
casilla3.recursoPuesto = partida.casillas[i].recursoPuesto;
if (partida.casillas[i].recursoPuesto == true)
{
GameObject recurso1 = Instantiate(isla.recursos[partida.casillas[i].recurso.id]);
recurso1.transform.SetParent(Escenario.Generar.Escenario.instancia.casillas[x, z].prefab.transform);
recurso1.transform.localPosition = partida.casillas[i].recurso.posicion.ObtenerVector3();
recurso1.gameObject.transform.Rotate(partida.casillas[i].recurso.rotacion.ObtenerVector3(), Space.World);
Escenario.Recurso recurso2 = recurso1.GetComponent <Escenario.Recurso>();
recurso2.cantidad = partida.casillas[i].recurso.cantidad;
if (partida.casillas[i].recurso.subrecursos.Length > 0)
{
int j = 0;
while (j < recurso2.subrecursos.Count)
{
if (recurso2.subrecursos[j] != null)
{
recurso2.subrecursos[j].SetActive(partida.casillas[i].recurso.subrecursos[j]);
}
j += 1;
}
}
}
}
}
i += 1;
}
}
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 PonerCasilla(Assets.Casilla casilla)
{
Assets.Casilla[] casillasFinal;
int id = casilla.id;
int idDebug = casilla.idDebug;
if (coloresGeneracion == false)
{
if (idDebug != 99)
{
idDebug = id;
}
if (id != casillasDebug.Length - 1 && idDebug != 99)
{
id = CalcularIDFinal(id);
}
if (casilla.isla != null)
{
casillasFinal = casilla.isla.casillas;
}
else
{
casillasFinal = casillasDebug;
}
}
else
{
if (idDebug == 99)
{
if (casilla.isla != null)
{
casillasFinal = casilla.isla.casillas;
}
else
{
casillasFinal = casillasDebug;
}
}
else
{
casillasFinal = casillasDebug;
idDebug = id;
}
}
int x = (int)casilla.posicion.x;
int z = (int)casilla.posicion.z;
if (Limites.Comprobar(x, 3, tamañoEscenarioX) == true && Limites.Comprobar(z, 3, tamañoEscenarioZ) == true)
{
if (casillas[x, z] == null)
{
Vector3 posicionFinal = casilla.posicion;
if (casillasEscala != 0.5f)
{
posicionFinal.x = (posicionFinal.x + posicionFinal.x * (casillasEscala * 1.5f)) - (tamañoEscenarioX / (casillasEscala + 0.5f));
posicionFinal.y = posicionFinal.y + posicionFinal.y * (casillasEscala * 1.5f);
posicionFinal.z = (posicionFinal.z + posicionFinal.z * (casillasEscala * 1.5f)) - (tamañoEscenarioZ / (casillasEscala + 0.5f));
}
GameObject casilla2 = Instantiate(casillasFinal[id].prefab, posicionFinal, Quaternion.identity);
casilla2.gameObject.transform.Rotate(Vector3.up, casilla.rotacion, Space.World);
casilla2.gameObject.transform.localScale = new Vector3(casillasEscala, casillasEscala, casillasEscala);
Coordenadas coordenadas = casilla2.gameObject.AddComponent <Coordenadas>();
coordenadas.x = x;
coordenadas.z = z;
Assets.Casilla casilla3 = new Assets.Casilla(id, casilla.rotacion, casilla.posicion);
casilla3.id = id;
casilla3.idDebug = idDebug;
casilla3.prefab = casilla2;
casilla3.prefab.gameObject.layer = LayerMask.NameToLayer("Terreno");
casilla3.isla = casilla.isla;
casilla3.recursoPuesto = false;
casilla3.recursoPosible = casillasFinal[id].recursoPosible;
casilla3.recursoPosicion = casillasFinal[id].recursoPosicion;
casilla3.construccionPosible = casillasFinal[id].construccionPosible;
casilla3.posicionesSuelo = casillasFinal[id].posicionesSuelo;
casilla3.posicionesParedes = casillasFinal[id].posicionesParedes;
casillas[x, z] = casilla3;
}
}
}
//------------------------------------------------------------------------------------------------------------------------------------
private void GenerarNivel(float altura)
{
foreach (Assets.Isla isla in islas)
{
Partida.PartidaIsla isla2 = Vectores.instancia.LeerDatos(isla.id);
foreach (Partida.PartidaCasilla casilla in isla2.casillas)
{
Vector3 casilla2 = casilla.coordenadas.ObtenerVector3();
if (altura == casilla2.y)
{
if (Limites.Comprobar((int)casilla2.x, 3, tamañoEscenarioX) == true && Limites.Comprobar((int)casilla2.z, 3, tamañoEscenarioZ) == true)
{
if (casillas[(int)casilla2.x, (int)casilla2.z] == null)
{
Assets.Casilla casilla3 = new Assets.Casilla(0, 0, casilla2)
{
isla = isla
};
PonerCasilla(casilla3);
}
}
}
}
}
foreach (Assets.Casilla subcasilla in casillas)
{
if (subcasilla != null)
{
int x = (int)subcasilla.posicion.x;
int z = (int)subcasilla.posicion.z;
float y = subcasilla.posicion.y;
y = y - 0.5f;
if (y < 0.0f)
{
y = 0.0f;
}
if ((y > 0) && (altura == subcasilla.posicion.y) && Limites.Comprobar(x, 2, tamañoEscenarioX) == true && Limites.Comprobar(z, 2, tamañoEscenarioZ) == true)
{
if (casillas[x - 1, z - 1] == null)
{
Colores.instancia.Casilla_Xmenos1_Zmenos1(x, y, z);
}
if (casillas[x - 1, z + 1] == null)
{
Colores.instancia.Casilla_Xmenos1_Zmas1(x, y, z);
}
if (casillas[x + 1, z - 1] == null)
{
Colores.instancia.Casilla_Xmas1_Zmenos1(x, y, z);
}
if (casillas[x + 1, z + 1] == null)
{
Colores.instancia.Casilla_Xmas1_Zmas1(x, y, z);
}
if (casillas[x, z - 1] == null)
{
Colores.instancia.Casilla_X0_Zmenos1(x, y, z);
}
if (casillas[x - 1, z] == null)
{
Colores.instancia.Casilla_Xmenos1_Z0(x, y, z);
}
if (casillas[x, z + 1] == null)
{
Colores.instancia.Casilla_X0_Zmas1(x, y, z);
}
if (casillas[x + 1, z] == null)
{
Colores.instancia.Casilla_Xmas1_Z0(x, y, z);
}
}
}
}
}
