Ejemplo n.º 1
0
 /// <summary>
 /// Realiza el proceso para validar una cuenta.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void Bt_Aceptar_Click(object sender, RoutedEventArgs e)
 {
     if (!tb_CodigoVerificacion.Text.Equals(""))
     {
         if (ValidarCodigo(tb_CodigoVerificacion.Text))
         {
             try {
                 ServiceSYE.Jugador jugador = cliente.ObtenerJugadorPorCodigo(tb_CodigoVerificacion.Text);
                 if (!jugador.NombreUsuario.Equals("*"))
                 {
                     ValidarCuentaJugador(jugador);
                 }
                 else
                 {
                     MessageBox.Show(Properties.Resources.mb_ConexionBD, Properties.Resources.mb_Alerta);
                 }
             } catch (CommunicationException) {
                 MessageBox.Show(Properties.Resources.mb_ConexionServidor, Properties.Resources.mb_Alerta);
             }
         }
         else
         {
             tb_CodigoVerificacion.Text = "";
             MessageBox.Show(Properties.Resources.mb_SoloNumeros, Properties.Resources.mb_Alerta);
         }
     }
     else
     {
         MessageBox.Show(Properties.Resources.mb_CodigoVacio, Properties.Resources.mb_Alerta);
     }
 }
Ejemplo n.º 2
0
 /// <summary>
 /// Realiza el proceso para enviar, nuevamente, el código de verificación al correo del jugador.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void Bt_Enviar_Click(object sender, RoutedEventArgs e)
 {
     if (ValidarDatos())
     {
         try {
             ServiceSYE.Jugador jugador = cliente.ObtenerJugadorPorNombre(tb_NombreUsuario.Text);
             if (ValidarJugador(jugador))
             {
                 if (!jugador.Codigo.Equals("00000"))
                 {
                     Registrarse registrarse = new Registrarse();
                     String      codigo      = registrarse.GenerarCodigo();
                     if (!codigo.Equals("*") && !codigo.Equals("**"))
                     {
                         EnviarNuevoCodigo(jugador, codigo);
                     }
                     else
                     {
                         MandarMensajeErrorCodigo(codigo);
                     }
                 }
                 else
                 {
                     MessageBox.Show(Properties.Resources.mb_CuentaYaVerificada, Properties.Resources.mb_Alerta);
                 }
             }
         } catch (CommunicationException) {
             MessageBox.Show(Properties.Resources.mb_ConexionServidor, Properties.Resources.mb_Alerta);
         }
     }
     tb_NombreUsuario.Text = "";
 }
Ejemplo n.º 3
0
 /// <summary>
 /// Registra al jugador en el sistema.
 /// </summary>
 /// <param name="jugador">
 /// Objeto jugador con los datos del jugador que se va a registrar.
 /// </param>
 private void RegistrarJugador(ServiceSYE.Jugador jugador)
 {
     try {
         if (cliente.EnviarCodigoACorreo(jugador, Properties.Resources.ms_Asunto, Properties.Resources.ms_IngresaCodigo, Properties.Resources.ms_Mensaje))
         {
             if (cliente.RegistrarJugador(jugador))
             {
                 MessageBox.Show(Properties.Resources.mb_RegistroExitoso, Properties.Resources.mb_Listo);
                 MessageBox.Show(Properties.Resources.mb_CorreoEnviado, Properties.Resources.mb_Codigo);
                 ValidarCuenta validarCuenta = new ValidarCuenta();
                 validarCuenta.Show();
                 this.Close();
             }
             else
             {
                 MessageBox.Show(Properties.Resources.mb_ConexionBD, Properties.Resources.mb_Alerta);
             }
         }
         else
         {
             MessageBox.Show(Properties.Resources.mb_RegistroFallido, Properties.Resources.mb_Alerta);
         }
     } catch (CommunicationException) {
         MessageBox.Show(Properties.Resources.mb_ConexionServidor, Properties.Resources.mb_Alerta);
     }
 }
