protected override void OnNavigatedTo(NavigationEventArgs e)
{
var lastPage = Frame.BackStack.Last().SourcePageType;
//Frame.BackStack.Clear();
//GC.Collect();
//if (e.SourcePageType.FullName.Equals("Pinturillo.CrearSalaPage"))
if (lastPage.FullName.Contains("CrearSalaPage"))
{
if (e.Parameter != null)
{
viewModel.Partida = (clsPartida)e.Parameter;
clsJugador jugadorLider = viewModel.Partida.ListadoJugadores.First <clsJugador>(x => x.IsLider);
//viewModel.Partida.ListadoJugadores.
viewModel.UsuarioPropio = jugadorLider.Nickname;
viewModel.Mensaje.JugadorQueLoEnvia = jugadorLider;
}
}
else
{
if (e.Parameter != null)
{
viewModel.UsuarioPropio = (string)e.Parameter;
}
}
base.OnNavigatedTo(e);
}
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>
/// 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);
}
}
/*
* public class User
* {
* public string Name { get; set; }
*
* public int Age { get; set; }
* }*/
protected override void OnNavigatedTo(NavigationEventArgs e)
{
var lastPage = Frame.BackStack.Last().SourcePageType;
//Frame.BackStack.Clear();
//if (e.SourcePageType.FullName.Equals("Pinturillo.CrearSalaPage"))
if (lastPage.FullName.Contains("SalaEspera"))
{
if (e.Parameter != null)
{
Tuple <String, clsPartida> partidaConNick = (Tuple <String, clsPartida>)e.Parameter;
//viewModel.UsuarioPropio.Nickname = partidaConNick.Item1;
viewModel.Partida = partidaConNick.Item2;
viewModel.NotifyPropertyChanged("Partida");
clsJugador jugadorLider = viewModel.Partida.ListadoJugadores.FirstOrDefault <clsJugador>(x => x.Nickname == partidaConNick.Item1);
//viewModel.Partida.ListadoJugadores.
viewModel.UsuarioPropio = jugadorLider;
viewModel.Mensaje.JugadorQueLoEnvia = viewModel.UsuarioPropio;
//Este invoke solo lo puede emitir el lider (que si no el servidor recibe 5 llamadas pa lo mismo)
//Pero no sé como hacer que solo se invoke una vez ya que aun no está puesto el connectionID del jugador actual en la partida xD
//De momento lo he apañao en el servidor poniendo que si es null la partida no haga nada
}
}
proxy.Invoke("yaHeNavegado", viewModel.Partida.NombreSala);
base.OnNavigatedTo(e);
}
public clsJuegoVM()
{
listadoBotones = new clsListadoBotones().ListadoBotones();
comandoAbandonarPartida = new DelegateCommand(AbandonarPartidaExecute);
listaRandom = new ObservableCollection <clsBoton>();
objJugador = new clsJugador();
//Genera un primer sonido
operacionesListado.GenerarSonidosAleatorios(listaRandom);
//Al generar un primer sonido, contamos como que se ha generado una repetición (para que corresponda con el índice de la lista)
repeticiones = 0;
//Cada segundo suena un sonido de la secuencia
//Si jugador falla se acaba la partida
hacerSonidos = new DispatcherTimer();
hacerSonidos.Tick += HacerSonidosIluminarBoton;
hacerSonidos.Interval = new TimeSpan(0, 0, 1);
hacerSonidos.Start();
//Habilita tablero tras reproducir sonidos
//if (!hacerSonidos.IsEnabled) //Si el temporizador no está en ejecución, habilita el tablero
//{
// tableroHabilitado = true;
// NotifyPropertyChanged("TableroHabilitado");
//}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
var lastPage = Frame.BackStack.Last().SourcePageType;
//Frame.BackStack.Clear();
//GC.Collect();
//if (e.SourcePageType.FullName.Equals("PinturilloParaPruebas3.CrearSalaPage"))
if (lastPage.FullName.Equals("PinturilloParaPruebas3.CrearSalaPage"))
{
if (e.Parameter != null)
{
viewModel.Partida = (clsPartida)e.Parameter;
clsJugador jugadorLider = viewModel.Partida.ListadoJugadores.First <clsJugador>(x => x.IsLider);
//viewModel.Partida.ListadoJugadores.
viewModel.UsuarioPropio = jugadorLider.Nickname;
viewModel.Mensaje.JugadorQueLoEnvia = jugadorLider;
}
}
else
{
if (e.Parameter != null)
{
//TODO aqui hace falta pillar el nombre de la partida que has tappeado
//Tupla item 1 nick, item 2 nombre partida
viewModel.UsuarioPropio = ((Tuple <string, string>)e.Parameter).Item1;
viewModel.Partida.NombreSala = ((Tuple <string, string>)e.Parameter).Item2;
}
}
base.OnNavigatedTo(e);
}
public void Inicio()
{
Console.WriteLine("Servidor escuchando en puerto 8000");
server = new TcpListener(ipendpoint);
server.Start();
while (true)
{
if (juego.Jugadores.Count < 1)
{
client = server.AcceptTcpClient();
con = new Connection();
con.stream = client.GetStream();
con.streamr = new StreamReader(con.stream);
con.streamw = new StreamWriter(con.stream);
con.recibe = con.streamr.ReadLine();
clsMensajeBase msjLee = paquete.recibirMensaje(con.recibe);
Console.WriteLine("Jugador " + msjLee.Nick + " se unio a la partida");
clsJugador jugador = new clsJugador(msjLee.Nick);
juego.agregarJugador(jugador);
cliente = new clsCliente(con.stream, con.streamw, con.streamr, msjLee.Nick);
router.ListaCliente.Add(cliente);
if ((1 - juego.Jugadores.Count) == 0)
{
router.comienzaPartida();
}
Thread t = new Thread(cliente.DataIn);
t.Start();
}
}
}
/// <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);
}
}
}
}
/// <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();
}
}
/// <summary>
/// Método que inserta un nuevo jugador en la BD
/// </summary>
/// <param name="nuevoJugador">objeto clsJugador nuevoJugador</param>
/// <returns>int filasAfectadas</returns>
public int InsertNuevoJugador(clsJugador nuevoJugador)
{
clsMyConnection objConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
int filasAfectadas = 0;
try
{
connection = objConnection.getConnection();
command.Connection = connection;
command.Parameters.Add("@nombreJugador", System.Data.SqlDbType.VarChar).Value = nuevoJugador.NombreJugador;
command.Parameters.Add("@puntuacionJugador", System.Data.SqlDbType.Int).Value = nuevoJugador.Aciertos;
command.CommandText = "INSERT INTO TopScoresSimon (nombreJugador, aciertos) VALUES (@nombreJugador, @puntuacionJugador)";
filasAfectadas = command.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
finally
{
if (connection != null)
{
objConnection.closeConnection(ref connection);
}
}
return(filasAfectadas);
}
/// <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);
}
}
public List <clsJugador> jugadoresGanadores(List <clsJugador> listaJugadores)
{
List <clsJugador> listaARetornar = new List <clsJugador>();
for (int i = 0; i < listaJugadores.Count; i++)
{
List <clsCarton> listaCartones = new List <clsCarton>();
for (int x = 0; x < listaJugadores[i].ListaCartones.Count; x++)
{
if (listaJugadores[i].ListaCartones[x].NumeroAReducirParaGanar == 0)
{
listaCartones.Add(listaJugadores[i].ListaCartones[x]);
}
}
if (listaCartones.Count > 0)
{
clsJugador jugador = new clsJugador();
jugador.ListaCartones = listaCartones;
jugador.NombreJugador = listaJugadores[i].NombreJugador;
listaARetornar.Add(jugador);
}
}
return(listaARetornar);
}
public void quitarJugador(clsJugador j)
{
if (Jugadores.Exists(x => x.Nick == j.Nick))
{
Jugadores.Remove(j);
}
if (Jugadores.Count() == 0)
{
// finJuego(Color.Transparent);
}
}
/// <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>
/// Método que obtiene la lista completa de jugadores aciertos ordenados de mayor a menor
/// </summary>
/// <returns>ObservableCollection<clsJugador> listaJugadores</returns>
public ObservableCollection <clsJugador> GetListaJugadores()
{
clsMyConnection objConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
SqlDataReader reader = null;
clsJugador objJugador;
ObservableCollection <clsJugador> listaJugadores = new ObservableCollection <clsJugador>();
try
{
connection = objConnection.getConnection();
command.Connection = connection;
command.CommandText = "SELECT * FROM TopScoresSimon ORDER BY aciertos DESC";
reader = command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
objJugador = new clsJugador();
objJugador.IdJugador = (int)reader["idJugador"];
objJugador.NombreJugador = (string)reader["nombreJugador"];
objJugador.Aciertos = (int)reader["aciertos"];
listaJugadores.Add(objJugador);
}
}
}
catch (Exception e)
{
throw e;
}
finally
{
if (reader != null)
{
reader.Close();
}
if (connection != null)
{
objConnection.closeConnection(ref connection);
}
}
return(listaJugadores);
}
/// <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;
}
public List <clsJugador> crearJugador(List <clsJugador> listaJugadores, int nombreUsuario, int cantidadCartones, int cantidadNumerosAJugar, int modalidad)
{
clsJugador jugador = new clsJugador(nombreUsuario, cantidadCartones, cantidadNumerosAJugar, modalidad);
if (!(listaJugadores.Count == 0))
{
#region validar cartones repetidos
//Recorre Cada Jugador
for (int x = 0; x < listaJugadores.Count; x++)
{
bool similar = true;
//Recorre cada carton de jugador x
// if (listaJugadores[x].ListaCartones.)
for (int i = 0; i < listaJugadores[x].ListaCartones.Count; i++)
{
//Recorre nuevo jugador
for (int z = 0; z < jugador.ListaCartones.Count; z++)
{
//recorre cada celda
for (int p = 0; p < 5; p++)
{
for (int q = 0; q < 5; q++)
{
if (!(q == 3 && p == 3))
{
//valida si encuentra una diferencia
if (!(listaJugadores[x].ListaCartones[i].Columnas[p][q].Numero == jugador.ListaCartones[z].Columnas[p][q].Numero))
{
similar = false;
}
}
}
}
if (similar)
{
jugador = new clsJugador(nombreUsuario, cantidadCartones, cantidadNumerosAJugar, modalidad);
x = -1;
}
}
}
}
#endregion
}
listaJugadores.Add(jugador);
return(listaJugadores);
}
/// <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 bool PuedeVoltear
//{
// get
// {
// return puedeVoltear;
// }
// set
// {
// puedeVoltear = value;
// }
//}
#endregion
#region Constructores
public clsJuegoVM()
{
//Relleno la lista de cartas
clsListadoCompletoCartas listadoCartas = new clsListadoCompletoCartas();
listadoCompletoCartas = listadoCartas.ListadoCompletoCartasEnCasilla();
//El tablero inicialmente está habilitado
tableroHabilitado = true;
//Instancia el jugador de la partida
objJugador = new clsJugador();
commandAbandonarPartida = new DelegateCommand(ComprobarSalirPartida);
//Cosas del DispatcherTimer
tiempoPuntuacion = new DispatcherTimer();
tiempoPuntuacion.Tick += MostrarTiempo;
tiempoPuntuacion.Interval = new TimeSpan(0, 0, 1);
//Empieza a contar el tiempo al comenzar la partida
tiempoPuntuacion.Start();
}
/// <summary>
/// Se ejecuta cuando se ha navegado a esta pantalla.
///
/// Obtiene de la anterior pantalla tanto la partida como el nombre de usuario, necesarios para poder preparar esta pantalla para el inicio de la partida.
///
/// Al acabar, indica al servidor que ya ha navegado.
/// </summary>
/// <param name="e"></param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
var lastPage = Frame.BackStack.Last().SourcePageType;
//Frame.BackStack.Clear();
//if (e.SourcePageType.FullName.Equals("Pinturillo.CrearSalaPage"))
if (lastPage.FullName.Equals("Pinturillo.SalaEspera"))
{
if (e.Parameter != null)
{
Tuple <String, clsPartida> partidaConNick = (Tuple <String, clsPartida>)e.Parameter;
//viewModel.UsuarioPropio.Nickname = partidaConNick.Item1;
viewModel.Partida = partidaConNick.Item2;
viewModel.NotifyPropertyChanged("Partida");
clsJugador jugadorLider = viewModel.Partida.ListadoJugadores.FirstOrDefault <clsJugador>(x => x.Nickname == partidaConNick.Item1);
//viewModel.Partida.ListadoJugadores.
viewModel.UsuarioPropio = jugadorLider;
viewModel.Mensaje.JugadorQueLoEnvia = viewModel.UsuarioPropio;
//Este invoke solo lo puede emitir el lider (que si no el servidor recibe 5 llamadas pa lo mismo)
//Pero no sé como hacer que solo se invoke una vez ya que aun no está puesto el connectionID del jugador actual en la partida xD
//De momento lo he apañao en el servidor poniendo que si es null la partida no haga nada
//if (viewModel.UsuarioPropio.IsLider && viewModel.PuedesFuncionar)
// //Esto es un apaño, tengo que cambiarlo para que haga el invoke "el primero que no sea null" (por si el usuario 0 se habia salido o algo asi)
//{
// proxy.Invoke("comenzarPartidaEnGrupo", viewModel.Partida);
//}
}
}
//Notificar al servidor que ya he navegado
proxy.Invoke("yaHeNavegado", viewModel.Partida.NombreSala);
base.OnNavigatedTo(e);
}
public clsJuegoVM()
{
listadoBotones = new clsListadoBotones().ListadoBotones();
comandoAbandonarPartida = new DelegateCommand(AbandonarPartidaExecute);
listaRandom = new ObservableCollection <clsBoton>();
objJugador = new clsJugador();
//Genera un primer sonido
operacionesListado.GenerarSonidosAleatorios(listaRandom);
//Al generar un primer sonido, contamos como que se ha generado una repetición (para que corresponda con el índice de la lista)
repeticiones = 0;
//Cada segundo suena un sonido de la secuencia
//Si jugador falla se acaba la partida
hacerSonidos = new DispatcherTimer();
hacerSonidos.Tick += HacerSonidosIluminarBoton;
hacerSonidos.Interval = new TimeSpan(0, 0, 1);
hacerSonidos.Start();
}
/// <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>
/// Callback sobreescrito que se llama cuando un cliente se desconecta.
/// Este método llama a jugador ha salido si el cliente desconectado pertenecía a un grupo.
/// </summary>
/// <param name="stopCalled">indica si la desconexión fue forzosa o no</param>
/// <returns></returns>
public override Task OnDisconnected(bool stopCalled)
{
//Obtener el ID de conexion del usuario que ha salido
clsJugador jugadorQueSeDesconecta = null;
string nombreGrupo = "";
bool encontrado = false;
for (int i = 0; i < listadoSalas.ListadoPartidas.Count && !encontrado; i++)
{
for (int j = 0; j < listadoSalas.ListadoPartidas[i].ListadoJugadores.Count && !encontrado; j++)
{
if (listadoSalas.ListadoPartidas[i].ListadoJugadores[j].ConnectionID == Context.ConnectionId)
{
jugadorQueSeDesconecta = listadoSalas.ListadoPartidas[i].ListadoJugadores[j];
nombreGrupo = listadoSalas.ListadoPartidas[i].NombreSala;
encontrado = true;
}
}
}
//Comprobar si estaba en algun grupo
if (encontrado) //Si estaba en un grupo, sacarlo
{
jugadorHaSalido(jugadorQueSeDesconecta.Nickname, nombreGrupo);
}
encontrado = false;
for (int i = 0; i < this.listadoNickConConnectionID.ListadoNickConConnectionID.Count && !encontrado; i++)
{
if (Context.ConnectionId == this.listadoNickConConnectionID.ListadoNickConConnectionID[i].Item2)
{
encontrado = true;
this.listadoNickConConnectionID.ListadoNickConConnectionID.RemoveAt(i); //Se elimina del listado de nicks
}
}
return(base.OnDisconnected(stopCalled));
}
/// <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();
}
}
}
/// <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);
}
}
/// <summary>
/// Método que inserta un nuevo jugador en la BD
/// </summary>
/// <param name="nuevoJugador">objeto clsJugador nuevoJugador</param>
/// <returns>int que representa la filas afectadas al ejecutar la inserción</returns>
public int InsertNuevoJugador(clsJugador nuevoJugador)
{
return(new clsOperacionesJugadorDAL().InsertNuevoJugador(nuevoJugador));
}
/// <summary>
/// Se ejecutará cuando el servidor indique que la partido ha comenzado.
///
/// Se inicia el temporizador para el primer turno.
///
/// Si es el turno del cliente, se habilita el canvas, si no, se deshabilita.
///
/// Se establecerá la nueva palabra a acertar, mostrándola oculta con guiones en la interfaz.
/// </summary>
/// <param name="obj">La partida que acaba de comenzar</param>
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)
{
obj.ListadoMensajes = new System.Collections.ObjectModel.ObservableCollection <clsMensaje>();
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
{
if (viewModel.TimeMax >= 88)
{
txtTurno.Visibility = Visibility.Visible;
viewModel.TurnoJugador = "ES TU TURNO";
viewModel.NotifyPropertyChanged("TurnoJugador");
}
//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
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
// 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");
}
}
});
}
/// <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");
}
}
}
});
}
public void agregarJugador(clsJugador j)
{
j.Color = listaColores[Jugadores.Count];
Jugadores.Add(j);
}