示例#1
0
    /*
     * //Update is called once per frame
     * void Update () {
     * }
     */


    void OnLoginFacebook(string _name)
    {
        Debug.Log(">>> PULSO EN LOGIN FACEBOOK");
        Interfaz.ClickFX();
    }
示例#2
0
 void OnLoginKicks(string _name)
 {
     Debug.Log(">>> PULSO EN LOGIN KICKS");
     Interfaz.ClickFX();
 }
 private void btnLimpiar_Click(object sender, EventArgs e)
 {
     Interfaz.limpiarInterfaz(this);
 }
        bool IdentificarDeclaracion(string Sentencia)
        {
            if (RgxSimples.IsMatch(Sentencia))
            {
                //variables simples
                var VariableAGuardar = new Variables();
                var arreglo          = Sentencia.Split();
                var tipo             = arreglo[0];

                if (arreglo[1] == "[]")
                {
                    VariableAGuardar.Nombre = arreglo[2];
                    VariableAGuardar.Array  = true;
                }
                else
                {
                    VariableAGuardar.Nombre = arreglo[1];
                    VariableAGuardar.Array  = false;
                }
                VariableAGuardar.tipo = tipo;

                //validar arreglo
                //agrega
                VariableAGuardar.Ambito   = PilaDeAmbitos.Peek();
                VariableAGuardar.val      = null;
                VariableAGuardar.Estatica = false;
                GuardarVariableEnAmbito(VariableAGuardar);
                return(true);
            }
            else if (RgxEstaticas.IsMatch(Sentencia))
            {
                //variable estatica
                var arreglo          = Sentencia.Split();
                var tipo             = arreglo[1];
                var nombre           = arreglo[2];
                var VariableAGuardar = new Variables();
                VariableAGuardar.tipo     = tipo;
                VariableAGuardar.Nombre   = nombre;
                VariableAGuardar.Ambito   = PilaDeAmbitos.Peek();
                VariableAGuardar.val      = null;
                VariableAGuardar.Estatica = true;
                GuardarVariableEnAmbito(VariableAGuardar);
                return(true);
            }
            else if (RgxClases.IsMatch(Sentencia))
            {            //CLASES
                var clases  = new Clase();
                var splited = Sentencia.Replace(" , ", " ").Split(' ');
                clases.Nombre = splited[1];
                clases.Ambito = PilaDeAmbitos.Peek();
                if (Sentencia.Contains("extends"))
                {
                    clases.HeredaDe = splited[3];
                }
                if (Sentencia.Contains("implements"))
                {
                    var inicio         = Sentencia.IndexOf("implements");
                    var parteAEliminar = "";
                    for (int i = 0; i < inicio; i++)
                    {
                        parteAEliminar += Sentencia[i];
                    }
                    var saux = Sentencia.Replace(parteAEliminar, "").Replace("implements ", "").Split(',');

                    for (int i = 0; i < saux.Length; i++)
                    {
                        clases.Interfaces.Add(saux[i].Trim());
                    }

                    var stop = 0;
                }
                //GuardarClase(clases);
                GuardarClaseEnAmbito(clases);
                AbrirUnAmbito(clases.Nombre);
                PilaDeTipoDeSentencia.Push("Clase");
                return(true);
            }
            else if (RgxMetodos.IsMatch(Sentencia))
            {            //METODOS
                var MetodoActual = new Metodo()
                {
                    Tipo   = Sentencia.Split(' ')[0],
                    Nombre = Sentencia.Split(' ')[1],
                    Ambito = PilaDeAmbitos.Peek()
                };
                MetodoActual.Ambito = PilaDeAmbitos.Peek();
                var ParametrosDeMetodo = Sentencia.Remove(0, Sentencia.IndexOf('(')).Trim().Replace("(", "").Replace(")", "").Replace(" , ", ",").Split(',');
                //diccionario clases[clase actual].metodos.add(nombre defuncion);
                //metodos generales.add[nombre, clase funcion]
                foreach (var item in ParametrosDeMetodo)
                {
                    var ParametroActual = new Variables()
                    {
                        tipo   = item.Trim().Split(' ')[0],
                        Ambito = MetodoActual.Nombre
                    };
                    if (item.Trim().Contains("[]"))
                    {                    //es un parametro tipo array
                        ParametroActual.Array  = true;
                        ParametroActual.Nombre = item.Trim().Split(' ')[2];
                    }
                    else
                    {                    //es un parametro normal
                        ParametroActual.Nombre = item.Trim().Split(' ')[1];
                    }

                    if (MetodoActual.Parametros.ContainsKey(ParametroActual.Nombre))
                    {                    //parametro de nombre repetido
                    }
                    else
                    {
                        MetodoActual.Parametros.Add(ParametroActual.Nombre, ParametroActual);
                    }
                }
                GuardarMetodo(MetodoActual);
                if (PilaDeTipoDeSentencia.Peek() == "Interfaz")
                {
                }
                else
                {
                    //AbrirUnAmbito(MetodoActual.Nombre);
                    //PilaDeTipoDeSentencia.Push("Metodo");
                }

                return(true);
            }
            else if (RgxInterfaz.IsMatch(Sentencia))
            {
                var InterfazActual = new Interfaz()
                {
                    Nombre = Sentencia.Trim().Split(' ')[1], Ambito = PilaDeAmbitos.Peek()
                };

                if (AbrirUnAmbito(InterfazActual.Nombre))
                {
                    GuardarInterfazEnAmbito(InterfazActual);
                    PilaDeTipoDeSentencia.Push("Interfaz");
                }
                else
                {                //Error en Apertura de Ambito por que ya existia en el actual
                }

                return(true);
            }
            else
            {
                if (Asignacion.IsMatch(Sentencia))
                {
                    var SimboloAAsignar    = Sentencia.Split('=')[0].Trim();
                    var VariableResultante = BuscarVariables(SimboloAAsignar);
                    if (VariableResultante == null)
                    {
                        Console.WriteLine($"La instruccion no se ejecuto por que la variable \"{SimboloAAsignar}\" no existe en ningun ambito.");
                        return(true);
                    }
                    else
                    {                    // ComprobarTipos
                        var Operacion = Sentencia.Split('=')[1].Trim();
                        var TipoGeneralDeLaOperacion = ComprobarTiposParaAsignacion(VariableResultante, Operacion);

                        if (VariableResultante.tipo == TipoGeneralDeLaOperacion.Key)
                        {
                            //operar
                            RegistroDeAmbitos[VariableResultante.Ambito].Variables[VariableResultante.Nombre].val = TipoGeneralDeLaOperacion.Value;
                        }
                        else
                        {
                            //tipos diferentes
                            Console.WriteLine($"La instruccion no se ejecuto por que la variable \"{VariableResultante.Nombre}\" es tipo {VariableResultante.tipo} y no hay convercion hacia tipo {TipoGeneralDeLaOperacion.Key} para {TipoGeneralDeLaOperacion.Value}.");
                        }
                    }
                }
                else if (RgxStmts.IsMatch(Sentencia))
                {
                    var StmtTipo   = Sentencia.Substring(0, Sentencia.IndexOf("(")).Trim();
                    var parametros = Sentencia.Remove(0, Sentencia.IndexOf("(")).Trim();

                    var resultado = VerificarParametrosDeSTMT(parametros);
                    if (resultado.Key != null)
                    {
                        Console.WriteLine($"El simbolo \"{resultado.Key}\" es tipo {resultado.Value} y no hay convercion hacia tipos diferentes dentro de las sentencias.");
                    }
                    else
                    {
                    }
                }
                else if (RgxClaseMetodoCall.IsMatch(Sentencia))
                {
                    var aux = Sentencia.Remove(0, Sentencia.IndexOf('.') + 1).Trim();
                    //obtencion de info de parametros
                    if (!RegistroDeAmbitos.ContainsKey(aux.Substring(0, aux.IndexOf("(")).Trim()))
                    {
                        Console.WriteLine($"El metodo no existe en ningun ambito{aux.Substring(0, aux.IndexOf("(")).Trim()}");
                        return(false);
                    }
                    else
                    {
                        var ParametrosDeInstancia = RegistroDeAmbitos[aux.Substring(0, aux.IndexOf("(")).Trim()].Metodos[aux.Substring(0, aux.IndexOf("(")).Trim()].Parametros;
                        var ParametrosEnviados    = aux.Remove(0, aux.IndexOf("(")).Trim().Replace("(", "").Replace(")", "").Replace(" , ", ",").Split(',');
                        var listaDeTipos          = new List <string>();
                        foreach (var item in ParametrosEnviados)
                        {
                            if (Number.IsMatch(item.Trim()))
                            {
                                listaDeTipos.Add("int");
                            }
                            else if (item.Contains("▄"))
                            {
                                listaDeTipos.Add("string");
                            }
                            else if (Boolean.IsMatch(item.Trim()))
                            {
                                listaDeTipos.Add("boolean");
                            }
                            else
                            {                            //es un tipo abstracto y tenemos que ir a traerlo
                                var encontrado = BuscarVariables(item.Trim());
                                if (encontrado == null)
                                {
                                    encontrado = BuscarEnParametros(item.Trim());
                                }
                            }
                        }
                        if (listaDeTipos.Count != ParametrosDeInstancia.Count)
                        {
                            Console.WriteLine($"No se enviaron los mismos parametros para la instancia {Sentencia}");
                        }
                        else
                        {
                            for (int i = 0; i < listaDeTipos.Count; i++)
                            {
                                if (listaDeTipos[i] != ParametrosDeInstancia.ElementAt(i).Value.tipo)
                                {
                                    Console.WriteLine($"Se envio como parametrop un {listaDeTipos[i]} y se esperaba un {ParametrosDeInstancia.ElementAt(i).Value.tipo}");
                                }
                            }
                        }
                        return(true);
                    }
                }
                else if (RgxMetodoCall.IsMatch(Sentencia))
                {
                    var aux = Sentencia;
                    //obtencion de info de parametros
                    if (!RegistroDeAmbitos.ContainsKey(aux.Substring(0, aux.IndexOf("(")).Trim()))
                    {
                        Console.WriteLine($"El metodo no existe en ningun ambito{aux.Substring(0, aux.IndexOf("(")).Trim()}");
                        return(false);
                    }
                    else
                    {
                        var ParametrosDeInstancia = RegistroDeAmbitos[aux.Substring(0, aux.IndexOf("(")).Trim()].Metodos[aux.Substring(0, aux.IndexOf("(")).Trim()].Parametros;
                        var ParametrosEnviados    = aux.Remove(0, aux.IndexOf("(")).Trim().Replace("(", "").Replace(")", "").Replace(" , ", ",").Split(',');
                        var listaDeTipos          = new List <string>();
                        foreach (var item in ParametrosEnviados)
                        {
                            if (Number.IsMatch(item.Trim()))
                            {
                                listaDeTipos.Add("int");
                            }
                            else if (item.Contains("▄"))
                            {
                                listaDeTipos.Add("string");
                            }
                            else if (Boolean.IsMatch(item.Trim()))
                            {
                                listaDeTipos.Add("boolean");
                            }
                            else
                            {                            //es un tipo abstracto y tenemos que ir a traerlo
                                var encontrado = BuscarVariables(item.Trim());
                                if (encontrado == null)
                                {
                                    encontrado = BuscarEnParametros(item.Trim());
                                }
                            }
                        }
                        if (listaDeTipos.Count != ParametrosDeInstancia.Count)
                        {
                            Console.WriteLine($"No se enviaron los mismos parametros para la instancia {Sentencia}");
                        }
                        else
                        {
                            for (int i = 0; i < listaDeTipos.Count; i++)
                            {
                                if (listaDeTipos[i] != ParametrosDeInstancia.ElementAt(i).Value.tipo)
                                {
                                    Console.WriteLine($"Se envio como parametrop un {listaDeTipos[i]} y se esperaba un {ParametrosDeInstancia.ElementAt(i).Value.tipo}");
                                }
                            }
                        }
                        return(true);
                    }
                }

                return(false);
            }
        }
示例#5
0
    /// <summary>
    /// Muestra el control con los valores de los parametros recibidos
    /// </summary>
    /// <param name="_usuario"></param>
    /// <param name="_habilitarRetar">Indica si pulsar al pulsar sobre este control se permite retar a este jugador o no</param>
    /// <param name="_ocultarBotonesFavorito">Fuerza que no se muestren los botones añadir / eliminar favorito</param>
    public void AsignarValores(Usuario _usuario, bool _habilitarRetar = true, bool _ocultarBotonesFavorito = false)
    {
        // guardar la informacion del usuario
        m_usuario = _usuario;

        // actualizar textos
        m_txtUsuario.text = _usuario.alias;

        // actualizar collider
        if (_habilitarRetar)
        {
            m_btnRetar.action = (_name) => {
                Interfaz.ClickFX();

#if !DEBUG_RETO
                /*
                 * // comprobar si el jugador tiene suficiente dinero para ofrecer un duelo
                 * //H4CK para evitar pagar duelos
                 * if (Interfaz.m_monedas< Stats.PRECIO_RETO) {
                 *  // informar al jugador de que no tiene suficiente dinero para retar al rival
                 *  ifcDialogBox.instance.Show(ifcDialogBox.TipoBotones.ACEPTAR_CANCELAR, "DINERO INSUFICIENTE", "Para retar a <color=#ffd200>" + _usuario.alias + "</color> a un duelo necesitas disponer al menos <color=#ffd200>" + Stats.PRECIO_RETO + "$</color>.");
                 *
                 * } else {
                 */
#endif
                // retar al rival
                ifcDuelo.m_rival = _usuario;

                ifcDialogBox.instance.ShowTwoButtonDialog(
                    ifcDialogBox.TwoButtonType.POSITIVE_NEGATIVE,
                    LocalizacionManager.instance.GetTexto(102).ToUpper(),
                    string.Format(LocalizacionManager.instance.GetTexto(103), "<color=#ddf108> " + _usuario.alias + "</color>", _usuario.getRatio() + "%"),
                    LocalizacionManager.instance.GetTexto(45).ToUpper(),
                    LocalizacionManager.instance.GetTexto(48).ToUpper(),
                    // accion al pulsar aceptar
                    (_name1) => {
                    // enviar el mensaje al server
                    MensajeBase msg = Shark.instance.mensaje <MsgRequestDuel>();
                    (msg as MsgRequestDuel).m_challenge = _usuario.alias;
                    (msg as MsgRequestDuel).m_uid       = _usuario.uid;
                    msg.send();

                    // indicar que este jugador paga por el duelo
                    // Interfaz.m_tegoQuePagarDuelo = true;

                    // mostrar un dialogo mientras se espera la respuesta
                    ifcDialogBox.instance.ShowZeroButtonDialog(LocalizacionManager.instance.GetTexto(104).ToUpper(), LocalizacionManager.instance.GetTexto(105));
                    ifcDialogBox.instance.WaitToCloseAutomatically(Stats.TIEMPO_ESPERA_CONFIRMACION_RETO_RIVAL);
                });

#if !DEBUG_RETO
                //}
#endif
            };

            m_btnRetar.gameObject.SetActive(true);
        }
        else
        {
            m_btnRetar.gameObject.SetActive(false);
        }

        // instanciar y mostrar el jugador en la escena
        if (m_jugadorEscena != null)
        {
            GameObject.Destroy(m_jugadorEscena);
        }
        Vector3 relPosition = new Vector3(transform.position.x, transform.position.y + 0.05f, transform.position.z);
        m_jugadorEscena = Interfaz.instance.InstantiatePlayerAtScreenRelative(relPosition, _usuario.initMode, _usuario.DefaultCharacter.idModelo, (_usuario.initMode) ? _usuario.equipacionGoalkeeper : _usuario.equipacionShooter);

        // actualizar control
        gameObject.SetActive(true);
    }
示例#6
0
        private void btnModificar_Click(object sender, EventArgs e)
        {
            string resumenModificaciones = "Se han modificado los campos:";
            string resumenErrores        = "No se han podido modificar los campos:";

            Boolean modificacion = false;
            Boolean error        = false;

            if (cambioString(this.Usuario, txtUsuario.Text))
            {
                if (usernameValido())
                {
                    cambiarStringUsuarios("NombreUsuario", txtUsuario.Text);
                    resumenModificaciones = resumenModificaciones + "\nNombre de usuario";
                    modificacion          = true;
                }
                else
                {
                    //MessageBox.Show("Nombre de usuario inválido.", "Error");
                    resumenErrores = resumenErrores + "\nNombre de usuario (no ingresado o ya existente)";
                    error          = true;
                }
            }

            if (cambioString(this.Passoword, txtPassword.Text))
            {
                UTF8Encoding  encoderHash   = new UTF8Encoding();
                SHA256Managed hasher        = new SHA256Managed();
                byte[]        bytesDeHasheo = hasher.ComputeHash(encoderHash.GetBytes(txtPassword.Text));
                string        password      = bytesDeHasheoToString(bytesDeHasheo);

                List <SqlParameter> listaParametros = new List <SqlParameter>();
                SqlConnector.agregarParametro(listaParametros, "@IdUsuario", this.IdUsuario);
                SqlConnector.agregarParametro(listaParametros, "@Password", password);
                SqlConnector.ejecutarQuery("UPDATE PalcoNet.Usuario SET Password = @Password, PrimeraVez = 0 WHERE IdUsuario = @IdUsuario", listaParametros, SqlConnector.iniciarConexion());
                SqlConnector.cerrarConexion();

                resumenModificaciones = resumenModificaciones + "\nContraseña";
                modificacion          = true;
            }

            if (cambioInt(this.Estado, cmbEstado.SelectedIndex))
            {
                cambiarIntUsuarios("Estado", cmbEstado.SelectedIndex);
                resumenModificaciones = resumenModificaciones + "\nEstado";
                modificacion          = true;
            }



            if (cambioInt(this.TipoDocumento, cmbTipoDocumento.SelectedIndex))
            {
                if (numeroDeDocumentoValido())
                {
                    if (!SqlConnector.existenSimultaneamente(cmbTipoDocumento.SelectedItem.ToString(), txtNumeroDocumento.Text, "PalcoNet.Cliente", "TipoDoc", "NumDoc"))
                    {
                        switch (cmbTipoDocumento.SelectedIndex)
                        {
                        case 0:
                            cambiarStringClientes("TipoDoc", "DU");
                            break;

                        case 1:
                            cambiarStringClientes("TipoDoc", "CI");
                            break;

                        case 2:
                            cambiarStringClientes("TipoDoc", "LC");
                            break;
                        }
                        resumenModificaciones = resumenModificaciones + "\nTipo de documento";
                        modificacion          = true;
                    }
                    else
                    {
                        resumenErrores = resumenErrores + "\nTipo de documento (ya existente)";
                        error          = true;
                    }
                }
                else
                {
                    //MessageBox.Show("Tipo y/o número de documento inválido/s.", "Error");
                    resumenErrores = resumenErrores + "\nTipo de documento (número de documento no ingresado o inválido)";
                    error          = true;
                }
            }

            if (cambioString(this.NumeroDocumento, txtNumeroDocumento.Text))
            {
                if (numeroDeDocumentoValido())
                {
                    if (!SqlConnector.existenSimultaneamente(cmbTipoDocumento.SelectedItem.ToString(), txtNumeroDocumento.Text, "PalcoNet.Cliente", "TipoDoc", "NumDoc"))
                    {
                        cambiarLongIntClientes("Num_Doc", Convert.ToInt64(txtNumeroDocumento.Text));
                        resumenModificaciones = resumenModificaciones + "\nNúmero de documento";
                        modificacion          = true;
                    }
                    else
                    {
                        resumenErrores = resumenErrores + "\nNúmero de documento (ya existente)";
                        error          = true;
                    }
                }
                else
                {
                    //MessageBox.Show("Número de documento inválido.", "Error");
                    resumenErrores = resumenErrores + "\nNúmero de documento (no ingresado o inválido)";
                    error          = true;
                }
            }

            if (cambioString(this.Nombre, txtNombre.Text))
            {
                if (!txtNombre.Text.Equals(""))
                {
                    cambiarStringClientes("Nombre", txtNombre.Text);
                    resumenModificaciones = resumenModificaciones + "\nNombre";
                    modificacion          = true;
                }
                else
                {
                    resumenErrores = resumenErrores + "\nNombre (no ingresado)";
                    error          = true;
                }
            }

            if (cambioString(this.Apellido, txtApellido.Text))
            {
                if (!txtApellido.Text.Equals(""))
                {
                    cambiarStringClientes("Apellido", txtApellido.Text);
                    resumenModificaciones = resumenModificaciones + "\nApellido";
                    modificacion          = true;
                }
                else
                {
                    resumenErrores = resumenErrores + "\nApellido (no ingresado)";
                    error          = true;
                }
            }

            if (cambioString(this.Email, txtEmail.Text))
            {
                if (!txtEmail.Text.Equals(""))
                {
                    cambiarStringClientes("Email", txtEmail.Text);
                    resumenModificaciones = resumenModificaciones + "\nE-mail";
                    modificacion          = true;
                }
                else
                {
                    resumenErrores = resumenErrores + "\nE-mail (no ingresado)";
                    error          = true;
                }
            }

            if (cambioString(this.Telefono, txtTelefono.Text))
            {
                if (txtTelefono.Text.Equals("") || ((Interfaz.esNumerico(txtTelefono.Text, System.Globalization.NumberStyles.Integer)) && (txtTelefono.Text.Length <= 18)))
                {
                    if (txtTelefono.Text.Equals(""))
                    {
                        cambiarNullClientes("Telefono");
                        resumenModificaciones = resumenModificaciones + "\nTeléfono";
                        modificacion          = true;
                    }
                    else
                    {
                        if (!SqlConnector.existeString(txtTelefono.Text, "PalcoNet.Clientes", "Telefono"))
                        {
                            cambiarLongIntClientes("Telefono", Convert.ToInt64(txtTelefono.Text));
                            resumenModificaciones = resumenModificaciones + "\nTeléfono";
                            modificacion          = true;
                        }
                        else
                        {
                            resumenErrores = resumenErrores + "\nTeléfono (ya existente)";
                            error          = true;
                        }
                    }
                }
                else
                {
                    resumenErrores = resumenErrores + "\nTeléfono (valor no numérico o muy grande)";
                    error          = true;
                }
            }

            if (cambioString(this.Direccion, txtDireccion.Text))
            {
                if (!txtDireccion.Text.Equals(""))
                {
                    cambiarStringClientes("Direccion", txtDireccion.Text);
                    resumenModificaciones = resumenModificaciones + "\nDirección";
                    modificacion          = true;
                }
                else
                {
                    resumenErrores = resumenErrores + "\nDirección (no ingresada)";
                    error          = true;
                }
            }

            if (cambioString(this.CodigoPostal, txtCodigoPostal.Text))
            {
                if (!txtCodigoPostal.Text.Equals(""))
                {
                    if (txtCodigoPostal.Text.Length <= 50)
                    {
                        cambiarStringClientes("CodigoPostal", txtCodigoPostal.Text);
                        resumenModificaciones = resumenModificaciones + "\nCódigo Postal";
                        modificacion          = true;
                    }
                    else
                    {
                        MessageBox.Show("Código postal inválido.", "Error");
                        resumenErrores = resumenErrores + "\nCódigo postal (valor muy grande)";
                        error          = true;
                    }
                }
                else
                {
                    resumenErrores = resumenErrores + "\nCódigo Postal (no ingresado)";
                    error          = true;
                }
            }

            if (cambioInt(Dia, cmbDia.SelectedIndex) || cambioInt(Mes, cmbMes.SelectedIndex) || cambioInt(Ano, cmbAno.SelectedIndex))
            {
                cambiarFecha("FechaNacimiento", fecha(cmbDia.SelectedItem.ToString(), cmbMes.SelectedItem.ToString(), cmbAno.SelectedItem.ToString()));
                resumenModificaciones = resumenModificaciones + "\nFecha de nacimiento";
                modificacion          = true;
            }

            if (modificacion)
            {
                MessageBox.Show(resumenModificaciones);
            }

            if (error)
            {
                MessageBox.Show(resumenErrores);
            }

            if (modificacion || error)
            {
                this.Close();
                frmBuscarCliente.Show();
            }
        }
示例#7
0
    /// <summary>
    /// Obtiene las referencias a los elementos de esta interfaz
    /// </summary>
    private void GetReferencias()
    {
        // boton back
        if (m_btnBack == null)
        {
            m_btnBack        = transform.FindChild("btnAtras").GetComponent <btnButton>();
            m_backMethod     = Back;
            m_btnBack.action = Back;
        }

        // tooltip para mostrar si un jugador o una equipacion esta disponible
        if (m_tooltipItemDisponible == null)
        {
            m_tooltipItemDisponible = transform.FindChild("tooltipItemDisponible").GetComponent <cntTooltipItemDisponible>();
        }

        // boton lanzador
        if (m_btnLanzador == null)
        {
            m_btnLanzador = transform.FindChild("botones/btnLanzador").GetComponent <btnButton>();
        }
        m_btnLanzador.Toggle = true;
        m_btnLanzador.action = (_name) => {
            Interfaz.ClickFX();

            EquipacionManager.instance.ResetEquipacion(true);
            Interfaz.instance.ResetJugador(true);

            m_tipoVestuario = TipoVestuario.LANZADOR;

            // mostrar el modelo que corresponda
            Interfaz.instance.RefrescarModelosJugadores(true, false);

            // actualizar los controles
            ShowAs(m_tipoVestuario);
        };

        // boton portero
        if (m_btnPortero == null)
        {
            m_btnPortero = transform.FindChild("botones/btnPortero").GetComponent <btnButton>();
        }
        m_btnPortero.Toggle = true;
        m_btnPortero.action = (_name) => {
            Interfaz.ClickFX();

            EquipacionManager.instance.ResetEquipacion(false);
            Interfaz.instance.ResetJugador(false);

            m_tipoVestuario = TipoVestuario.PORTERO;

            // mostrar el modelo que corresponda
            Interfaz.instance.RefrescarModelosJugadores(false, true);

            // actualizar los controles
            ShowAs(m_tipoVestuario);
        };

        // grupos de items a comprar
        if (m_cntCompraPowerUpsLanzador == null)
        {
            m_cntCompraPowerUpsLanzador = transform.FindChild("CompraPowerUpsLanzador").GetComponent <cntCompraItemsContainer>();
        }
        if (m_cntCompraPowerUpsPortero == null)
        {
            m_cntCompraPowerUpsPortero = transform.FindChild("CompraPowerUpsPortero").GetComponent <cntCompraItemsContainer>();
        }
        if (m_cntCompraEscudos == null)
        {
            m_cntCompraEscudos = transform.FindChild("CompraEscudos").GetComponent <cntCompraItemsContainer>();
        }

        // boton info lanzador
        if (m_btnInfo == null)
        {
            m_btnInfo        = transform.FindChild("btnInfo").GetComponent <btnButton>();
            m_btnInfo.action = (_name) => {
                Interfaz.ClickFX();
                GeneralSounds_menu.instance.playOneShot(GeneralSounds_menu.instance.popupOnClip);

                // desplegar la info
                if (m_tipoVestuario == TipoVestuario.LANZADOR)
                {
                    ifcDialogoInfoJugador.instance.Show(InfoJugadores.instance.GetTirador(Interfaz.instance.Thrower));
                }
                else
                {
                    ifcDialogoInfoJugador.instance.Show(InfoJugadores.instance.GetPortero(Interfaz.instance.Goalkeeper));
                }
                ifcDialogoInfoJugador.instance.Desplegar();

                // ocultar este boton
                m_btnInfo.gameObject.SetActive(false);
            };
        }


        // boton listo
        if (m_btnListo == null)
        {
            m_btnListo        = transform.FindChild("btnListo").GetComponent <btnButton>();
            m_btnListo.action = (_name) => {
                GeneralSounds_menu.instance.playOneShot(GeneralSounds_menu.instance.confirmClip);
                // si la pantalla anterior era el "MainMenu" (estoy en modo multiplayer)
                bool estoyJugandoDuelo = (m_pantallaAnterior == ifcMainMenu.instance);

                // comprobar la fase desbloqueada
                int faseMinima = 4;
                if (estoyJugandoDuelo && Interfaz.ultimaMisionDesbloqueada < faseMinima)
                {
                    ifcDialogBox.instance.ShowOneButtonDialog(
                        ifcDialogBox.OneButtonType.POSITIVE,
                        LocalizacionManager.instance.GetTexto(258).ToUpper(),
                        string.Format(LocalizacionManager.instance.GetTexto(259), "<color=#ddf108>" + LocalizacionManager.instance.GetTexto(11) + " " + ((int)(faseMinima / 10) + 1) + "-" + (faseMinima % 10) + "</color>"),
                        LocalizacionManager.instance.GetTexto(45).ToUpper());
                    return;
                }

                // si el usuario necesita al menos un lanzador para jugar => comprobar que lo tenga
                if ((estoyJugandoDuelo || (!estoyJugandoDuelo && GameplayService.initialGameMode == GameMode.Shooter)) &&
                    !InfoJugadores.instance.HayAlgunLanzadorAdquirido())
                {
                    ifcDialogBox.instance.ShowOneButtonDialog(
                        ifcDialogBox.OneButtonType.POSITIVE,
                        LocalizacionManager.instance.GetTexto(84).ToUpper(),
                        LocalizacionManager.instance.GetTexto(94),
                        LocalizacionManager.instance.GetTexto(45).ToUpper());

                    return;
                }

                // si el usuario necesita al menos un portero para jugar => comprobar que lo tenga
                if ((estoyJugandoDuelo || (!estoyJugandoDuelo && GameplayService.initialGameMode == GameMode.GoalKeeper)) &&
                    !InfoJugadores.instance.HayAlgunPorteroAdquirido())
                {
                    ifcDialogBox.instance.ShowOneButtonDialog(
                        ifcDialogBox.OneButtonType.POSITIVE,
                        LocalizacionManager.instance.GetTexto(84).ToUpper(),
                        LocalizacionManager.instance.GetTexto(95),
                        LocalizacionManager.instance.GetTexto(45).ToUpper());

                    return;
                }

                Interfaz.ClickFX();

                // pedir el alias al usuario
                if (estoyJugandoDuelo && Interfaz.m_uname == "")
                {
                    PedirAlias(Interfaz.m_uname);
                    return;
                }

                // al salir de esta pantalla verificar que los jugadores y las equipaciones seleccionadas estan adquiridas
                ComprobarJugadoresYEquipacionesAdquiridos();

                // comprobar si se esta jugando en modo "single" o "multi"
                if (m_pantallaAnterior == ifcMainMenu.instance)
                {
                    // estoy jugando Duelo => ir al "Lobby"

                    // ocultar la barra superior
                    //cntBarraSuperior.instance.SetVisible(false);
#if DEBUG_MULTI
                    GoDuelo();
#else
                    Interfaz.instance.getServerIP(Stats.tipo, Stats.zona);
#endif
                    ifcDialogBox.instance.ShowZeroButtonDialog(
                        LocalizacionManager.instance.GetTexto(96).ToUpper(),
                        LocalizacionManager.instance.GetTexto(97));
                    //ifcDialogBox.instance.Show(ifcDialogBox.TipoBotones.NONE, "Conectando...", "Por favor, espere.");
                }
                else if (m_pantallaAnterior == ifcCarrera.instance)
                {
                    // estoy jugando Single => jugar mision
                    Cortinilla.instance.Play();
                }
            };
        }

        // escudo multiplicador de puntuacion
        if (m_imgEscudo == null)
        {
            m_imgEscudo = transform.FindChild("escudo").GetComponent <GUITexture>();
        }
        if (m_txtMultiplicador == null)
        {
            m_txtMultiplicador = transform.FindChild("escudo/txtMultiplicador").GetComponent <GUIText>();
        }
    }
示例#8
0
 public Boolean campoNumerico(TextBox textbox)
 {
     return(Interfaz.esNumerico(textbox.Text, System.Globalization.NumberStyles.Integer));
 }
示例#9
0
        private void btnBuscar_Click(object sender, EventArgs e)
        {
            switch (cmbFiltro.SelectedIndex)
            {
            case -1:
                MessageBox.Show("Debe seleccionar un criterio de búsqueda.", "Error");
                break;

            case 0:     // Nombre
                if (!tBusqueda.Text.Equals(""))
                {
                    frmBuscarCliente frmBuscar = new frmBuscarCliente('N', tBusqueda.Text);
                    frmBuscar.Show();
                }
                else
                {
                    MessageBox.Show("Debe ingresar los campos solicitados", "Error");
                }
                break;

            case 1:     // Apellido
                if (!tBusqueda.Text.Equals(""))
                {
                    frmBuscarCliente frmBuscar = new frmBuscarCliente('A', tBusqueda.Text);
                    frmBuscar.Show();
                }
                else
                {
                    MessageBox.Show("Debe ingresar los campos solicitados", "Error");
                }
                break;

            case 2:     // Tipo de documento
                if (cmbFiltroTipoDocumento.SelectedIndex != -1)
                {
                    frmBuscarCliente frmBuscar = new frmBuscarCliente('T', cmbFiltroTipoDocumento.SelectedItem.ToString());
                    frmBuscar.Show();
                }
                else
                {
                    MessageBox.Show("Debe ingresar los campos solicitados", "Error");
                }
                break;

            case 3:     // Número de documento
                if (!tBusqueda.Text.Equals(""))
                {
                    if (Interfaz.esNumerico(tBusqueda.Text, System.Globalization.NumberStyles.Integer))
                    {
                        frmBuscarCliente frmBuscar = new frmBuscarCliente('D', tBusqueda.Text);
                        frmBuscar.Show();
                    }
                    else
                    {
                        MessageBox.Show("Número de documento inválido.", "Error");
                    }
                }
                else
                {
                    MessageBox.Show("Debe ingresar los campos solicitados", "Error");
                }
                break;

            case 4:     // Email
                if (!tBusqueda.Text.Equals(""))
                {
                    frmBuscarCliente frmBuscar = new frmBuscarCliente('E', tBusqueda.Text);
                    frmBuscar.Show();
                }
                else
                {
                    MessageBox.Show("Debe ingresar los campos solicitados", "Error");
                }
                break;
            }
        }
示例#10
0
    // Use this for initialization
    void Start()
    {
        m_backMethod = Back;

#if UNITY_IPHONE || UNITY_ANDROID
        transform.Find("btnAlta").gameObject.SetActive(false);
        transform.Find("btnMedia").gameObject.SetActive(false);
        transform.Find("btnBaja").gameObject.SetActive(false);
        transform.Find("SubtituloCalidad").gameObject.SetActive(false);
        Vector3 tempPos;
        tempPos    = transform.Find("SubtituloAudio").position;
        tempPos.y -= 0.2f;
        transform.Find("SubtituloAudio").position = tempPos;

        tempPos    = transform.Find("btnEfectos").position;
        tempPos.y -= 0.2f;
        transform.Find("btnEfectos").position = tempPos;

        tempPos    = transform.Find("btnMusica").position;
        tempPos.y -= 0.2f;
        transform.Find("btnMusica").position = tempPos;

        calidad = 2;
#else
        if (!PlayerPrefs.HasKey("calidad"))
        {
            calidad = 1;
            PlayerPrefs.SetInt("calidad", calidad);
        }
        else
        {
            calidad = PlayerPrefs.GetInt("calidad");
        }
#endif

        if (!PlayerPrefs.HasKey("fx"))
        {
            fx = true;
            PlayerPrefs.SetInt("fx", fx ? 1 : 0);
        }
        else
        {
            fx = PlayerPrefs.GetInt("fx") == 1;
        }
        if (!PlayerPrefs.HasKey("music"))
        {
            music = true;
            PlayerPrefs.SetInt("music", music ? 1 : 0);
        }
        else
        {
            music = PlayerPrefs.GetInt("music") == 1;
        }

        getComponentByName("btnEfectos").GetComponent <btnButton>().Toggle = true;
        getComponentByName("btnMusica").GetComponent <btnButton>().Toggle  = true;

        getComponentByName("btnEfectos").GetComponent <btnButton>().action = (_name) =>
        {
            fx = !fx;
            PlayerPrefs.SetInt("fx", fx ? 1 : 0);
            setFX();
            Interfaz.ClickFX();
        };
        getComponentByName("btnMusica").GetComponent <btnButton>().action = (_name) =>
        {
            Interfaz.ClickFX();
            music = !music;
            PlayerPrefs.SetInt("music", music ? 1 : 0);

            setMusic();
        };

        getComponentByName("btnAlta").GetComponent <btnButton>().action = (_name) =>
        {
            Interfaz.ClickFX();
            if (calidad != 2)
            {
                calidad = 2;
                PlayerPrefs.SetInt("calidad", calidad);
                setCalidad();
            }
        };
        getComponentByName("btnMedia").GetComponent <btnButton>().action = (_name) =>
        {
            Interfaz.ClickFX();
            if (calidad != 1)
            {
                calidad = 1;
                PlayerPrefs.SetInt("calidad", calidad);
                setCalidad();
            }
        };
        getComponentByName("btnBaja").GetComponent <btnButton>().action = (_name) =>
        {
            Interfaz.ClickFX();
            if (calidad != 0)
            {
                calidad = 0;
                PlayerPrefs.SetInt("calidad", calidad);
                setCalidad();
            }
        };

        getComponentByName("btnAtras").GetComponent <btnButton>().action = Back;

        setFX();
        setMusic();
        setCalidad();
    }
示例#11
0
        public Controlador(Interfaz interfaz)
        {
            inter = interfaz;



            inter.lbLadoDelCuadrado.Visible        = false;
            inter.txtLadoUsuario.Visible           = false;
            inter.btnCalcularAreaPerimetro.Visible = false;
            inter.pictureBox1.Visible = false;
            inter.panel1.Visible      = false;
            inter.panel2.Visible      = false;
            inter.btnRegresar.Visible = false;



            inter.panelRetangulo1.Visible  = false;
            inter.panelRectangulo2.Visible = false;
            inter.panelRectangulo3.Visible = false;
            inter.picRectangulo.Visible    = false;



            inter.panelTrapecio1.Visible = false;
            inter.pictureBox6.Visible    = false;
            inter.panelTrapecio3.Visible = false;
            inter.panelTrapecio2.Visible = false;

            inter.btnLimpiar.Visible = false;



            inter.btnCuadrado.Click += new System.EventHandler(this.Click);
            inter.btnCalcularAreaPerimetro.Click += new System.EventHandler(this.CalcularAreaYPerimetro);

            inter.btnRectangulo.Click         += new System.EventHandler(this.btnRecta);
            inter.btnCalcularRectángulo.Click += new System.EventHandler(this.btnCalcuarR);

            inter.btnTrapecio.Click         += new System.EventHandler(this.btnTrapecio);
            inter.btnCalcularTrapecio.Click += new System.EventHandler(this.btnCalcularTrapecio);

            inter.btnRegresar.Click += new System.EventHandler(this.btnRegresar);

            inter.txtAreaCuadrado.KeyPress       += new KeyPressEventHandler(numeros);
            inter.txtH.KeyPress                  += new KeyPressEventHandler(numeros);
            inter.txtLadoARectangulo.KeyPress    += new KeyPressEventHandler(numeros);
            inter.txtLadob.KeyPress              += new KeyPressEventHandler(numeros);
            inter.txtLadoB2.KeyPress             += new KeyPressEventHandler(numeros);
            inter.txtLadoBRectangulo.KeyPress    += new KeyPressEventHandler(numeros);
            inter.txtLadoD.KeyPress              += new KeyPressEventHandler(numeros);
            inter.txtLadoUsuario.KeyPress        += new KeyPressEventHandler(numeros);
            inter.txtResulAreaR.KeyPress         += new KeyPressEventHandler(numeros);
            inter.txtResulPerimetroR.KeyPress    += new KeyPressEventHandler(numeros);
            inter.txtResultadoPerimetro.KeyPress += new KeyPressEventHandler(numeros);
            inter.txtResultadoTrapecio.KeyPress  += new KeyPressEventHandler(numeros);
            inter.txtTrapecioResul2.KeyPress     += new KeyPressEventHandler(numeros);

            inter.txtLadoUsuario.KeyPress     += new KeyPressEventHandler(PasarCuadrado);
            inter.txtLadoARectangulo.KeyPress += new KeyPressEventHandler(PasarRectangulo);
            inter.txtLadoBRectangulo.KeyPress += new KeyPressEventHandler(PasarRectanguloDos);

            inter.txtLadob.KeyPress  += new KeyPressEventHandler(PasarTrapecioUno);
            inter.txtLadoB2.KeyPress += new KeyPressEventHandler(PasarTrapecioDos);
            inter.txtLadoD.KeyPress  += new KeyPressEventHandler(PasarTrapecioTres);
            inter.txtH.KeyPress      += new KeyPressEventHandler(PasarTrapecioCuatro);

            inter.btnLimpiar.Click += new System.EventHandler(limpiar);
        }