Ejemplo n.º 4
0
 /// <summary>
 /// Constructor de la ventana Espera.
 /// </summary>
 /// <param name="jugador">
 /// Objeto jugador que se mandó desde el menú.
 /// </param>
 /// <param name="partida">
 /// Objeto partida que se mandó desde el menú.
 /// </param>
 /// /// <param name="clientePartida">
 /// Conexión con el servidor para acceder a los métodos que proporciona sobre las partidas.
 /// </param>
 /// /// <param name="clienteChat">
 /// Conexión con el servidor para acceder a los métodos que proporciona sobre el chat.
 /// </param>
 /// /// <param name="partidas">
 /// Objeto mensajes que implementa los métodos que reciben respuesta del servidor, sobre las partidas.
 /// </param>
 /// /// <param name="mensajes">
 /// Objeto mensajes que implementa los métodos que reciben respuesta del servidor, sobre el chat.
 /// </param>
 public Partida(ServiceSYE.Jugador jugador, ServiceSYE.Partida partida, ServiceSYE.PartidaClient clientePartida, ServiceSYE.ChatClient clienteChat, Partidas partidas, Mensajes mensajes)
 {
     InitializeComponent();
     this.Title          = this.Title + " - " + jugador.NombreUsuario;
     partidas.Partida    = this;
     mensajes.Partida    = this;
     this.Jugador        = jugador;
     this.clienteChat    = clienteChat;
     this.clientePartida = clientePartida;
     this.clienteJugador = new ServiceSYE.JugadorClient();
     try {
         this.PartidaEnJuego = clientePartida.ObtenerPartida(partida.Nombre);
         DispatcherTimer temporizadorInicio = new DispatcherTimer();
         temporizadorInicio.Interval = new TimeSpan(0, 0, 5);
         temporizadorInicio.Tick    += (a, b) => {
             temporizadorInicio.Stop();
             if (PartidaEnJuego.JugadoresPartida.ElementAt(0).Value.NombreUsuario.Equals(jugador.NombreUsuario))
             {
                 try {
                     clienteChat.EnviarMensajePartida("", PartidaEnJuego.Nombre, 1);
                 } catch (CommunicationException) {
                     EnviarMensajeError();
                 }
             }
         };
         temporizadorInicio.Start();
         CargarTablero();
         CargarBonus();
         this.Jugador = ObtenerTurno(PartidaEnJuego.JugadoresPartida, this.Jugador);
         EnviarMensajeTurnos();
         ValidarConectado();
     } catch (CommunicationException) {
         EnviarMensajeError();
     }
 }
Ejemplo n.º 5
0
        /// <summary>
        /// Verifica que un jugador ganó la partida.
        /// </summary>
        /// <param name="nombreUsuario">
        /// Nombre del jugador que acaba de pasar su turno.
        /// </param>
        /// <returns>
        /// Valor boolenan que es True si el jugador ganó la partida y si no es False.
        /// </returns>
        private Boolean VerificarGanador(String nombreUsuario)
        {
            Boolean verificar = false;

            ServiceSYE.Jugador jugadorMovimiento = new ServiceSYE.Jugador();
            for (int i = 0; i < PartidaEnJuego.JugadoresPartida.Count; i++)
            {
                if (PartidaEnJuego.JugadoresPartida.ElementAt(i).Value.NombreUsuario.Equals(nombreUsuario))
                {
                    jugadorMovimiento = PartidaEnJuego.JugadoresPartida.ElementAt(i).Value;
                }
            }
            if (jugadorMovimiento.Turno.Casilla.Numero == 100)
            {
                verificar        = true;
                tb_Mensajes.Text = tb_Mensajes.Text + "*" + jugadorMovimiento.NombreUsuario + Properties.Resources.ms_Gano + "*\n\n";
                tb_Mensajes.ScrollToEnd();
                posicionJugadores = new List <ServiceSYE.Jugador>();
                List <ServiceSYE.Jugador> posicionJugadoresAux = new List <ServiceSYE.Jugador>();
                List <int> premios = DefinirPremios(PartidaEnJuego.JugadoresPartida.Count);
                for (int i = 0; i < PartidaEnJuego.JugadoresPartida.Count; i++)
                {
                    posicionJugadoresAux.Add(PartidaEnJuego.JugadoresPartida.ElementAt(i).Value);
                }
                for (int i = PartidaEnJuego.JugadoresPartida.Count; i > 0; i--)
                {
                    ServiceSYE.Jugador jugadorMasAlto = DefinirJugadorMasAlto(posicionJugadoresAux, i);
                    posicionJugadoresAux.Remove(jugadorMasAlto);
                    jugadorMasAlto.Estadisticas.Puntos = Convert.ToInt16(premios.ElementAt(i - 1));
                    posicionJugadores.Add(jugadorMasAlto);
                    GuardarNuevasEstadisticas(jugadorMasAlto, i);
                }
            }
            return(verificar);
        }
