/// <summary>
/// Método que será llamado por un cliente cuando un contador de un cliente llega a 0,
/// para evitar que el servidor dé los datos del siguiente turno antes de que todos
/// los integrantes del grupo hayan terminado.
/// </summary>
/// <param name="connectionIDJugador"></param>
/// <param name="nombreGrupo"></param>
public void miContadorHaLlegadoACero(string connectionIDJugador, string nombreGrupo)
{
bool todosHanTerminado = true;
//Marcar ese jugador como que su timer ha terminado
clsPartida partidaActual = obtenerPartidaPorNombreSala(nombreGrupo);
clsJugador jugadorQueHaTerminado = partidaActual.ListadoJugadores.FirstOrDefault <clsJugador>(x => x.ConnectionID == connectionIDJugador);
jugadorQueHaTerminado.HaTerminadoTimer = true;
//Comprobar si todos los jugadores de la partida han terminado
for (int i = 0; i < partidaActual.ListadoJugadores.Count; i++)
{
if (!partidaActual.ListadoJugadores[i].HaTerminadoTimer)
{
//Si el timer de alguno NO ha terminado, entonces no todos han terminado
todosHanTerminado = false;
}
}
if (todosHanTerminado)
{
//Vuelvo a poner sus "haTerminadoTimer" a false
for (int i = 0; i < partidaActual.ListadoJugadores.Count; i++)
{
partidaActual.ListadoJugadores[i].HaTerminadoTimer = false;
}
//Cuando todos han terminado, se llama a avanzar turno
avanzarTurno(partidaActual);
}
}
/// <summary>
/// Finaliza una partida.
/// </summary>
public void terminarPartida()
{
//Obtiene la partida del cliente que llamó al método
clsPartida partida = partidas.getMatchByConnectionID(Context.ConnectionId);
//Si el cliente está en una partida
if (partida != null)
{
//Por cada categoria
for (int i = 0; i < partidas.Lista.Count; i++)
{
//Por cada partida
for (int j = 0; j < partidas.Lista[i].Partidas.Count; j++)
{
//Si encuentra la partida, la borra de la lista
if (partidas.Lista[i].Partidas[j].Id == partida.Id)
{
partidas.Lista[i].Partidas.Remove(partida);
}
}
}
clsJugador jugador1 = partida.Jugador1;
clsJugador jugador2 = partida.Jugador2;
//Informa a ambos jugadores de la partida de que la partida ha terminado y envía las estadísticas de esta (preguntas acertadas y falladas de cada jugador)
Clients.Client(jugador1.ConnectionID).mandarEstadisticasFinalPartida(jugador1.PreguntasAcertadas, jugador1.PreguntasFalladas, jugador2.PreguntasAcertadas, jugador2.PreguntasFalladas);
Clients.Client(jugador2.ConnectionID).mandarEstadisticasFinalPartida(jugador2.PreguntasAcertadas, jugador2.PreguntasFalladas, jugador1.PreguntasAcertadas, jugador1.PreguntasFalladas);
}
}
/// <summary>
/// Método que es llamado cuando un jugador se une a una sala creada.
/// Se llama al método jugadorAdded de los clientes.
/// </summary>
/// <param name="nombreGrupo">nombre de la sala a la que se une</param>
/// <param name="jugador">jugador que se une</param>
public void addJugadorToSala(string nombreGrupo, clsJugador jugador)
{
clsPartida partida = obtenerPartidaPorNombreSala(nombreGrupo);
clsJugador jugadorBuscado;
if (partida != null)
{
jugadorBuscado = partida.ListadoJugadores
.FirstOrDefault <clsJugador>(p => p.ConnectionID == jugador.ConnectionID);
if (jugadorBuscado == null)
{
if (partida.ListadoJugadores.Count < partida.NumeroMaximoJugadores)
{
jugador.ConnectionID = Context.ConnectionId;
Groups.Add(Context.ConnectionId, partida.NombreSala);
partida.ListadoJugadores.Add(jugador);
Clients.Client(jugador.ConnectionID).jugadorAdded(jugador, partida);
Clients.AllExcept(jugador.ConnectionID).jugadorAdded(jugador, partida);
}
}
}
}
public VMPantallaJuego()
{
PuedesFuncionar = true;
this.tiempoEspera = 3;
_partida = new clsPartida();
_usuarioPropio = new clsJugador();
this._mensaje = new clsMensaje();
_mensaje.JugadorQueLoEnvia = new clsJugador();
this.GoBackCommand = new DelegateCommand(ExecuteGoBackCommand);
this.SendMessageCommand = new DelegateCommand(ExecuteSendMessageCommand, CanExecuteSendMessageCommand);
this.IsUltimaPalabraAcertada = false;
_timeMax = TIME_MAX;
this._dispatcherTimer = new DispatcherTimer();
this._dispatcherTimer.Interval = new TimeSpan(0, 0, 1);
this._dispatcherTimer.Tick += Timer_Tik;
//this._dispatcherTimer.Start();
this.LblTemporizador = TIME_MAX.ToString();
this._palabraAMostrar = "";
TipoEntradaInkCanvas = CoreInputDeviceTypes.None;
SignalR();
// proxy.Invoke("comenzarPartidaEnGrupo", _partida);
}
/// <summary>
/// El cliente llama a este método cuando acierte la palabra y haya que sumar
/// puntos a un usuario.
/// El método pasa el turno si todos los usuarios (menos el que pintaba)
/// de una partida han acertado.
/// </summary>
/// <param name="connectionIDUSer">connection ID del usuario al que han de sumarse los puntos</param>
/// <param name="puntosToAdd">cantidad de puntos a sumar</param>
/// <param name="nombreGrupo">nombre del grupo al que pertenece el usuario</param>
public void addPuntosToUser(string connectionIDUSer, int puntosToAdd, string nombreGrupo)
{
clsPartida partidaActual = obtenerPartidaPorNombreSala(nombreGrupo);
clsJugador jugador = partidaActual.ListadoJugadores.FirstOrDefault <clsJugador>(x => x.ConnectionID == connectionIDUSer);
jugador.Puntuacion += puntosToAdd;
jugador.IsUltimaPalabraAcertada = true;
Clients.Group(nombreGrupo).puntosAdded(partidaActual);
//Si todos los jugadores ya han acertado la palabra, se pasa el turno
int acertantes = 0;
//Comprobar si todos los jugadores de la partida han acertado ya
for (int i = 0; i < partidaActual.ListadoJugadores.Count; i++)
{
if (partidaActual.ListadoJugadores[i].IsUltimaPalabraAcertada)
{
acertantes++;
}
}
if (acertantes == (partidaActual.ListadoJugadores.Count - 1)) //deben haber acertado todos menos uno (el que pinta)
{
//avanzarTurno(partidaActual);
//Todos han acertado ya
Clients.Group(nombreGrupo).todosHanAcertado();
}
}
//Cuando cambia el turno
private async void onHaCambiadoElTurno(clsPartida obj)
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (obj.ListadoJugadores != null && viewModel.UsuarioPropio.Nickname != null)
{
viewModel.Partida = obj;
viewModel.NotifyPropertyChanged("Partida");
viewModel.UsuarioPropio = obj.ListadoJugadores.FirstOrDefault <clsJugador>(x => x.Nickname == viewModel.UsuarioPropio.Nickname);
//Iniciamos el timer
viewModel.TimeMax = TIME_MAX;
viewModel.NotifyPropertyChanged("TimeMax");
viewModel.LblTemporizador = TIME_MAX.ToString();
viewModel.NotifyPropertyChanged("LblTemporizador");
viewModel.tiempoEspera = 10;
viewModel.DispatcherTimer.Start();
//Se limpia el canvas
inkCanvas.InkPresenter.StrokeContainer.Clear();
if (obj.ConnectionIDJugadorActual == viewModel.UsuarioPropio.ConnectionID)
//es nuestro turno
{
//Habilitar el canvas
// viewModel.TipoEntradaInkCanvas = CoreInputDeviceTypes.Mouse;
inkCanvas.InkPresenter.InputDeviceTypes = CoreInputDeviceTypes.Mouse;
//NotifyPropertyChanged("TipoEntradaInkCanvas");
//palabra a mostrar será la palabra en juego
viewModel.PalabraAMostrar = obj.PalabraEnJuego;
viewModel.NotifyPropertyChanged("PalabraAMostrar");
viewModel.IsMiTurno = true;
viewModel.NotifyPropertyChanged("IsMiTurno");
}
else
{
//No es nuestro turno
//Deshabilitar el canvas
inkCanvas.InkPresenter.InputDeviceTypes = CoreInputDeviceTypes.None;
ballpointpen.SelectedBrushIndex = 0;
inkToolbar.ActiveTool = null;
// NotifyPropertyChanged("TipoEntradaInkCanvas");
//palabra a mostrar será ___
// viewModel.PalabraAMostrar = "*******"; //esto ponerlo con tantos * como letras tenga y tal
viewModel.PalabraAMostrar = new string('*', obj.PalabraEnJuego.Length);
viewModel.IsMiTurno = false;
viewModel.NotifyPropertyChanged("IsMiTurno");
viewModel.NotifyPropertyChanged("PalabraAMostrar"); // NotifyPropertyChanged("PalabraAMostrar");
}
}
});
}
//Cuando comienza la partida
private async void onPartidaComenzada(clsPartida obj)
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (viewModel.PuedesFuncionar)
{
if (obj.ListadoJugadores != null && viewModel.UsuarioPropio.Nickname != null)
{
viewModel.Partida = obj;
viewModel.NotifyPropertyChanged("Partida");
viewModel.hanAcertadoTodos = false;
viewModel.UsuarioPropio = obj.ListadoJugadores.FirstOrDefault <clsJugador>(x => x.Nickname == viewModel.UsuarioPropio.Nickname);
//Iniciamos el timer
viewModel.DispatcherTimer.Start();
if (obj.ConnectionIDJugadorActual == viewModel.UsuarioPropio.ConnectionID)
//es nuestro turno
{
//Habilitar el canvas
// viewModel.TipoEntradaInkCanvas = CoreInputDeviceTypes.Mouse;
inkCanvas.InkPresenter.InputDeviceTypes = CoreInputDeviceTypes.Mouse;
//NotifyPropertyChanged("TipoEntradaInkCanvas");
//palabra a mostrar será la palabra en juego
viewModel.PalabraAMostrar = obj.PalabraEnJuego;
viewModel.NotifyPropertyChanged("PalabraAMostrar");
viewModel.IsMiTurno = true;
viewModel.NotifyPropertyChanged("IsMiTurno");
}
else
{
//No es nuestro turno
//Deshabilitar el canvas
// viewModel.TipoEntradaInkCanvas = CoreInputDeviceTypes.None;
inkCanvas.InkPresenter.InputDeviceTypes = CoreInputDeviceTypes.None;
// NotifyPropertyChanged("TipoEntradaInkCanvas");
//palabra a mostrar será ___
//viewModel.PalabraAMostrar = "*******"; //esto ponerlo con tantos * como letras tenga y tal
viewModel.IsMiTurno = false;
viewModel.NotifyPropertyChanged("IsMiTurno");
String[] arrayPalabras = obj.PalabraEnJuego.Split(' ');
String palabraResuelta = "";
foreach (var palabra in arrayPalabras)
{
palabraResuelta += new String('*', palabra.Length);
palabraResuelta += " ";
}
viewModel.PalabraAMostrar = palabraResuelta;
viewModel.NotifyPropertyChanged("PalabraAMostrar");
}
viewModel.PuedesFuncionar = false;
viewModel.NotifyPropertyChanged("PuedesFuncionar");
}
}
});
}
public SalaEsperaVM()
{
// Aquí obtendría la partida enviada desde la otra ventana
partida = new clsPartida();
partida.ListadoJugadores.Add(new clsJugador("id", 0, "Ivan", false, false, false));
partida.ListadoJugadores.Add(new clsJugador("id", 0, "Pepe", false, false, false));
}
/// <summary>
/// Añade un mensaje al listado de mensajes de una partida.
/// Llama al método addMensajeToChat de todos los clientes del grupo.
/// </summary>
/// <param name="mensaje">mensaje a añadir</param>
/// <param name="nombreGrupo">nombre del grupo donde hay que añadir el mensaje</param>
public void sendMensaje(clsMensaje mensaje, string nombreGrupo)
{
clsPartida partida = obtenerPartidaPorNombreSala(nombreGrupo);
if (partida != null)
{
partida.ListadoMensajes.Add(mensaje);
Clients.Group(nombreGrupo).addMensajeToChat(mensaje);
//Clients.All.addMensajeToChat(mensaje);
}
}
/// <summary>
/// Establece el estado de la pantalla de creación de sala.
/// </summary>
public CrearSalaVM()
{
PuedesFuncionar = true;
_partida = new clsPartida();
_visible = "Collapsed";
_lblErrorNombreSala = "*";
_lblErrorNumJugadores = "*";
_checkboxChecked = false;
SignalR();
}
/// <summary>
/// A este método lo llamará el cliente que cree una partida, y
/// así se añadirá al listado de partidas del servidor y se
/// añadirá el usuario creador como líder de la partida.
/// Se añadirá el nuevo grupo y los clientes recibirán las partidas
/// para que vean la nueva partida reflejada en su listado de salas.
/// El que llama también recibirá la partida creada.
/// </summary>
/// <param name="partida">partida creada</param>
/// <param name="nickLider">nick del líder (quien ha creado la partida)</param>
public void añadirPartida(clsPartida partida, String nickLider)
{
//clsJugador jugador = partida.ListadoJugadores.First<clsJugador>(j => j.ConnectionID == Context.ConnectionId);
clsJugador lider = new clsJugador(Context.ConnectionId, 0, nickLider, false, false, true, false);
partida.ListadoJugadores.Add(lider);
Groups.Add(Context.ConnectionId, partida.NombreSala);
listadoSalas.ListadoPartidas.Add(partida);
Clients.All.recibirSalas(listadoSalas.ListadoPartidas);
Clients.Caller.salaCreada(partida);
}
/// <summary>
// Metodo que llama al metodo de un cliente en concreto y lo pone como lider
// A este metodo se le llamara cuando salga de la partida o se desconecte un
// jugador que sea el actual lider del grupo.
/// </summary>
/// <param name="nombreGrupo">nombre del grupo del cliente que llama</param>
public void llamarConvertirEnLider(string nombreGrupo)
{
clsPartida partida = obtenerPartidaPorNombreSala(nombreGrupo);
string conexionIDSiguienteJugador = "";
if (partida.ListadoJugadores.Count > 0)
{
conexionIDSiguienteJugador = partida.ListadoJugadores[0].ConnectionID; //el primer jugador que haya (el jugador lider ya debe haber salido del grupo)
if (!String.IsNullOrEmpty(conexionIDSiguienteJugador))
{
Clients.Client(conexionIDSiguienteJugador).nombrarComoLider(); //nombramos como lider a ese jugador
}
}
}
/// <summary>
// A este método se le llama cuando hay un nuevo líder, para guardar el dato
// en el listado de partidas del servidor
/// </summary>
/// <param name="nickUsuario">nick del nuevo lider</param>
/// <param name="nombreGrupo">nombre del grupo al que pertenece el cliente que llama</param>
public void habemusNuevoLider(string nickUsuario, string nombreGrupo)
{
clsPartida partida = obtenerPartidaPorNombreSala(nombreGrupo);
//Se ponen todos los "isLider" a false (en realidad creo que no haría falta ya que
//el anterior líder habría salido ya de la lista de jugadores
for (int i = 0; i < partida.ListadoJugadores.Count; i++)
{
partida.ListadoJugadores[i].IsLider = false;
}
//Se pone el nuevo lider
clsJugador jugador = partida.ListadoJugadores.FirstOrDefault <clsJugador>(j => j.Nickname == nickUsuario);
jugador.IsLider = true;
}
/// <summary>
/// Método que será llamado por un cliente cuando ya haya navegado de una pantalla concreta
/// a otra, para evitar que el servidor dé los datos de las partidas antes de que todos
/// los integrantes del grupo hayan viajado.
/// </summary>
/// <param name="nombreGrupo">nombre del grupo</param>
public void yaHeNavegado(string nombreGrupo)
{
clsPartida partidaActual = obtenerPartidaPorNombreSala(nombreGrupo);
if (partidaActual != null)
{
partidaActual.JugadoresQueHanNavegado += 1;
if (partidaActual.JugadoresQueHanNavegado == partidaActual.ListadoJugadores.Count)
{
//Todos han navegado
partidaActual.ListadoMensajes = new System.Collections.ObjectModel.ObservableCollection <clsMensaje>();
comenzarPartidaEnGrupo(partidaActual);
}
}
}
/// <summary>
/// Hace comenzar una nueva partida, cogiendo a los dos jugadores que estén primero en la cola
/// </summary>
/// <param name="categoria">Categoria en la que se jugará la partida</param>
public void comenzarPartida(clsCategoriaYJugadoresBuscando categoria)
{
bool clientesDisponibles = false;
//Coge a los dos jugadores que estén primero en la cola (Aunque esto no es una cola como tal xD, estaría bien cambiarlo)
//clsJugador jugador1 = categoria.JugadoresBuscando[0];
//clsJugador jugador2 = categoria.JugadoresBuscando[1];
Queue <clsJugador> colaJugadoresBuscando = new Queue <clsJugador>(categoria.JugadoresBuscando);
clsJugador jugador1 = colaJugadoresBuscando.Dequeue();
clsJugador jugador2 = colaJugadoresBuscando.Dequeue();
//Crea una lista vacia de preguntas (cuando alguno de los clientes entre en la partida entonces se solicitarán las preguntas, no sabía hacerlo de otra forma, haciendolo aqui tengo problemas con la asincronia)
List <clsQuestion> questions = new List <clsQuestion>();
//Crea el objeto con la partida
clsPartida partida = new clsPartida(clsPartida.IdIndex + categoria.Nombre, jugador1, jugador2, questions);
//Añade la partida a la lista de partidas de la categoría dada
categoria.Partidas.Add(partida);
//Elimina de la cola a ambos jugadores que van a empezar a jugar
String connectionID;
int eliminadosDeCola = 0;
//Por cada categoria o cuando ambos hayan sido eliminados de la cola
for (int i = 0; i < partidas.Lista.Count && eliminadosDeCola < 2; i++)
{
//Por cada jugador en cola o cuando ambos hayan sido eliminados de la cola
for (int j = 0; j < partidas.Lista[i].JugadoresBuscando.Count && eliminadosDeCola < 2; j++)
{
connectionID = partidas.Lista[i].JugadoresBuscando[j].ConnectionID;
//Si es el jugador1 o jugador2, lo saca de cola
if (connectionID == partida.Jugador1.ConnectionID || connectionID == partida.Jugador2.ConnectionID)
{
partidas.Lista[i].JugadoresBuscando.RemoveAt(j);
eliminadosDeCola++;
}
}
}
//Indica a ambos jugadores que la partida comienza, mandando la informacion de esta (nombre de ambos jugadores y lista de preguntas)
Clients.Client(jugador1.ConnectionID).comenzarPartida(partida.Jugador1.Nombre, partida.Jugador2.Nombre, partida.Preguntas);
Clients.Client(jugador2.ConnectionID).comenzarPartida(partida.Jugador1.Nombre, partida.Jugador2.Nombre, partida.Preguntas);
}
public SalaEsperaVM()
{
// Aquí obtendría la partida enviada desde la otra ventana
puedesFuncionar2 = true;
partida = new clsPartida();
this.salir = new DelegateCommand(salir_execute);
SignalR();
this.enviarMensaje = new DelegateCommand(enviarMensaje_execute, enviarMensaje_canExecute);
this.comenzarPartida = new DelegateCommand(comenzarPartida_execute, comenzarPartida_canExecute);
this.mensaje = new clsMensaje();
mensaje.JugadorQueLoEnvia = new clsJugador();
//partida.ListadoJugadores.Add(new clsJugador("id", 0, "Ivan", false, false, false));
//partida.ListadoJugadores.Add(new clsJugador("id", 0, "Pepe", false, false, false));
}
//TODO: Quitarle la categoria de la lista de parametros, no la necesita (en realidad no uso ninguno de los parametros xD)
/// <summary>
/// Pide las preguntas a la API.
/// </summary>
/// <param name="numberOfQuestions">Número de preguntas que se desean obtener</param>
/// <param name="category">Categoría que tendrán las preguntas</param>
/// <param name="difficulty">Dificultad de las preguntas a obtener</param>
/// <param name="type">Tipo de las preguntas a obtener (multichoice o true/false)</param>
/// <returns></returns>
public async Task pedirPreguntas(int numberOfQuestions, string category, string difficulty, string type)
{
category = Utils.Categories.First(cat => cat.Value == category).Key;
clsPartida partida = partidas.getMatchByConnectionID(Context.ConnectionId);
//Si la partida todavía no tiene preguntas (necesario ya que si no se ejecutaría dos veces, ya que cada cliente lo pide una vez)
if (partida.Preguntas.Count == 0)
{
List <clsQuestion> questions = await QuestionsHandler.getQuestions(numberOfQuestions, category, difficulty, type); ///////////////////////////////////////////////////////////////////////////////
partida.Preguntas = questions;
Clients.Client(partida.Jugador1.ConnectionID).sendQuestions(partida.Preguntas);
Clients.Client(partida.Jugador2.ConnectionID).sendQuestions(partida.Preguntas);
}
}
/// <summary>
/// Metodo para indicar que se comienza la partida
/// Se establecen propiedades como el turno, la ronda, la palabra en juego, IsJugandose.
/// Llama al OnPartidaComenzada de los clientes del grupo.
/// </summary>
/// <param name="partida">partida que comienza</param>
public void comenzarPartidaEnGrupo(clsPartida partida)
{
partida = obtenerPartidaPorNombreSala(partida.NombreSala);
if (partida != null)
{
//Se pone el primer turno de la primera ronda
//el turno es el del primer jugador
if (partida.ListadoJugadores.Count > 0)
{
partida.ConnectionIDJugadorActual = partida.ListadoJugadores[0].ConnectionID;
}
partida.Turno = 1;
partida.RondaActual = 1;
partida.PalabraEnJuego = Utilidad.obtenerPalabraAleatoria();
//TODO rellenar el listado de posiciones a descubrir
partida.PosicionesADescubrir = Utilidad.rellenarPosicionesADescubrir(partida.PalabraEnJuego);
partida.IsJugandose = true;
//Por si acaso se le pone a todos que NO es su turno
for (int i = 0; i < partida.ListadoJugadores.Count; i++)
{
partida.ListadoJugadores[i].IsMiTurno = false;
}
//Se le pone que es su turno al jugador
clsJugador jugador = partida.ListadoJugadores.FirstOrDefault <clsJugador>(x => x.ConnectionID == partida.ConnectionIDJugadorActual);
jugador.IsMiTurno = true;
//Aqui haría falta guardar esta partida en la lista de partidas
Clients.Group(partida.NombreSala).onPartidaComenzada(partida);
}
}
/// <summary>
/// Método que se llamará cuando un cliente haya salido de una partida.
/// El método se encargará de evaluar si es necesario pasar el turno si el jugador
/// estaba jugando y era su turno. También se borra al usuario del grupo y de la partida.
/// </summary>
/// <param name="usuario">nick de usuario del cliente que ha salido</param>
/// <param name="nombreSala">nombre del grupo del cual ha salido</param>
public void jugadorHaSalido(string usuario, string nombreSala)
{
clsPartida partida = obtenerPartidaPorNombreSala(nombreSala);
clsJugador jugador;
jugador = partida.ListadoJugadores.FirstOrDefault <clsJugador>(j => j.Nickname == usuario);
if (jugador != null)
{
if (jugador.IsMiTurno == true)
{
// isJugadorDesconectado = true;
jugador.IsDesconectado = true;
avanzarTurno(partida);
}
//Elimina al jugador del array de jugadores de la partida
partida.ListadoJugadores.Remove(jugador);
Groups.Remove(Context.ConnectionId, partida.NombreSala);
if (partida.ListadoJugadores.Count == 0)
{
listadoSalas.ListadoPartidas.Remove(partida);
Clients.All.eliminarPartidaVacia(partida.NombreSala);
}
else
{
Clients.All.jugadorDeletedSala(jugador.Nickname, nombreSala);
if (jugador.IsLider)
{
llamarConvertirEnLider(nombreSala);
//luego (si era el lider) se pone de lider al primero de la lista
}
}
}
}
/// <summary>
/// Sale del juego, haciendo que salga de la cola si está en alguna o de la partida si está en una
/// </summary>
public void salir()
{
//Sale de la cola si está en alguna
salirDeCola();
clsPartida partida = partidas.getMatchByConnectionID(Context.ConnectionId);
//Si está en partida
if (partida != null)
{
//Borra la partida
for (int i = 0; i < partidas.Lista.Count; i++)
{
for (int j = 0; j < partidas.Lista[i].Partidas.Count; j++)
{
if (partidas.Lista[i].Partidas[j].Id == partida.Id)
{
partidas.Lista[i].Partidas.Remove(partida);
}
}
}
clsJugador jugador1 = partida.Jugador1;
clsJugador jugador2 = partida.Jugador2;
//Indica al otro jugador de la partida que la partida ha acabado porque uno de los jugadores se ha ido
if (jugador1.ConnectionID == Context.ConnectionId)
{
Clients.Client(jugador2.ConnectionID).jugadorSeFue();
}
else
{
Clients.Client(jugador1.ConnectionID).jugadorSeFue();
}
}
}
private void ListadoSalas_Tapped(object sender, TappedRoutedEventArgs e)
{
clsPartida partida = (clsPartida)((FrameworkElement)e.OriginalSource).DataContext;
viewModel.ListadoSalas_Tapped(partida);
}
/// <summary>
/// Comprueba si la respuesta dada para la pregunta dada es correcta
/// </summary>
/// <param name="question">La pregunta a comprobar</param>
/// <param name="answer">La respuesta que se desea comprobar si es correcta o no</param>
/// <param name="questionNumber">número de la pregunta (necesario en el cliente)</param>
public void comprobarPregunta(clsQuestion question, String answer, int questionNumber)
{
clsQuestion questionInstanceOfTheGame;
//Obtiene la partida del cliente que llamo a este método
clsPartida partida = partidas.getMatchByConnectionID(Context.ConnectionId);
//Si el cliente está en una partida
if (partida != null)
{
//Si es la respuesta correcta
if (question.correct_answer == answer)
{
//isCorrect = true;
//Si el cliente que llamo al método es el jugador 1, le suma la pregunta acertada e indica que ya ha contestado y que la respuesta es correcta
if (partida.Jugador1.ConnectionID.Equals(Context.ConnectionId))
{
partida.Jugador1.PreguntasAcertadas++;
partida.jugador1HaContestado = true;
partida.jugador1EsRespuestaCorrecta = true;
}
else //Si no, significa que el cliente que llamó al método es el jugador2
{
partida.Jugador2.PreguntasAcertadas++;
partida.jugador2HaContestado = true;
partida.jugador2EsRespuestaCorrecta = true;
}
}
else //Si no es la respuesta correcta
{
//isCorrect = false;
//Si el cliente que llamó al método es el jugador1, le suma la pregunta fallada e indica que el jugador1 ha contestado y que la respuesta no es correcta
if (partida.Jugador1.ConnectionID.Equals(Context.ConnectionId))
{
partida.Jugador1.PreguntasFalladas++;
partida.jugador1HaContestado = true;
partida.jugador1EsRespuestaCorrecta = false;
}
else //Si no, significa que el cliente que llamó al método es el jugador2
{
partida.Jugador2.PreguntasFalladas++;
partida.jugador2HaContestado = true;
partida.jugador2EsRespuestaCorrecta = false;
}
}
//Si ambos jugadores han contestado
if (partida.jugador1HaContestado && partida.jugador2HaContestado)
{
questionInstanceOfTheGame = partida.Preguntas.Find(p => p.question == question.question);
if (questionInstanceOfTheGame != null)
{
questionInstanceOfTheGame.alreadyPlayed = true;
}
//Indica de nuevo que todavía no han contestado (para la proxima vez que se llame a este método)
partida.jugador1HaContestado = false;
partida.jugador2HaContestado = false;
//Informa a los clientes indicando tanto si su respuesta es correcta o no como la de su rival.
Clients.Client(partida.Jugador1.ConnectionID).sendIsCorrect(partida.jugador1EsRespuestaCorrecta, questionNumber);
Clients.Client(partida.Jugador2.ConnectionID).sendRivalIsCorrect(partida.jugador1EsRespuestaCorrecta, questionNumber);
Clients.Client(partida.Jugador2.ConnectionID).sendIsCorrect(partida.jugador2EsRespuestaCorrecta, questionNumber);
Clients.Client(partida.Jugador1.ConnectionID).sendRivalIsCorrect(partida.jugador2EsRespuestaCorrecta, questionNumber);
}
//Clients.Caller.sendIsCorrect(isCorrect);
}
else //Si el cliente no está en una partida, le indica que la partida no existe (puede darse cuando uno de los dos clientes ha salido de la partida, ya que la partida desaparece)
{
Clients.Caller.laPartidaNoExiste();
}
}
/// <summary>
/// Se ejecutará cuando el servidor indique se ha cambiado el turno.
///
/// Se reiniciará el temporizador
/// Se limpiará el canvas, y si es el turno de este cliente se habilitará para que se pueda pintar en el, si no, se deshabilitará.
///
/// Se establecerá la nueva palabra a acertar, mostrándola oculta con guiones en la interfaz.
/// </summary>
/// <param name="obj">La partida que se está jugando</param>
private async void onHaCambiadoElTurno(clsPartida obj)
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (viewModel.PuedesFuncionar)
{
if (obj.ListadoJugadores != null && viewModel.UsuarioPropio.Nickname != null)
{
viewModel.Partida = obj;
viewModel.NotifyPropertyChanged("Partida");
viewModel.HaAcertado = false;
viewModel.UsuarioPropio = obj.ListadoJugadores.FirstOrDefault <clsJugador>(x => x.Nickname == viewModel.UsuarioPropio.Nickname);
viewModel.hanAcertadoTodos = false;
//Iniciamos el timer
viewModel.TimeMax = TIME_MAX;
viewModel.NotifyPropertyChanged("TimeMax");
viewModel.LblTemporizador = TIME_MAX.ToString();
viewModel.NotifyPropertyChanged("LblTemporizador");
viewModel.tiempoEspera = TIME_WAIT;
viewModel.DispatcherTimer.Start();
//Se limpia el canvas
inkCanvas.InkPresenter.StrokeContainer.Clear();
if (obj.ConnectionIDJugadorActual == viewModel.UsuarioPropio.ConnectionID)
//es nuestro turno
{
//Habilitar el canvas
// viewModel.TipoEntradaInkCanvas = CoreInputDeviceTypes.Mouse;
if (viewModel.TimeMax > 88)
{
txtTurno.Visibility = Visibility.Visible;
viewModel.TurnoJugador = "ES TU TURNO";
viewModel.NotifyPropertyChanged("TurnoJugador");
}
inkCanvas.InkPresenter.InputDeviceTypes = CoreInputDeviceTypes.Mouse;
//NotifyPropertyChanged("TipoEntradaInkCanvas");
//palabra a mostrar será la palabra en juego
viewModel.PalabraAMostrar = obj.PalabraEnJuego;
viewModel.NotifyPropertyChanged("PalabraAMostrar");
viewModel.IsMiTurno = true;
viewModel.NotifyPropertyChanged("IsMiTurno");
}
else
{
//No es nuestro turno
if (viewModel.TimeMax >= 88)
{
txtTurno.Visibility = Visibility.Visible;
clsJugador jugador = viewModel.Partida.ListadoJugadores.FirstOrDefault <clsJugador>(x => x.ConnectionID == viewModel.Partida.ConnectionIDJugadorActual);
viewModel.TurnoJugador = "ES EL TURNO DE " + jugador.Nickname;
viewModel.NotifyPropertyChanged("TurnoJugador");
}
//Deshabilitar el canvas
inkCanvas.InkPresenter.InputDeviceTypes = CoreInputDeviceTypes.None;
//InkDrawingAttributes att = new InkDrawingAttributes();
//att.Color = Windows.UI.Colors.Black;
//inkCanvas.InkPresenter.UpdateDefaultDrawingAttributes(att);
ballpointpen.SelectedBrushIndex = 0;
inkToolbar.ActiveTool = null;
// NotifyPropertyChanged("TipoEntradaInkCanvas");
//palabra a mostrar será ___
// viewModel.PalabraAMostrar = "*******"; //esto ponerlo con tantos * como letras tenga y tal
String[] arrayPalabras = obj.PalabraEnJuego.Split(' ');
String palabraResuelta = "";
foreach (var palabra in arrayPalabras)
{
palabraResuelta += new String('-', palabra.Length);
palabraResuelta += " ";
}
viewModel.PalabraAMostrar = palabraResuelta;
viewModel.IsMiTurno = false;
viewModel.NotifyPropertyChanged("IsMiTurno");
viewModel.NotifyPropertyChanged("PalabraAMostrar"); // NotifyPropertyChanged("PalabraAMostrar");
}
}
}
});
}
/// <summary>
/// Método que avanza un turno en una partida, cambiando todas las propiedades
/// pertinentes como el turno actual, la ronda y el jugador actual.
/// Se llamará al método OnHaCambiadoElTurno de todos los clientes del grupo.
/// </summary>
/// <param name="partida">partida en juego en la que se pasará el turno</param>
public void avanzarTurno(clsPartida partida)
{
clsPartida partidaObtenida = obtenerPartidaPorNombreSala(partida.NombreSala);
if (partidaObtenida.RondaActual <= partida.NumeroRondasGlobales)
{
//El cliente que termine su turno, llama a este método
//este método avisa a los clientes de que el turno ha cambiado
//si el cliente detecta que el id del nuevo jugador es el propio
//hace cosas (habilita su canvas), los demas canvas de inhabilitan
//se debe cambiar la palabra en juego
//Obtengo el jugador actual
clsJugador jugadorJugando = partida.ListadoJugadores.FirstOrDefault <clsJugador>(x => x.ConnectionID == partida.ConnectionIDJugadorActual);
////Se ponen todos los "isUltimaPalabraAcertada" a false
for (int i = 0; i < partida.ListadoJugadores.Count; i++)
{
partida.ListadoJugadores[i].IsUltimaPalabraAcertada = false;
//Por si acaso se le pone a todos que NO es su turno
partida.ListadoJugadores[i].IsMiTurno = false;
}
//Obtengo la posicion en la lista de jugadores del jugador actual
int posicion = -1;
for (int i = 0; i < partida.ListadoJugadores.Count || posicion == -1; i++)
{
if (partida.ListadoJugadores[i].ConnectionID == jugadorJugando.ConnectionID)
{
posicion = i;
}
}
//Asigno una nueva palabra
partida.PalabraEnJuego = Utilidad.obtenerPalabraAleatoria();
//TODO rellenar el listado de posiciones a descubrir
partida.PosicionesADescubrir = Utilidad.rellenarPosicionesADescubrir(partida.PalabraEnJuego);
//Cambio el jugador jugando
if (posicion < partida.ListadoJugadores.Count - 1)
{
partida.ConnectionIDJugadorActual = partida.ListadoJugadores[(posicion + 1)].ConnectionID;
}
else
{
//Si ya han jugado todos los jugadores de la lista, se vuelve a empezar
partida.ConnectionIDJugadorActual = partida.ListadoJugadores[0].ConnectionID;
}
//Se le pone que es su turno al jugador
clsJugador jugador = partida.ListadoJugadores.FirstOrDefault <clsJugador>(x => x.ConnectionID == partida.ConnectionIDJugadorActual);
jugador.IsMiTurno = true;
//Cambio el turno/ronda
if (partida.Turno < partida.ListadoJugadores.Count)
{
partida.Turno++;
if (jugadorJugando.IsDesconectado)
{
partida.Turno--;
jugadorJugando.IsDesconectado = false;
}
}
else
{
partida.Turno = 1;
if (partida.RondaActual < partida.NumeroRondasGlobales)
{
partida.RondaActual++;
}
else
{
//Terminaria la partida y se harian cosas
Clients.Group(partida.NombreSala).HaTerminadoLaPartida();
}
}
//Llamo al metodo haCambiadoElTurno de los clientes, y en ese metodo se debera comprobar si le toca al propio usuario
Clients.Group(partida.NombreSala).haCambiadoElTurno(partida);
}
}