//------------------------------------------------------------------------------------------------------------------
/*
* METODO QUE SE EJECUTA CUANDO SE PULSA SOBRE UN ASPECTO
*/
public void bApariencia()
{
//Comprobar si la apariencia esta bloqueada
if (bloqueado)
{
if (infoPersistente.getEnergia() >= precioApariencia)
{
//Iniciamos proceso de compra
solicitarComprar();
}
else
{
//Mostrar mensaje saldo insuficiente
string texto = "No tienes suficiente energia para comprar esta apariencia";
ventanaEmergente.GetComponent <VentanaInformacion>().mostrarInfo(texto, "Aceptar");
}
}
else
{
//Guardar la interfaz activa
refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("aparienciaActiva").SetValueAsync(nombreAspecto);
infoPersistente.setAparienciaActiva(nombreAspecto);
//Establecer nueva apariencia en la imagen
animatorImagen1.SetTrigger(nombreAspecto);
animatorImagen2.SetTrigger(nombreAspecto);
//Desmarcar todos los objetos
for (int i = 0; i < apariencias.Length; i++)
{
apariencias[i].GetComponent <Apariencia>().desmarcar();
}
//Marcar objeto como activo
marcar();
}
}
//-----------------------------------------------------------------------------------------------------------------------
/*
* METODO PARA BUSCAR UN USUARIO POR EL NOMBRE
*/
public async System.Threading.Tasks.Task buscarUsuarioAsync()
{
List <string> listEncontrados = new List <string>();
//Comprobar que se ha introducido algun texto de busqueda
if (ifUsuarioBuscar.text.Equals(""))
{
panelInicio.gameObject.SetActive(true);
panelSinResultados.gameObject.SetActive(false);
return;
}
//Obtener datos de firebase
await refBD.getBaseDatos().GetReference("jugadores")
.GetValueAsync().ContinueWith(task => {
if (task.IsFaulted)
{
}
else if (task.IsCompleted)
{
DataSnapshot snapshot = task.Result;
IEnumerable <DataSnapshot> posLeida = snapshot.Children;
//Recorrer los resultado leidos sobre todos los jugadores
foreach (var linea in posLeida)
{
//Buscar jugadores que en su nombre contienen el texto introducido
if (linea.Value.ToString().ToLower().Contains(ifUsuarioBuscar.text.ToLower()))
{
if (linea.Value.ToString().ToLower().Equals(ifUsuarioBuscar.text.ToLower()))
{
//Si se encuentra uno en el que coinciden todas las letras, lo situamos el primero de la lista
listEncontrados.Insert(0, linea.Key.ToString());
}
else
{
//Si solo contiene la palabra, lo incluimos como otro mas
listEncontrados.Add(linea.Key.ToString());
}
}
}
}
});
//Tras realizar busqueda comprobar el numero de resultados
if (listEncontrados.Count > 0)
{
//Si es mayor que 0, llamamos al metodo para obtener los datos de los usuario
_ = ObtenerDatosPorUIDAsync(listEncontrados);
panelSinResultados.gameObject.SetActive(false);
panelInicio.gameObject.SetActive(false);
}
else
{
//En otro caso, indicamos que no se han encontrado resultados de la busqueda, mostramos el panel adecuado
panelSinResultados.gameObject.SetActive(true);
panelInicio.gameObject.SetActive(false);
}
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO QUE SE EJECUTA AL CAMBIAR LA SENSIBILIDAD DEL MOVIMIENTO
*/
public void cambiadoSenMov()
{
//Obtener valor seleccionado
int ajuste = (int)sSenMov.value;
//Guardar el nuevo ajuste en el nodo de firebase
refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("ajustes").Child("senMov").SetValueAsync(ajuste + "");
//Cambiar directamente el ajuste en el objeto de informacion persistente
infoPersistente.setSenMov(ajuste);
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO QUE SE EJECUTA CUANDO SE PULSA EL BOTON DE ACEPTAR LA BATALLA
*/
public void bAceptar()
{
//Ocultar panel
panelPrincipal.gameObject.SetActive(false);
//Indicar aceptar solicitud de batalla al contrincante
refBD.getBaseDatos().GetReference("usuarios").Child(uidOponente).Child("batalla/respuesta").SetValueAsync("true");
//Indicar que esta en batalla para no recibir mas solicitudes
infoPersistente.setEnBatalla(true);
//Marcar la variable para empezar la partida desde el metodo update
empezarPartida = true;
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO PARA ESTABLECER LOS METODO DE ESCUCHA CONTINUAOS DE LOS NODOS CON INFORMACION NECESARIA DE LA BASE DE DATOS
*/
public void obtenerDatosContinuos()
{
//Poner a la escucha el campo correspondiente para obtener la informacion continua
refBD.getBaseDatos()
.GetReference("usuarios/" + refBD.getUsuario().UserId)
.ValueChanged += HandleValueChanged;
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO PARA COMPROBAR SI LA VERSION QUE SE ESTA EJECUTANDO ES LA ULTIMA DISPONIBLE
*/
public async System.Threading.Tasks.Task detectar()
{
string version = "";
//Leer el nodo de relaciones del usuario
await refBD.getBaseDatos().GetReference("version")
.GetValueAsync().ContinueWith(task => {
if (task.IsFaulted)
{
}
else if (task.IsCompleted)
{
DataSnapshot snapshot = task.Result;
version = snapshot.Value.ToString();
}
});
//Si la version de la aplicacion no se corresponde con la ultima, mostramos el mensaje de desconexion para evitar su uso
if (!version.Equals("3"))
{
panelVersion.gameObject.SetActive(true);
}
//Si la version es la ultima
else
{
//Comprobar si se esta logueado
comprobarLogueo();
}
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO QUE SE EJECUTA AL INICIO DE LA EJECUCIÓN PARA REALIZAR REFERENCIAS
*/
void Awake()
{
//Obtener referencias
infoPersistente = GameObject.Find("InfoPersistente").GetComponent <InfoPersistente>();
refBD = GameObject.Find("ReferenciaBD").GetComponent <ReferenciaBaseDatos>();
//Resetear los nodos de juego de la base de datos
infoPersistente.setJugando(true);
infoPersistente.setPeticionBatalla("null");
infoPersistente.setRespuestaBatalla("null");
refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("batalla/peticion").SetValueAsync("null");
refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("batalla/respuesta").SetValueAsync("null");
//Inicializacion
txtCuentaAtras.text = tiempoCuentaAtras.ToString("f0");
panelCuentaAtras.gameObject.SetActive(false);
txtCuentaAtras.text = tiempoReaparecer.ToString("f0");
panelReaparecer.gameObject.SetActive(false);
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO QUE SE EJECUTA AL INICIAR EL SCRIPT
*/
void Start()
{
//Obtener referencias
refBD = GameObject.Find("ReferenciaBD").GetComponent <ReferenciaBaseDatos>();
infoPersistente = GameObject.Find("InfoPersistente").GetComponent <InfoPersistente>();
//Establecer los datos a null para comenzar
refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("batalla/peticion").SetValueAsync("null");
refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("batalla/respuesta").SetValueAsync("null");
//Poner a la escucha el campo correspondiente para obtener todos los nombres de usuario ocupados de la base de datos
refBD.getBaseDatos()
.GetReference("usuarios/" + refBD.getUsuario().UserId)
.ValueChanged += HandleValueChanged;
//Llamada al metodo de actualizar foto por si ha cambiado respecto a la ultima conexion
//actualizarFotoPerfil();
//Establecer animacion del personaje
animatorImagenWalter.SetTrigger(infoPersistente.getAparienciaActiva());
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO QUE SE EJECUTA REPETIDAMENTE CADA FOTOGRAMA DE LA EJECUCION
*/
void Update()
{
//Obtener autenticacion
FirebaseAuth auth = FirebaseAuth.DefaultInstance;
//Comprobar si esta conectado al servidor photon y logueado para cargar la escena principal
if (PhotonNetwork.IsConnected && auth != null)
{
//Ejecutar solo la primera vez
if (primeraEjecucion)
{
primeraEjecucion = false;
refBD.setUsuario(auth.CurrentUser);
cargarEscenaPrincipal();
}
}
//Si se activa la variable de escena principal
if (escenaPrincipal)
{
if (obtenerinfo && primeraEjecucion2)
{
primeraEjecucion2 = false;
obtenerinfo = false;
//Cargar informacion inicial
infoPersistente.obtenerDatosContinuos();
//Iniciar Informacion
refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("batalla/peticion").SetValueAsync("null");
refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("batalla/respuesta").SetValueAsync("null");
}
//No cambiar de escena mientras no se recupere toda la informacion inicial
if (infoPersistente.isObtenidoTodo())
{
//Cargar escena principal
SceneManager.LoadScene("Principal");
}
}
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO QUE SE EJECUTA AL INICIAR EL SCRIPT
*/
void Start()
{
//Obtener referencias
refBD = GameObject.Find("ReferenciaBD").GetComponent <ReferenciaBaseDatos>();
//Ocultar el panel no tienes amigos
panelSinAmigos.gameObject.SetActive(false);
//Poner a la escucha el nodo para obtener amigos o solicitudes
refBD.getBaseDatos()
.GetReference("usuarios/" + refBD.getUsuario().UserId + "/relaciones")
.ValueChanged += HandleValueChanged;
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO PARA OBTENER LOS DATOS DEL USUARIO INDICADO POR PARAMETRO DE LA BASE DE DATOS
*/
public async System.Threading.Tasks.Task ObtenerUsuAsync(string uid)
{
//Iniciar variables
string nombreUsu = "", foto = "";
//Leer el nodo de relaciones del usuario
await refBD.getBaseDatos().GetReference("usuarios/" + uid)
.GetValueAsync().ContinueWith(task => {
if (task.IsFaulted)
{
}
else if (task.IsCompleted)
{
DataSnapshot snapshot = task.Result;
IEnumerable <DataSnapshot> posLeida = snapshot.Children;
//Recorrer los resultado leidos del usuario
foreach (var linea in posLeida)
{
//En funcion del dato leido lo alamacenaremos en la variable adecuada
if (linea.Key.ToString().Equals("nombreUsu"))
{
nombreUsu = linea.Value.ToString();
}
if (linea.Key.ToString().Equals("foto"))
{
foto = linea.Value.ToString();
}
}
}
});
//Crear un objeto de la clase amigo con los datos leidos
Amigo amigoLeido = new Amigo {
nombre = nombreUsu, urlFoto = foto, codigoUid = uid
};
//Crear el objeto en el contenedor de la lista
GameObject elementoLista = Instantiate(prefabElemento, contenedorLista);
//Llamada al metodo que le asigna los datos al elemento del listado, indicando que tipo de elemento es (solicitud, amigo...)
//Es un amigo
if (queUsuariosObtener.Equals("amigo"))
{
elementoLista.GetComponent <ElementoLista>().crearMiAmigo(amigoLeido, ventanaEmergente, solicitarBatalla);
}
//Es una solicitud
else
{
elementoLista.GetComponent <ElementoLista>().crear(amigoLeido, queUsuariosObtener, ventanaEmergente);
}
}
//--------------------------------------------------------------------------------------------------------------
/*
* METODO PARA MOSTRAR MENSAJE DE SOLICITUD DE BATALLA
*/
public async System.Threading.Tasks.Task crearBatalla()
{
string nombre = "";
await refBD.getBaseDatos().GetReference("jugadores")
.GetValueAsync().ContinueWith(task => {
if (task.IsFaulted)
{
}
else if (task.IsCompleted)
{
DataSnapshot snapshot = task.Result;
IEnumerable <DataSnapshot> posLeida = snapshot.Children;
//Recorrer los resultado leidos del usuario
foreach (var linea in posLeida)
{
//Buscar el nombre del jugador con el id de batalla
if (linea.Key.ToString().Equals(infoPersistente.getPeticionBatalla()))
{
nombre = linea.Value.ToString();
}
}
}
});
//Indicar que estamos en batalla
infoPersistente.setEnBatalla(true);
//Guardar nombre oponente
infoPersistente.setNombreOponente(nombre);
//Mostrar el mensaje emergente de batalla
ventanaBatalla.GetComponent <Batalla>().crear(nombre, infoPersistente.getPeticionBatalla());
//A partir de la creacion del mensaje contar tiempo
contarTiempo = true;
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO QUE SE EJECUTA AL INICIAR EL SCRIPT
*/
void Start()
{
//Obtener referencias
refBD = GameObject.Find("ReferenciaBD").GetComponent <ReferenciaBaseDatos>();
//Añadir listener que llamara un metodo cuando los valores del campo de texto cambien
ifUsuarioBuscar.onEndEdit.AddListener(delegate { buscarUsuarioAux(); });
//Inicializar componentes
panelInicio.gameObject.SetActive(true);
panelSinResultados.gameObject.SetActive(false);
//Poner a la escucha el nodo para obtener amigos
refBD.getBaseDatos()
.GetReference("usuarios/" + refBD.getUsuario().UserId + "/relaciones")
.ValueChanged += HandleValueChanged;
}
//========>
/*
* METODO PARA EFECTUAR LA PROPIA ELIMINACIÓN DE LA AMISTAD EN AMBOS USUARIOS AL PULSAR EN ACEPTAR DEL MENSAJE EMERGENTE
*/
public void borrarAmigo()
{
//Eliminar la entrada de la relacion para los 2 usuarios
refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("relaciones").Child(uid).RemoveValueAsync();
refBD.getBaseDatos().GetReference("usuarios").Child(uid).Child("relaciones").Child(refBD.getUsuario().UserId).RemoveValueAsync();
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO QUE SE EJECUTA AL INICIAR EL SCRIPT
*/
void Start()
{
//Inicializar variables
nomDisponible = true;
//Llamada al metodo para comprobar la disponibilidad del nombre
ifNomUsu.onEndEdit.AddListener(delegate { comprobarDisponibilidad(); });
//Poner a la escucha el campo correspondiente para obtener todos los nombres de usuario ocupados de la base de datos
refBD.getBaseDatos()
.GetReference("jugadores")
.ValueChanged += HandleValueChanged;
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO QUE SE EJECUTA REPETIDAMENTE CADA FOTOGRAMA DE LA EJECUCION
*/
void Update()
{
/////////////////////////////////////////////// RECIBIR RESPUESTAS A PETICIONES /////////////////////////////////////////////////
if (solicitado)
{
if (tiempoAux > 0)
{
tiempoAux -= Time.deltaTime;
}
else
{
//Si ha finalizado el tiempo de vida de la solicitud sin respuesta
//Ocultar ventana de espera
ventanaEmergente.GetComponent <VentanaEspera>().ocultar();
//Marcar como fin de solicitud
solicitado = false;
infoPersistente.setEnBatalla(false);
//reiniciar tiempo
tiempoAux = tiempoEspera;
//Mostrar mensaje info
string texto = "Tiempo de espera agotado";
ventanaEmergente.GetComponent <VentanaInformacion>().mostrarInfo(texto, "Aceptar");
}
}
else if (buscando)
{
if (tiempoAux > 0)
{
tiempoAux -= Time.deltaTime;
}
else
{
//Si ha finalizado el tiempo de vida de la busqueda sin respuesta
//Ocultar ventana de espera
ventanaEmergente.GetComponent <VentanaEspera>().ocultar();
//Marcar como fin de solicitud
buscando = false;
infoPersistente.setEnBatalla(false);
//Salir de la sala creada
gestionPartidas.salirSala();
//reiniciar tiempo
tiempoAux = tiempoEspera;
//Mostrar mensaje info
string texto = "No hay ningun jugador en este momento, intentelo mas tarde";
ventanaEmergente.GetComponent <VentanaInformacion>().mostrarInfo(texto, "Aceptar");
}
}
if (infoPersistente.getRespuestaBatalla().Equals("true"))
{
//Crear Sala de juego con el nombre de mi uid
gestionPartidas.crearSalaAmigo(refBD.getUsuario().UserId);
//Reinicializar la respuesta
refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("batalla/respuesta").SetValueAsync("null");
//Establecer a nulo la respuesta para evitar que se ejecute mas de una vez
infoPersistente.setRespuestaBatalla("null");
}
else if (infoPersistente.getRespuestaBatalla().Equals("false"))
{
//Reinicializar la respuesta
refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("batalla/respuesta").SetValueAsync("null");
ventanaEmergente.GetComponent <VentanaEspera>().ocultar();
//Mostrar mensaje info
string texto = "El oponente ha rechazado la batalla";
ventanaEmergente.GetComponent <VentanaInformacion>().mostrarInfo(texto, "Aceptar");
//Marcar como fin de solicitud
solicitado = false;
infoPersistente.setEnBatalla(false);
infoPersistente.setRespuestaBatalla("null");
}
}
//------------------------------------------------------------------------------------------------------------------
/*
* METODO PARA MOSTRAR EL PANEL FINAL DE LA PARTIDA
*/
public async System.Threading.Tasks.Task mostrarAsync(string estado, int energiaGanada)
{
//Desconectarnos de la sala de juego creada
if (PhotonNetwork.CurrentRoom != null)
{
PhotonNetwork.LeaveRoom();
}
//Obtener referencias
refBD = GameObject.Find("ReferenciaBD").GetComponent <ReferenciaBaseDatos>();
infoPersistente = GameObject.Find("InfoPersistente").GetComponent <InfoPersistente>();
//Obtener mi personaje si no lo he obtenido previamente
if (miPersonaje == null)
{
miPersonaje = GameObject.Find("miPersonaje");
}
//Bloquear el personaje para no poder interactuar mas con el
if (miPersonaje != null)
{
miPersonaje.GetComponent <EstadoJugador>().setEstado(0);
}
//Establecer la energia y titulo en funcion de si hemos ganado, perdido, empatado o se ha desconectado el oponente
int energia = 0;
switch (estado)
{
case "ganado":
energia = energiaGanada + 30; //Sumar el bonus
panelBonus.gameObject.SetActive(true);
txtTitulo.text = "Has ganado";
break;
case "perdido":
energia = energiaGanada;
panelBonus.gameObject.SetActive(false);
txtTitulo.text = "Has perdido";
break;
case "empatado":
energia = energiaGanada;
panelBonus.gameObject.SetActive(false);
txtTitulo.text = "Empate";
break;
case "desconectado":
panelBonus.gameObject.SetActive(true);
energia = energiaGanada + 30; //Sumar el bonus
txtTitulo.text = "El oponente ha abandonado la partida";
break;
}
//Mostrar la energia obtenida
txtEnergiaGanada.text = ("+" + energiaGanada);
//Sumar energia al nodo de firebase
await refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("energia").SetValueAsync("" + (infoPersistente.getEnergia() + energia));
//Establecer los datos a null
await refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("batalla/peticion").SetValueAsync("null");
await refBD.getBaseDatos().GetReference("usuarios").Child(refBD.getUsuario().UserId).Child("batalla/respuesta").SetValueAsync("null");
//Cuando sumamos la energia a la base de datos mostramos el propio panel informativo
panelContenido.gameObject.SetActive(true);
canvasPantalla.gameObject.SetActive(false);
}