Ejemplo n.º 6
0
 /// <summary>
 /// Realiza el proceso para iniciar sesión.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void Bt_Ingresar_Click(object sender, RoutedEventArgs e)
 {
     if (ValidarDatos())
     {
         try {
             ServiceSYE.Jugador jugador = cliente.IniciarSesion(tb_NombreUsuario.Text, ComputeSha256Hash(pb_Contrasenia.Password));
             if (!jugador.NombreUsuario.Equals("*"))
             {
                 if (!jugador.NombreUsuario.Equals(""))
                 {
                     Ingresar(jugador);
                 }
                 else
                 {
                     MessageBox.Show(Properties.Resources.mb_NombreUsuarioOContraseniaIncorrectos, Properties.Resources.mb_Alerta);
                 }
             }
             else
             {
                 MessageBox.Show(Properties.Resources.mb_ConexionBD, Properties.Resources.mb_Alerta);
             }
         } catch (CommunicationException) {
             MessageBox.Show(Properties.Resources.mb_ConexionServidor, Properties.Resources.mb_Alerta);
         }
     }
     tb_NombreUsuario.Text   = "";
     pb_Contrasenia.Password = "";
 }
Ejemplo n.º 7
0
        public void DefinirJugadorMasAltoTest()
        {
            jugadores.Add(new ServiceSYE.Jugador {
                NombreUsuario = "Josue",
                Turno         = new ServiceSYE.Turno {
                    NumeroTurno = 1,
                    Casilla     = new ServiceSYE.Casilla {
                        Numero = 8
                    }
                }
            });
            jugadores.Add(new ServiceSYE.Jugador {
                NombreUsuario = "Josue2",
                Turno         = new ServiceSYE.Turno {
                    NumeroTurno = 1,
                    Casilla     = new ServiceSYE.Casilla {
                        Numero = 18
                    }
                }
            });
            jugadores.Add(new ServiceSYE.Jugador {
                NombreUsuario = "Josue3",
                Turno         = new ServiceSYE.Turno {
                    NumeroTurno = 1,
                    Casilla     = new ServiceSYE.Casilla {
                        Numero = 28
                    }
                }
            });
            jugador = partida.DefinirJugadorMasAlto(jugadores, 3);
            String esperado = jugador.NombreUsuario;

            Assert.AreEqual("Josue3", esperado);
        }
