// private void cargarJuego() {
// int w = saveGame.heightmapW;
// int h = saveGame.heightmapH;
// Color[] pixels = new Color[w * h];
// for (int i = 0; i < w * h; i++) {
// float temp = saveGame.heightmapData[i];
// pixels[i] = new Color(temp, temp, temp);
// }
// if (texturaBase.width != w || texturaBase.height != h) {
// Debug.LogError("Las dimensiones de las texturas no coinciden!");
// }
// texturaBase.SetPixels(pixels);
// texturaBase.Apply();
// estado = 1;
// }
//Menus personalizados --------------------------------------------------------------------------------------------------------------------
private void menuPrincipal()
{
GUILayout.BeginArea(new Rect((float)cuantoW * 20.5f, cuantoH * 20, cuantoW * 7, cuantoH * 5));
GUILayout.BeginVertical();
if (GUILayout.Button(new GUIContent("Comenzar juego", "Comenzar un juego nuevo"), "boton_menu_1"))
{
pixels = new Color[texturaBase.width * texturaBase.height];
FuncTablero.inicializa(texturaBase);
faseCreacion = 0;
paso1Completado = false;
// objetoRoca.renderer.enabled = true;
objetoRoca.animation.Play("HologramaAparecer");
Camera.main.animation.Play("AcercarseHolograma");
estado = 5;
}
if (GUILayout.Button(new GUIContent("Cargar", "Acceder a las partidas guardadas"), "boton_menu_2"))
{
estado = 6;
}
if (GUILayout.Button(new GUIContent("Opciones", "Acceder a las opciones"), "boton_menu_3"))
{
// Camera.main.animation.Play("AcercarsePantalla");
estado = 2;
}
if (GUILayout.Button(new GUIContent("Cr\u00e9ditos", "Visualiza los cr\u00e9ditos"), "boton_menu_3")) //U+00E9 es el caracter unicode 'é'
{
estado = 3;
}
if (GUILayout.Button(new GUIContent("Salir", "Salir de este juego"), "boton_menu_4"))
{
estado = 4;
}
GUILayout.EndVertical();
GUILayout.EndArea();
}
private bool hechaCarga = false; //Indica si se ha llevado a cabo una carga
//Update y transiciones de estados -------------------------------------------------------------------------------------------------------
void Awake()
{
Random.seed = System.DateTime.Now.Millisecond;
UnityEngine.Random.seed = System.DateTime.Now.Millisecond;
Debug.Log(FuncTablero.formateaTiempo() + ": Iniciando el script Principal...");
//Se busca el objeto con los valores guardados en la escena inicial, si lo hubiera
contenedor = GameObject.FindGameObjectWithTag("Carga");
if (contenedor == null) //Si el objeto no existe, crear el planeta de cero
{
Debug.Log(FuncTablero.formateaTiempo() + ": No encontrado contenedor, iniciando creacion inicial...");
creacionInicial();
contenedor = new GameObject("Contenedor");
contenedor.tag = "Carga";
contenedor.AddComponent <ValoresCarga>();
}
else //Si el objeto existe, cargar los valores necesarios
{
Debug.Log(FuncTablero.formateaTiempo() + ": Encontrado contenedor, cargando...");
ValoresCarga cont = contenedor.GetComponent <ValoresCarga>();
creacionCarga(cont);
hechaCarga = true;
}
Debug.Log(FuncTablero.formateaTiempo() + ": Completada la creacion del planeta.");
mejoras = GameObject.FindGameObjectWithTag("Mejoras").GetComponent <MejorasNave>();
interfaz = gameObject.GetComponent <InterfazPrincipal>();
materiales = GameObject.FindGameObjectWithTag("Materiales").GetComponent <Materiales> ();
}
private IEnumerator creacionParte3()
{
trabajando = true;
progreso = 0.0f;
GUI.enabled = false;
Debug.Log(FuncTablero.formateaTiempo() + ": Iniciando creacionParte3().");
Debug.Log(FuncTablero.formateaTiempo() + ": Creando el tablero...");
yield return(new WaitForSeconds(0.1f));
Casilla[,] tablero = FuncTablero.iniciaTablero(texturaBase, texHabitats, texHabitatsEstetica, texElems, rocaMesh, Vector3.zero);
progreso = 0.7f;
Debug.Log(FuncTablero.formateaTiempo() + ": Creando la vida...");
yield return(new WaitForSeconds(0.01f));
vida = new Vida(tablero);
progreso = 1.0f;
Debug.Log(FuncTablero.formateaTiempo() + ": Completado creacionParte3().");
yield return(new WaitForSeconds(0.01f));
progreso = 0.0f;
GUI.enabled = true;
trabajando = false;
faseCreacion = 0;
estado = 1;
}
public float escalaTiempo = 1.0f; //La escala temporal a la que se updateará todo
//Tipos especiales ----------------------------------------------------------------------------------------------------------------------
//Update y transiciones de estados -------------------------------------------------------------------------------------------------------
void Awake()
{
Random.seed = System.DateTime.Now.Millisecond;
UnityEngine.Random.seed = System.DateTime.Now.Millisecond;
Debug.Log(FuncTablero.formateaTiempo() + ": Iniciando el script Pruebas. Creacion inicial...");
creacionInicial();
Debug.Log(FuncTablero.formateaTiempo() + ": Completada la creacion del planeta.");
}
//Funciones basicas ----------------------------------------------------------------------------------------------------------------------
void Awake()
{
Debug.Log(FuncTablero.formateaTiempo() + ": Iniciando el metodo Awake() de la escena inicial...");
miObjeto = this.transform;
GameObject[] cadena = GameObject.FindGameObjectsWithTag("Carga");
if (cadena.Length > 1)
{
contenedorTexturas = cadena[0];
DontDestroyOnLoad(cadena[0]);
for (int i = 1; i < cadena.Length; i++)
{
Destroy(cadena[i]);
}
}
else
{
contenedorTexturas = cadena[0];
DontDestroyOnLoad(cadena[0]);
}
if (PlayerPrefs.HasKey("MusicaOn"))
{
if (PlayerPrefs.GetInt("MusicaOn") == 1)
{
musicaOn = true;
}
else
{
musicaOn = false;
}
}
if (PlayerPrefs.HasKey("MusicaVol"))
{
musicaVol = PlayerPrefs.GetFloat("MusicaVol");
}
if (PlayerPrefs.HasKey("SfxOn"))
{
if (PlayerPrefs.GetInt("SfxOn") == 1)
{
sfxOn = true;
}
else
{
sfxOn = false;
}
}
if (PlayerPrefs.HasKey("SfxVol"))
{
sfxVol = PlayerPrefs.GetFloat("SfxVol");
}
SaveLoad.compruebaRuta();
numSaves = SaveLoad.FileCount();
nombresSaves = new string[numSaves];
nombresSaves = SaveLoad.getFileNames();
objetoRoca.renderer.sharedMaterials[1].SetFloat("_nivelMar", nivelAguaInit);
objetoRoca.renderer.sharedMaterials[1].SetFloat("_tamPlaya", tamanoPlayasInit);
Debug.Log(FuncTablero.formateaTiempo() + ": Completado el metodo Awake().");
}
public void rellenaContenedor(ref ValoresCarga contenedor)
{
contenedor.texturaBase = objetoRoca.renderer.sharedMaterial.mainTexture as Texture2D;
contenedor.texturaElementos = objetoRoca.renderer.sharedMaterials[3].mainTexture as Texture2D;
contenedor.texturaHabitats = objetoRoca.renderer.sharedMaterials[1].GetTexture("_FiltroTex") as Texture2D;
contenedor.texturaHabsEstetica = objetoRoca.renderer.sharedMaterials[1].mainTexture as Texture2D;
contenedor.vida = vida;
contenedor.roca = objetoRoca.GetComponent <MeshFilter>().mesh;
contenedor.agua = objetoOceano.GetComponent <MeshFilter>().mesh;
contenedor.nivelAgua = FuncTablero.getNivelAgua();
contenedor.tamanoPlaya = FuncTablero.getTamanoPlaya();
}
private void creacionInicial()
{
Debug.Log(FuncTablero.formateaTiempo() + ": Iniciando la creacion desde cero...");
//Trabajar con la textura Textura_Planeta y crear el mapa lógico a la vez
Texture2D texturaBase = objetoRoca.renderer.sharedMaterial.mainTexture as Texture2D;
Color[] pixels = new Color[texturaBase.width * texturaBase.height];
FuncTablero.inicializa(texturaBase);
Debug.Log(FuncTablero.formateaTiempo() + ": Creando ruido...");
pixels = FuncTablero.ruidoTextura(); //Se crea el ruido para la textura base y normales...
Debug.Log(FuncTablero.formateaTiempo() + ": Completado. Suavizando polos y bordes...");
pixels = FuncTablero.suavizaBordeTex(pixels, texturaBase.width / 20); //Se suaviza el borde lateral...
pixels = FuncTablero.suavizaPoloTex(pixels); //Se suavizan los polos...
Debug.Log(FuncTablero.formateaTiempo() + ": Completado. Aplicando cambios...");
texturaBase.SetPixels(pixels);
texturaBase.Apply();
Debug.Log(FuncTablero.formateaTiempo() + ": Completado. Extruyendo vertices de la roca...");
float extrusion = 0.45f;
MeshFilter Roca = objetoRoca.GetComponent <MeshFilter>();
Mesh meshTemp = Roca.mesh;
meshTemp = FuncTablero.extruyeVerticesTex(meshTemp, texturaBase, extrusion, objetoRoca.transform.position);
Roca.mesh = meshTemp;
Debug.Log(FuncTablero.formateaTiempo() + ": Completado. Construyendo collider...");
//Se añade el collider aqui, para que directamente tenga la mesh adecuada
objetoRoca.AddComponent <MeshCollider>();
objetoRoca.GetComponent <MeshCollider>().sharedMesh = meshTemp;
Debug.Log(FuncTablero.formateaTiempo() + ": Completado. Calculando y extruyendo vertices del oceano...");
MeshFilter Agua = objetoOceano.GetComponent <MeshFilter>();
Mesh meshAgua = Agua.mesh;
meshAgua = FuncTablero.extruyeVerticesValor(meshAgua, FuncTablero.getNivelAgua(), extrusion, objetoOceano.transform.position);
Agua.mesh = meshAgua;
Debug.Log(FuncTablero.formateaTiempo() + ": Completado. Rellenando detalles...");
//se ajusta la propiedad de nivel de agua del shader
objetoOceano.renderer.sharedMaterial.SetFloat("_nivelMar", FuncTablero.getNivelAgua());
objetoOceano.renderer.sharedMaterial.SetFloat("_tamPlaya", FuncTablero.getTamanoPlaya());
Debug.Log(FuncTablero.formateaTiempo() + ": Terminado. Cargando texturas de habitats...");
//obtener la textura de habitats del array de materiales de roca. Habitats esta en la 1ª posicion.
Texture2D texElems = objetoRoca.renderer.sharedMaterials[2].mainTexture as Texture2D;
//Texture2D texPlantas = objetoRoca.renderer.sharedMaterials[2].mainTexture as Texture2D;
Texture2D texHabitatsEstetica = objetoRoca.renderer.sharedMaterials[1].mainTexture as Texture2D;
Texture2D texHabitats = objetoRoca.renderer.sharedMaterials[1].GetTexture("_FiltroTex") as Texture2D;
Debug.Log(FuncTablero.formateaTiempo() + ": Terminado. Creando el tablero...");
Casilla[,] tablero = FuncTablero.iniciaTablero(texturaBase, texHabitats, texHabitatsEstetica, texElems, Roca.mesh, objetoRoca.transform.position);
Debug.Log(FuncTablero.formateaTiempo() + ": Terminado. Creando Vida...");
vida = new Vida(tablero, objetoRoca.transform);
Debug.Log(FuncTablero.formateaTiempo() + ": Completada la creacion del planeta.");
}
private void creacionCarga(ValoresCarga contenedor)
{
Debug.Log(FuncTablero.formateaTiempo() + ": Iniciando el script de carga de valores...");
Texture2D texBase = contenedor.texturaBase;
FuncTablero.inicializa(texBase);
Mesh rocaMesh = contenedor.roca;
Mesh aguaMesh = contenedor.agua;
float nivelAgua = contenedor.nivelAgua;
float tamanoPlaya = contenedor.tamanoPlaya;
//Trabajar con la textura Textura_Planeta y crear el mapa lógico a la vez
Debug.Log(FuncTablero.formateaTiempo() + ": Aplicando textura de ruido...");
Texture2D texturaBase = objetoRoca.renderer.sharedMaterial.mainTexture as Texture2D;
texturaBase = texBase;
texturaBase.Apply();
Debug.Log(FuncTablero.formateaTiempo() + ": Asignando Mesh a la roca...");
MeshFilter Roca = objetoRoca.GetComponent <MeshFilter>();
Roca.mesh = rocaMesh;
//Se añade el collider aqui, para que directamente tenga la mesh adecuada
Debug.Log(FuncTablero.formateaTiempo() + ": Creando collider de la roca...");
objetoRoca.AddComponent <MeshCollider>();
objetoRoca.GetComponent <MeshCollider>().sharedMesh = rocaMesh;
Debug.Log(FuncTablero.formateaTiempo() + ": Asignando Mesh al oceano...");
MeshFilter Agua = objetoOceano.GetComponent <MeshFilter>();
Agua.mesh = aguaMesh;
Debug.Log(FuncTablero.formateaTiempo() + ": Completando detalles...");
//se ajusta la propiedad de nivel de agua del shader
objetoOceano.renderer.sharedMaterial.SetFloat("_nivelMar", nivelAgua);
objetoOceano.renderer.sharedMaterial.SetFloat("_tamPlaya", tamanoPlaya);
Debug.Log(FuncTablero.formateaTiempo() + ": Cargando texturas de habitats...");
//obtener la textura de habitats del array de materiales de roca. Habitats esta en la 1ª posicion.
objetoRoca.renderer.sharedMaterials[2].mainTexture = contenedor.texturaElementos;
objetoRoca.renderer.sharedMaterials[1].mainTexture = contenedor.texturaHabsEstetica;
Texture2D texHabitats = objetoRoca.renderer.sharedMaterials[1].GetTexture("_FiltroTex") as Texture2D;
texHabitats = contenedor.texturaHabitats;
objetoRoca.renderer.sharedMaterials[1].SetTexture("_FiltroTex", texHabitats);
Debug.Log(FuncTablero.formateaTiempo() + ": Cargando la vida...");
vida = new Vida(contenedor.vida);
vida.setObjetoRoca(objetoRoca.transform);
Debug.Log(FuncTablero.formateaTiempo() + ": Carga completada.");
}
private IEnumerator creacionParte2()
{
trabajando = true;
progreso = 0.0f;
GUI.enabled = false;
Debug.Log(FuncTablero.formateaTiempo() + ": Iniciando creacionParte2().");
yield return(new WaitForSeconds(0.1f));
progreso = 0.1f;
Debug.Log(FuncTablero.formateaTiempo() + ": Instanciando la esfera roca...");
yield return(new WaitForSeconds(0.01f));
Mesh meshTemp = GameObject.Instantiate(meshEsfera) as Mesh;
progreso = 0.2f;
Debug.Log(FuncTablero.formateaTiempo() + ": Extruyendo vertices de roca...");
yield return(new WaitForSeconds(0.01f));
meshTemp = FuncTablero.extruyeVerticesTex(meshTemp, texturaBase, 0.45f, new Vector3(0.0f, 0.0f, 0.0f));
progreso = 0.6f;
yield return(new WaitForSeconds(0.01f));
rocaMesh = meshTemp;
Debug.Log(FuncTablero.formateaTiempo() + ": Instanciando la esfera agua...");
yield return(new WaitForSeconds(0.01f));
Mesh meshAgua = GameObject.Instantiate(meshEsfera) as Mesh;
progreso = 0.7f;
Debug.Log(FuncTablero.formateaTiempo() + ": Extruyendo vertices de agua...");
yield return(new WaitForSeconds(0.01f));
meshAgua = FuncTablero.extruyeVerticesValor(meshAgua, nivelAguaInit, 0.45f, new Vector3(0.0f, 0.0f, 0.0f));
aguaMesh = meshAgua;
progreso = 1.0f;
Debug.Log(FuncTablero.formateaTiempo() + ": Completada creacionParte2().");
yield return(new WaitForSeconds(0.01f));
nombrePlaneta = "PL" + Random.Range(1, 50000).ToString();
nombreEstrella = "SP" + Random.Range(200, 6000).ToString();
progreso = 0.0f;
trabajando = false;
GUI.enabled = true;
faseCreacion = 2;
}
public void rellenaContenedor(ref ValoresCarga contenedor)
{
contenedor.texturaBase = objetoRoca.renderer.sharedMaterial.mainTexture as Texture2D;
contenedor.texturaElementos = objetoRoca.renderer.sharedMaterials[2].mainTexture as Texture2D;
contenedor.texturaHabitats = objetoRoca.renderer.sharedMaterials[1].GetTexture("_FiltroTex") as Texture2D;
contenedor.texturaHabsEstetica = objetoRoca.renderer.sharedMaterials[1].mainTexture as Texture2D;
contenedor.vida = vida;
contenedor.roca = objetoRoca.GetComponent <MeshFilter>().mesh;
contenedor.agua = objetoOceano.GetComponent <MeshFilter>().mesh;
contenedor.nivelAgua = FuncTablero.getNivelAgua();
contenedor.tamanoPlaya = FuncTablero.getTamanoPlaya();
contenedor.energia = energia;
contenedor.compBas = componentesBasicos;
contenedor.compAdv = componentesAvanzados;
contenedor.matBio = materialBiologico;
contenedor.mejorasCompradas = mejoras.mejorasCompradas;
contenedor.etapaJuego = (int)interfaz.etapaJuego;
}
//Devuelve true si se ha producido una colision con el planeta y además las coordenadas de la casilla del tablero en la que ha impactado el raycast (en caso de producirse)
public bool raycastRoca(Vector3 posicion, ref int x, ref int y, out RaycastHit hit)
{
//RaycastHit hit;
Ray ray = Camera.main.ScreenPointToRay(posicion);
if (objetoRoca.collider.Raycast(ray, out hit, Mathf.Infinity))
{
double xTemp = hit.textureCoord.x;
double yTemp = hit.textureCoord.y;
Texture2D tex = objetoRoca.renderer.sharedMaterial.mainTexture as Texture2D;
xTemp = xTemp * tex.width / FuncTablero.getRelTexTabAncho();
yTemp = (yTemp * tex.height / FuncTablero.getRelTexTabAlto());
x = (int)xTemp;
y = (int)yTemp;
FuncTablero.convierteCoordenadas(ref y, ref x);
return(true);
}
else
{
return(false);
}
}
private IEnumerator creacionParte1()
{
trabajando = true;
progreso = 0.0f;
GUI.enabled = false;
Debug.Log(FuncTablero.formateaTiempo() + ": Iniciando creacionParte1()...");
yield return(new WaitForSeconds(0.1f));
progreso = 0.1f;
Debug.Log(FuncTablero.formateaTiempo() + ": Creando ruido...");
yield return(new WaitForSeconds(0.01f));
pixels = FuncTablero.ruidoTextura(); //Se crea el ruido para la textura base y normales...
progreso = 0.7f;
Debug.Log(FuncTablero.formateaTiempo() + ": Completado. Suavizando borde...");
yield return(new WaitForSeconds(0.01f));
pixels = FuncTablero.suavizaBordeTex(pixels, texturaBase.width / 20); //Se suaviza el borde lateral...
progreso = 0.8f;
Debug.Log(FuncTablero.formateaTiempo() + ": Completado. Suavizando polos...");
yield return(new WaitForSeconds(0.01f));
pixels = FuncTablero.suavizaPoloTex(pixels); //Se suavizan los polos...
progreso = 0.9f;
Debug.Log(FuncTablero.formateaTiempo() + ": Completado. Aplicando cambios...");
yield return(new WaitForSeconds(0.01f));
texturaBase.SetPixels(pixels);
texturaBase.Apply();
progreso = 1.0f;
Debug.Log(FuncTablero.formateaTiempo() + ": Completada creacionParte1().");
yield return(new WaitForSeconds(0.01f));
progreso = 0.0f;
trabajando = false;
GUI.enabled = true;
paso1Completado = true;
}
private void creacionParte2Interfaz()
{
GUI.Label(new Rect(cuantoW * 2, cuantoH * 7, cuantoW * 15, cuantoH * 1), "Especifique los detalles de la orografia del planeta deseado.", "label_centrada");
GUI.Box(new Rect(cuantoW, cuantoH * 9, cuantoW * 10, cuantoH * 19), "");
GUILayout.BeginArea(new Rect(cuantoW, cuantoH * 9, cuantoW * 10, cuantoH * 15));
GUILayout.BeginVertical();
//Controles para alterar el tipo de terreno ya creado: tipo de planeta a escoger con la "rampa" adecuada, altura de las montañas,
//cantidad de agua, etc.
//Despues de este paso se colorea el mapa creado.
GUILayout.Label("Nivel del agua", "label_centrada");
GUILayout.BeginHorizontal();
GUILayout.Label("Min");
nivelAguaInit = GUILayout.HorizontalSlider(nivelAguaInit, 0.15f, 0.45f);
GUILayout.Label("Max");
GUILayout.EndHorizontal();
float nivelAguaTemp = Mathf.Lerp(0.0f, 1.0f, (nivelAguaInit - 0.15f) / (0.45f - 0.15f));
if (nivelAguaTemp <= 0.25f)
{
GUILayout.Label("Muy bajo");
}
else if (nivelAguaTemp <= 0.5f)
{
GUILayout.Label("Bajo");
}
else if (nivelAguaTemp <= 0.75f)
{
GUILayout.Label("Alto");
}
else
{
GUILayout.Label("Muy alto");
}
if (GUI.changed)
{
objetoRoca.renderer.sharedMaterials[1].SetFloat("_nivelMar", nivelAguaInit);
}
GUILayout.Label("Temperatura del planeta", "label_centrada");
GUILayout.BeginHorizontal();
GUILayout.Label("Min");
temperaturaInit = GUILayout.HorizontalSlider(temperaturaInit, 0.0f, 1.0f);
GUILayout.Label("Max");
GUILayout.EndHorizontal();
if (temperaturaInit <= 0.25f)
{
GUILayout.Label("Helado");
}
else if (temperaturaInit <= 0.5f)
{
GUILayout.Label("Frio");
}
else if (temperaturaInit <= 0.75f)
{
GUILayout.Label("Calido");
}
else
{
GUILayout.Label("Abrasador");
}
GUILayout.Label("Longitud de las playas", "label_centrada");
GUILayout.BeginHorizontal();
GUILayout.Label("Min");
tamanoPlayasInit = GUILayout.HorizontalSlider(tamanoPlayasInit, 0.02f, 0.06f);
GUILayout.Label("Max");
GUILayout.EndHorizontal();
float tamanoPlayasTemp = Mathf.Lerp(0.0f, 1.0f, (tamanoPlayasInit - 0.02f) / (0.06f - 0.02f));
if (tamanoPlayasTemp <= 0.25f)
{
GUILayout.Label("Muy peque\u00f1as");
}
else if (tamanoPlayasTemp <= 0.5f)
{
GUILayout.Label("Cortas");
}
else if (tamanoPlayasTemp <= 0.75f)
{
GUILayout.Label("Largas");
}
else
{
GUILayout.Label("Enormes");
}
// GUILayout.Label(tamanoPlayasInit.ToString());
if (GUI.changed)
{
objetoRoca.renderer.sharedMaterials[1].SetFloat("_tamPlaya", tamanoPlayasInit);
}
GUILayout.EndVertical();
GUILayout.EndArea();
GUILayout.BeginArea(new Rect(cuantoW * 12, cuantoH * 28, cuantoW * 35, cuantoH * 2));
GUILayout.BeginHorizontal();
if (GUILayout.Button(new GUIContent("Volver", "Volver a la primera fase"), GUILayout.Height(cuantoH)))
{
faseCreacion = 0;
}
GUILayout.Space(cuantoW * 28);
if (GUILayout.Button(new GUIContent("Siguiente", "Pasar a la tercera fase"), GUILayout.Height(cuantoH)))
{
FuncTablero.setNivelAgua(nivelAguaInit);
FuncTablero.setTemperatura(temperaturaInit);
FuncTablero.setTamanoPlaya(tamanoPlayasInit);
StartCoroutine(creacionParte2());
}
GUILayout.EndHorizontal();
GUILayout.EndArea();
}
private void creacionParte1Interfaz()
{
GUI.Label(new Rect(cuantoW * 2, cuantoH * 7, cuantoW * 15, cuantoH * 1), "Introduzca los parametros de busqueda para el proximo planeta a colonizar.", "label_centrada");
GUI.Box(new Rect(cuantoW, cuantoH * 9, cuantoW * 10, cuantoH * 19), "");
GUILayout.BeginArea(new Rect(cuantoW, cuantoH * 9, cuantoW * 10, cuantoH * 19));
GUILayout.BeginVertical();
//Controles para alterar el tipo de terreno a crear aleatoriamente: cosas que no influyan mucho, nombre, etc. o cosas que
//influyan en la creacion del ruido, por ejemplo el numero de octavas a usar podemos llamarlo "factor de erosion" o cosas asi.
//Despues de este paso se crea el mapa aleatorio con ruido.
GUILayout.Label("Altura del terreno", "label_centrada");
GUILayout.BeginHorizontal();
GUILayout.Label("Bajo");
gananciaInit = GUILayout.HorizontalSlider(gananciaInit, 0.45f, 0.55f);
GUILayout.Label("Alto");
GUILayout.EndHorizontal();
if (gananciaInit <= 0.475f)
{
GUILayout.Label("Bajo");
}
else if (gananciaInit <= 0.5f)
{
GUILayout.Label("Normal");
}
else if (gananciaInit <= 0.525f)
{
GUILayout.Label("Alto");
}
else
{
GUILayout.Label("Muy alto");
}
GUILayout.Label("Tama\u00f1o de continentes", "label_centrada");
GUILayout.BeginHorizontal();
GUILayout.Label("Bajo");
escalaInit = GUILayout.HorizontalSlider(escalaInit, 0.0055f, 0.001f);
GUILayout.Label("Alto");
GUILayout.EndHorizontal();
if (escalaInit >= 0.0045f)
{
GUILayout.Label("Islas peque\u00f1as");
}
else if (escalaInit >= 0.0033f)
{
GUILayout.Label("Islas grandes");
}
else if (escalaInit >= 0.0021f)
{
GUILayout.Label("Continentes");
}
else
{
GUILayout.Label("Grandes continentes");
}
GUILayout.Label("Irregularidad del relieve", "label_centrada");
GUILayout.BeginHorizontal();
GUILayout.Label("Baja");
octavasFloat = GUILayout.HorizontalSlider(octavasFloat, 2.0f, 10.0f);
GUILayout.Label("Alta");
GUILayout.EndHorizontal();
if (octavasFloat <= 4.0f)
{
GUILayout.Label("Terreno liso");
}
else if (octavasFloat <= 6.0f)
{
GUILayout.Label("Con relieve");
}
else if (octavasFloat <= 8.0f)
{
GUILayout.Label("Escarpado");
}
else
{
GUILayout.Label("Muy escarpado");
}
GUILayout.Label("Variacion", "label_centrada");
GUILayout.BeginHorizontal();
GUILayout.Label("Baja");
lacunaridadInit = GUILayout.HorizontalSlider(lacunaridadInit, 1.4f, 3.1f);
GUILayout.Label("Alta");
GUILayout.EndHorizontal();
float lacunaridadInitTemp = (lacunaridadInit - 1.4f) / (3.1f - 1.4f);
if (lacunaridadInitTemp <= 0.25f)
{
GUILayout.Label("Muy regular");
}
else if (lacunaridadInitTemp <= 0.5f)
{
GUILayout.Label("Regular");
}
else if (lacunaridadInitTemp <= 0.75f)
{
GUILayout.Label("Irregular");
}
else
{
GUILayout.Label("Muy irregular");
}
if (GUILayout.Button(new GUIContent("Buscar", "Busca un planeta con esos parametros."), GUILayout.Height(cuantoH * 1.5f)))
{
FuncTablero.setEscala(escalaInit);
FuncTablero.setGanancia(gananciaInit);
FuncTablero.setLacunaridad(lacunaridadInit);
FuncTablero.setOctavas2((int)octavasFloat);
FuncTablero.reiniciaPerlin();
StartCoroutine(creacionParte1());
}
GUILayout.EndVertical();
GUILayout.EndArea();
GUILayout.BeginArea(new Rect(cuantoW * 12, cuantoH * 28, cuantoW * 35, cuantoH * 2));
GUILayout.BeginHorizontal();
if (GUILayout.Button(new GUIContent("Volver", "Volver al men\u00fa principal"), GUILayout.Height(cuantoH)))
{
faseCreacion = 0;
estado = 0;
// objetoRoca.renderer.enabled = false;
objetoRoca.animation.Play("HologramaDesaparecer");
Camera.main.animation.Play("AlejarseHolograma");
}
GUILayout.Space(cuantoW * 28);
string tooltipTemp = "Pasar a la segunda fase";
if (!paso1Completado)
{
tooltipTemp = "Generar un planeta primero";
GUI.enabled = false;
}
if (GUILayout.Button(new GUIContent("Siguiente", tooltipTemp), GUILayout.Height(cuantoH)))
{
faseCreacion = 1;
}
GUI.enabled = true;
GUILayout.EndHorizontal();
GUILayout.EndArea();
}
void OnGUI()
{
GUI.skin = estiloGUI;
GUI.Box(new Rect(cuantoW * 16, 0, cuantoW * 16, cuantoH * 8), "", "header_titulo"); //Header es 500x500px
switch (estado)
{
case 0: //Menu principal
menuPrincipal();
break;
case 1: //Comenzar
Debug.Log(FuncTablero.formateaTiempo() + ": Iniciando la carga de la siguiente escena...");
ValoresCarga temp = contenedorTexturas.GetComponent <ValoresCarga>();
temp.texturaBase = texturaBase;
temp.texturaBase.Apply();
temp.roca = rocaMesh;
temp.agua = aguaMesh;
temp.nivelAgua = nivelAguaInit;
temp.tamanoPlaya = tamanoPlayasInit;
temp.texturaElementos = texElems;
temp.texturaHabitats = texHabitats;
temp.texturaHabsEstetica = texHabitatsEstetica;
temp.vida = vida;
temp.energia = 200;
temp.compBas = 50;
temp.compAdv = 0;
temp.matBio = 0;
temp.etapaJuego = 0;
Debug.Log(FuncTablero.formateaTiempo() + ": Valores cargados correctamente. Iniciando carga de nivel...");
Application.LoadLevel("Escena_Principal");
break;
case 2: //Opciones
menuOpciones();
if (GUI.changed)
{
actualizarOpciones();
}
break;
case 3: //Creditos
creditos();
break;
case 4: //Salir
PlayerPrefs.Save();
Application.Quit();
break;
case 5: //Creacion
if (faseCreacion == 0)
{
creacionParte1Interfaz();
}
else if (faseCreacion == 1)
{
creacionParte2Interfaz();
}
else if (faseCreacion == 2)
{
creacionParte3Interfaz();
}
break;
case 6: //Cargar (seleccion)
menuCargar();
break;
case 7: //Cargar (el juego seleccionado)
// cargarJuego();
Application.LoadLevel("Escena_Principal");
break;
}
if (trabajando)
{
barraProgreso();
}
//Tooltip
mostrarTooltip();
}
private static GameObject getModeloNoSerializableReal(int referencia, Vector3 pos)
{
if (modelosAnimales == null || modelosEdificios == null || modelosVegetales == null || objetoRoca == null)
{
if (!iniciaVariablesEstaticas())
{
Debug.LogError("Error al iniciar variables estaticas. Puede estar en una escena incorrecta?");
return(null);
}
}
//[Debug] -----------------
// Vector3 pos = Vector3.zero;
// ------------------------
GameObject resultado;
switch (referencia)
{
//Edificios [20-24]
case 20: //Fabrica componentes basicos
resultado = FuncTablero.creaMesh(pos, modelosEdificios.fabCompBas);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 21: //Central de energia
resultado = FuncTablero.creaMesh(pos, modelosEdificios.centralEnergia);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 22: //Granja
resultado = FuncTablero.creaMesh(pos, modelosEdificios.granja);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 23: //Fabrica componentes avanzados
resultado = FuncTablero.creaMesh(pos, modelosEdificios.fabCompAdv);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 24: //Central energia avanzada
resultado = FuncTablero.creaMesh(pos, modelosEdificios.centralEnergiaAdv);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
//Animales [10-19]
case 10: //Conejo
resultado = FuncTablero.creaMesh(pos, modelosAnimales.herbivoro1[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 11: //Camello
resultado = FuncTablero.creaMesh(pos, modelosAnimales.herbivoro2[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 12: //Tortuga
resultado = FuncTablero.creaMesh(pos, modelosAnimales.herbivoro3[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 13: //Ciervo
resultado = FuncTablero.creaMesh(pos, modelosAnimales.herbivoro4[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 14: //Salamandra
resultado = FuncTablero.creaMesh(pos, modelosAnimales.herbivoro5[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 15: //Zorro
resultado = FuncTablero.creaMesh(pos, modelosAnimales.carnivoro1[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 16: //Lobo
resultado = FuncTablero.creaMesh(pos, modelosAnimales.carnivoro2[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 17: //Serpiente
resultado = FuncTablero.creaMesh(pos, modelosAnimales.carnivoro3[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 18: //Tigre
resultado = FuncTablero.creaMesh(pos, modelosAnimales.carnivoro4[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 19: //Velociraptor
resultado = FuncTablero.creaMesh(pos, modelosAnimales.carnivoro5[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
//Vegetales [0-9]
case 0: //Seta
resultado = FuncTablero.creaMesh(pos, modelosVegetales.setas[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 1: //Flor
resultado = FuncTablero.creaMesh(pos, modelosVegetales.flores[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 2: //Caña
resultado = FuncTablero.creaMesh(pos, modelosVegetales.canas[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 3: //Arbusto
resultado = FuncTablero.creaMesh(pos, modelosVegetales.arbustos[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 4: //Estromatolito
resultado = FuncTablero.creaMesh(pos, modelosVegetales.estromatolitos[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 5: //Cactus
resultado = FuncTablero.creaMesh(pos, modelosVegetales.cactus[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 6: //Palmera
resultado = FuncTablero.creaMesh(pos, modelosVegetales.palmeras[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 7: //Pino
resultado = FuncTablero.creaMesh(pos, modelosVegetales.pinos[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 8: //Cipres
resultado = FuncTablero.creaMesh(pos, modelosVegetales.cipreses[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
case 9: //Pino alto
resultado = FuncTablero.creaMesh(pos, modelosVegetales.pinosAltos[UnityEngine.Random.Range(0, 4)]);
resultado.transform.position = objetoRoca.transform.TransformPoint(resultado.transform.position);
return(resultado);
default:
Debug.LogError("La referencia de entrada al metodo getModeloNoSerializableReal(int, Vector3) no es valida! Num = " + referencia.ToString());
return(GameObject.CreatePrimitive(PrimitiveType.Cube));
}
}