Ejemplo n.º 8
0
 /// <summary>
 /// Realiza el proceso para mover la ficha del jugador.
 /// </summary>
 /// <param name="nombreUsuario">
 /// Nombre del jugador del que se moverá su ficha.
 /// </param>
 /// <param name="mensaje">
 /// Mensaje que envía el juego.
 /// En este caso se recibe el mansaje para saber si cuando el jugador tiro en bonus obtuvo un 4, que en ese caso no se realiza ningún movimiento de la ficha.
 /// </param>
 public void DeterminarMovimiento(String nombreUsuario, String mensaje)
 {
     try {
         PartidaEnJuego = clientePartida.ObtenerPartida(PartidaEnJuego.Nombre);
         if (bonus && mensaje.Equals("4"))
         {
             CambiarTurno(nombreUsuario);
         }
         else
         {
             lb_Dado.Content = "";
             ServiceSYE.Jugador jugadorMovimiento = DeterminarJugadorMovimiento(nombreUsuario);
             MoverFicha(jugadorMovimiento);
             if (jugadorMovimiento.Turno.Casilla.Movimiento != 0)
             {
                 MoverFichaSerpienteOEscalera(jugadorMovimiento);
             }
             else
             {
                 if (jugadorMovimiento.Turno.Casilla.Bonus)
                 {
                     bonus = true;
                     TirarBonus(jugadorMovimiento);
                 }
                 else
                 {
                     CambiarTurno(nombreUsuario);
                 }
             }
         }
     } catch (CommunicationException) {
         EnviarMensajeError();
     }
 }
Ejemplo n.º 9
0
        /// <summary>
        /// Constructor de la ventana Espera.
        /// </summary>
        /// <param name="jugador">
        /// Objeto jugador que se mandó desde el menú.
        /// </param>
        /// <param name="partida">
        /// Objeto partida que se mandó desde el menú.
        /// </param>
        public Espera(ServiceSYE.Jugador jugador, ServiceSYE.Partida partida)
        {
            InitializeComponent();
            if (lb_Esperando.Content.ToString().Substring(0, 1).Equals("E"))
            {
                lb_Esperando.FontSize = 40;
            }
            this.Title    = this.Title + " - " + jugador.NombreUsuario;
            this.Jugador  = jugador;
            this.Partida  = partida;
            this.Partidas = new Partidas();
            InstanceContext contextoPartida = new InstanceContext(Partidas);

            this.ClientePartida  = new ServiceSYE.PartidaClient(contextoPartida);
            this.Mensajes        = new Mensajes();
            this.Mensajes.Espera = this;
            InstanceContext contextoChat = new InstanceContext(Mensajes);

            this.ClienteChat    = new ServiceSYE.ChatClient(contextoChat);
            this.clienteJugador = new ServiceSYE.JugadorClient();
            try {
                ClientePartida.UnirsePartida(jugador, partida.Nombre);
                ClienteChat.UnirseChat(jugador.NombreUsuario, partida.Nombre);
                ValidarConectado();
                ClienteChat.EnviarMensaje("", partida.Nombre);
            } catch (CommunicationException) {
                EnviarMensajeError();
            }
        }
Ejemplo n.º 10
0
 /// <summary>
 /// Constructor de la ventana MenuPrincipal.
 /// </summary>
 /// <param name="jugador">
 /// Objeto jugador que ingreso al juego.
 /// </param>
 public MenuPrincipal(ServiceSYE.Jugador jugador)
 {
     InitializeComponent();
     this.Title   = this.Title + " - " + jugador.NombreUsuario;
     this.jugador = jugador;
     CargarDatos();
     ValidarConectado();
 }
Ejemplo n.º 11
0
 /// <summary>
 /// Define el jugador más alto en una lista de jugadores según su posición de su casilla.
 /// </summary>
 /// <param name="posicionJugadoresAux">
 /// Lista de jugadores de la cual se definirá el jugador más alto.
 /// </param>
 /// <param name="contador">
 /// Valor enetero que define el contador según el número de jugadores de la lista.
 /// </param>
 /// <returns>
 /// Objeto jugador con la posición de casilla más alta.
 /// </returns>
 public ServiceSYE.Jugador DefinirJugadorMasAlto(List <ServiceSYE.Jugador> posicionJugadoresAux, int contador)
 {
     ServiceSYE.Jugador jugadorMasAlto = posicionJugadoresAux.ElementAt(0);
     for (int j = 1; j < contador; j++)
     {
         if (jugadorMasAlto.Turno.Casilla.Numero < posicionJugadoresAux.ElementAt(j).Turno.Casilla.Numero)
         {
             jugadorMasAlto = posicionJugadoresAux.ElementAt(j);
         }
     }
     return(jugadorMasAlto);
 }
Ejemplo n.º 12
0
 /// <summary>
 /// Determina quien es el jugador del cual se moverá su ficha.
 /// </summary>
 /// <param name="nombreUsuario">
 /// Nombre del jugador que se moverá su ficha.
 /// </param>
 /// <returns>
 /// Objeto jugador que tiene los datos del jugador que moverá su ficha.
 /// </returns>
 public Jugador DeterminarJugadorMovimiento(String nombreUsuario)
 {
     ServiceSYE.Jugador jugadorMovimiento = new ServiceSYE.Jugador();
     for (int i = 0; i < PartidaEnJuego.JugadoresPartida.Count; i++)
     {
         if (PartidaEnJuego.JugadoresPartida.ElementAt(i).Value.NombreUsuario.Equals(nombreUsuario))
         {
             jugadorMovimiento = PartidaEnJuego.JugadoresPartida.ElementAt(i).Value;
         }
     }
     return(jugadorMovimiento);
 }
Ejemplo n.º 13
0
 /// <summary>
 /// Crear un objeto jugador con los datos ingresados en la interfaz gráfica.
 /// </summary>
 /// <returns>
 /// Objeto jugador con los datos del jugador que se va a registrar.
 /// </returns>
 private ServiceSYE.Jugador CrearNuevoJugador()
 {
     ServiceSYE.Jugador jugador = new ServiceSYE.Jugador {
         NombreUsuario     = tb_NombreUsuario.Text,
         Contrasenia       = ComputeSha256Hash(pb_Contrasenia.Password),
         CorreoElectronico = tb_CorreoElectronico.Text,
         Codigo            = GenerarCodigo(),
         Estadisticas      = new ServiceSYE.Estadisticas {
             Puntos    = 1000,
             Victorias = 0,
         }
     };
     return(jugador);
 }
Ejemplo n.º 14
0
        public void ObtenerTurnoTest()
        {
            jugador.NombreUsuario = "Josue";
            jugadoresPartida.Add(1, new ServiceSYE.Jugador {
                NombreUsuario = "Josue",
                Turno         = new ServiceSYE.Turno {
                    NumeroTurno = 1,
                },
            });
            jugador = partida.ObtenerTurno(jugadoresPartida, jugador);
            int esperado = jugador.Turno.NumeroTurno;

            Assert.AreEqual(1, esperado);
        }
Ejemplo n.º 15
0
 /// <summary>
 /// Guarda las nuevas estadísticas (puntos y vitorias) de un jugador al terminar la partida.
 /// </summary>
 /// <param name="jugadorMasAlto">
 /// Objecto jugador que tiene los datos del jugador que se guardaran sus nuevas estadísticas.
 /// </param>
 /// <param name="contador">
 /// Valor entero que si es igual al número de jugador de la partida sirve para aumentar una victoria al jugador.
 /// </param>
 private void GuardarNuevasEstadisticas(ServiceSYE.Jugador jugadorMasAlto, int contador)
 {
     if (Jugador.NombreUsuario.Equals(jugadorMasAlto.NombreUsuario))
     {
         Jugador.Estadisticas.Puntos = Convert.ToInt16(Jugador.Estadisticas.Puntos + jugadorMasAlto.Estadisticas.Puntos);
         if (contador == PartidaEnJuego.JugadoresPartida.Count)
         {
             Jugador.Estadisticas.Victorias = Convert.ToInt16(Jugador.Estadisticas.Victorias + 1);
         }
         try {
             clienteJugador.ModificarEstadisticas(Jugador.NombreUsuario, Jugador.Estadisticas.Puntos, Jugador.Estadisticas.Victorias);
         } catch (CommunicationException) {
             MessageBox.Show(Properties.Resources.mb_ConexionBD2, Properties.Resources.mb_Alerta);
         }
     }
 }
Ejemplo n.º 16
0
 /// <summary>
 /// Realiza el proceso para enviar el mensaje de que un jugador cayó en una casilla bonus.
 /// </summary>
 /// <param name="jugadorMovimiento">
 /// Objecto jugador que tiene los datos del jugador que cayó en una casilla bonus.
 /// </param>
 private void TirarBonus(ServiceSYE.Jugador jugadorMovimiento)
 {
     if (jugadorMovimiento.NombreUsuario.Equals(Jugador.NombreUsuario))
     {
         DispatcherTimer temporizadorBonus = new DispatcherTimer();
         temporizadorBonus.Interval = new TimeSpan(0, 0, 2);
         temporizadorBonus.Tick    += (a, b) => {
             temporizadorBonus.Stop();
             try {
                 clienteChat.EnviarMensajePartida("", PartidaEnJuego.Nombre, 2);
             } catch (CommunicationException) {
                 EnviarMensajeError();
             }
         };
         temporizadorBonus.Start();
     }
 }
Ejemplo n.º 17
0
        /// <summary>
        /// Constructor de la ventana UnirsePartida.
        /// </summary>
        /// <param name="menuPrincipal">
        /// Ventana MenúPrincipal de la cual se mandó a llamar la ventana.
        /// </param>
        /// <param name="jugador">
        /// Objeto jugador que se mandó desde el menú.
        /// </param>
        public UnirsePartida(MenuPrincipal menuPrincipal, ServiceSYE.Jugador jugador)
        {
            InitializeComponent();
            this.menuPrincipal = menuPrincipal;
            this.jugador       = jugador;
            Partidas partidas = new Partidas();

            partidas.UnirsePartida = this;
            InstanceContext contexto = new InstanceContext(partidas);

            clientePartida = new ServiceSYE.PartidaClient(contexto);
            try {
                clientePartida.VerPartidas(jugador.NombreUsuario);
            } catch (CommunicationException) {
                MessageBox.Show(Properties.Resources.mb_ConexionServidor, Properties.Resources.mb_Alerta);
            }
            CargarPartidas();
        }
Ejemplo n.º 18
0
 /// <summary>
 /// Envía el correo electrónico al jugador con el nuevo código de verificación.
 /// </summary>
 /// <param name="jugador">
 /// Objeto jugador que contiene los datos del jugador al que se le va a enviar el correo.
 /// </param>
 /// <param name="codigo">
 /// Código que se enviará al jugador.
 /// </param>
 private void EnviarNuevoCodigo(ServiceSYE.Jugador jugador, String codigo)
 {
     if (cliente.ModificarCodigo(jugador.Codigo, codigo))
     {
         jugador.Codigo = codigo;
         if (cliente.EnviarCodigoACorreo(jugador, Properties.Resources.ms_Asunto, Properties.Resources.ms_IngresaCodigo, Properties.Resources.ms_Mensaje))
         {
             MessageBox.Show(Properties.Resources.mb_CodigoEnviado + jugador.CorreoElectronico + Properties.Resources.mb_IngreseCodigo, Properties.Resources.mb_Alerta);
         }
         else
         {
             MessageBox.Show(Properties.Resources.mb_EnvioFallido, Properties.Resources.mb_Alerta);
         }
     }
     else
     {
         MessageBox.Show(Properties.Resources.mb_ConexionBD, Properties.Resources.mb_Alerta);
     }
 }
Ejemplo n.º 19
0
        /// <summary>
        /// Verifica si el nombre de usuario no está ocupado por otro jugador.
        /// </summary>
        /// <param name="nombre">
        /// Nombre de usuario que se quiere verificar.
        /// </param>
        /// <returns>
        /// Valor entero que es´0 si el nombre está disponible, es 1 si no está disponible, es 2 si hubo un error en la base de datos y es 3 si hubo un error con el servidor.
        /// </returns>
        public int VerificarNombreUsuario(string nombre)
        {
            int verificar = 1;

            try {
                ServiceSYE.Jugador jugador = cliente.ObtenerJugadorPorNombre(nombre);
                if (jugador.NombreUsuario.Equals(""))
                {
                    verificar = 0;
                }
                if (jugador.NombreUsuario.Equals("*"))
                {
                    verificar = 2;
                }
            } catch (CommunicationException) {
                verificar = 3;
            }
            return(verificar);
        }
Ejemplo n.º 20
0
        /// <summary>
        /// Verifica si el correo electrónico no está ocupado por otro jugador.
        /// </summary>
        /// <param name="correo">
        /// Correo electrónico que se quiere verificar.
        /// </param>
        /// <returns>
        /// Valor entero que es´0 si el correo está disponible, es 1 si no está disponible, es 2 si hubo un error en la base de datos y es 3 si hubo un error con el servidor.
        /// </returns>
        public int VerificarCorreoElectronico(string correo)
        {
            int verificar = 1;

            try {
                ServiceSYE.Jugador jugador = cliente.ObtenerJugadorPorCorreo(correo);
                if (jugador.CorreoElectronico.Equals(""))
                {
                    verificar = 0;
                }
                if (jugador.NombreUsuario.Equals("*"))
                {
                    verificar = 2;
                }
            } catch (CommunicationException) {
                verificar = 3;
            }
            return(verificar);
        }
Ejemplo n.º 21
0
 /// <summary>
 /// Valida la cuenta de un jugador en el sistema.
 /// </summary>
 /// <param name="jugador">
 /// Objeto jugador que contiene los datos de la cuenta del jugador que se va a validar.
 /// </param>
 private void ValidarCuentaJugador(ServiceSYE.Jugador jugador)
 {
     if (jugador.Codigo.Equals(tb_CodigoVerificacion.Text))
     {
         if (cliente.ValidarCuentaJugador(tb_CodigoVerificacion.Text))
         {
             MessageBox.Show(Properties.Resources.mb_CuentaValidada + jugador.NombreUsuario + ".", Properties.Resources.mb_Listo);
             this.Close();
         }
         else
         {
             MessageBox.Show(Properties.Resources.mb_ConexionBD, Properties.Resources.mb_Alerta);
         }
     }
     else
     {
         tb_CodigoVerificacion.Text = "";
         MessageBox.Show(Properties.Resources.mb_CodigoIncorrecto, Properties.Resources.mb_Alerta);
     }
 }
Ejemplo n.º 22
0
 /// <summary>
 /// Ingresa al usuario al sistema.
 /// Verifica que el jugador tenga su cuenta validada y que no esté conectado.
 /// Invoca a la ventana de MenuPrincipal.
 /// </summary>
 /// <param name="jugador">
 /// Objeto jugador con los datos del jugador que quiere iniciar sesión.
 /// </param>
 private void Ingresar(ServiceSYE.Jugador jugador)
 {
     if (jugador.Codigo.Equals("00000"))
     {
         if (cliente.ValidarConectado(jugador))
         {
             cliente.UnirseAlJuego(jugador);
             MenuPrincipal menuPrincipal = new MenuPrincipal(jugador);
             menuPrincipal.Show();
             this.Close();
         }
         else
         {
             MessageBox.Show(Properties.Resources.ms_JugadorConectado, Properties.Resources.mb_Alerta);
         }
     }
     else
     {
         MessageBox.Show(Properties.Resources.mb_CuentaNoValidada, Properties.Resources.mb_Alerta);
     }
 }
Ejemplo n.º 23
0
        /// <summary>
        /// Valida que se haya encontrado el jugador y que no hubo algún error.
        /// </summary>
        /// <param name="jugador">
        /// Objeto jugador que se quiere validar.
        /// </param>
        /// <returns></returns>
        private Boolean ValidarJugador(ServiceSYE.Jugador jugador)
        {
            Boolean validar = false;

            if (!jugador.NombreUsuario.Equals("*"))
            {
                if (!jugador.NombreUsuario.Equals(""))
                {
                    validar = true;
                }
                else
                {
                    MessageBox.Show(Properties.Resources.mb_JugadorInexistente, Properties.Resources.mb_Alerta);
                }
            }
            else
            {
                MessageBox.Show(Properties.Resources.mb_ConexionBD, Properties.Resources.mb_Alerta);
            }
            return(validar);
        }
Ejemplo n.º 24
0
 /// <summary>
 /// Realiza el proceso para registrar a un jugador.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void Bt_Registrarse_Click(object sender, RoutedEventArgs e)
 {
     if (ValidarDatos())
     {
         ServiceSYE.Jugador jugador = CrearNuevoJugador();
         if (!jugador.Codigo.Equals("*") && !jugador.Codigo.Equals("**"))
         {
             RegistrarJugador(jugador);
         }
         else
         {
             if (jugador.Codigo.Equals("*"))
             {
                 MessageBox.Show(Properties.Resources.mb_ConexionBD, Properties.Resources.mb_Alerta);
             }
             else
             {
                 MessageBox.Show(Properties.Resources.mb_ConexionServidor, Properties.Resources.mb_Alerta);
             }
         }
     }
 }
Ejemplo n.º 25
0
 /// <summary>
 /// Realiza el proceso para determinar el movimiento de la ficha de un jugador si es que cayó en una serpiente o una escalera.
 /// </summary>
 /// <param name="jugadorMovimiento">
 /// Objecto jugador que tiene los datos del jugador que cayó en una serpiente o escalera.
 /// </param>
 private void MoverFichaSerpienteOEscalera(ServiceSYE.Jugador jugadorMovimiento)
 {
     try {
         if (jugadorMovimiento.NombreUsuario.Equals(Jugador.NombreUsuario))
         {
             Jugador.Turno.Casilla = PartidaEnJuego.Tablero.Casillas[jugadorMovimiento.Turno.Casilla.Numero + jugadorMovimiento.Turno.Casilla.Movimiento - 1];
             clientePartida.MovimientoEspecial(PartidaEnJuego.Nombre, Jugador.Turno.Casilla.Numero);
         }
         DispatcherTimer temporizadorMovimiento = new DispatcherTimer();
         temporizadorMovimiento.Interval = new TimeSpan(0, 0, 1);
         temporizadorMovimiento.Tick    += (a, b) => {
             temporizadorMovimiento.Stop();
             try {
                 PartidaEnJuego = clientePartida.ObtenerPartida(PartidaEnJuego.Nombre);
                 DeterminarMovimiento(jugadorMovimiento.NombreUsuario, "");
             } catch (CommunicationException) {
                 EnviarMensajeError();
             }
         };
         temporizadorMovimiento.Start();
     } catch (CommunicationException) {
         EnviarMensajeError();
     }
 }
Ejemplo n.º 26
0
 /// <summary>
 /// Constructor de la ventana CrearPartida.
 /// </summary>
 /// <param name="menuPrincipal">
 /// Ventana MenúPrincipal de la cual se mandó a llamar la ventana.
 /// </param>
 /// <param name="jugador">
 /// Objeto jugador que se mandó desde el menú.
 /// </param>
 public CrearPartida(MenuPrincipal menuPrincipal, ServiceSYE.Jugador jugador)
 {
     InitializeComponent();
     this.menuPrincipal = menuPrincipal;
     this.jugador       = jugador;
 }
Ejemplo n.º 27
0
 /// <summary>
 /// Constructor de la ventana TablaPosiciones.
 /// </summary>
 /// <param name="jugador">
 /// Objeto jugador que se mandó desde el menú.
 /// </param>
 public TablaPosiciones(ServiceSYE.Jugador jugador)
 {
     InitializeComponent();
     this.jugador = jugador;
     CargarJugadoresPuntos();
 }
Ejemplo n.º 28
0
 public Partidas(ServiceSYE.Jugador jugador)
 {
     this.jugador = jugador;
     InitializeComponent();
     cargarDatos();
 }