Esempio n. 1
0
    // Update is called once per frame
    void Update()
    {
        if (podeMudar)
        {
            float quanto = CommandReader.GetAxis("horizontal", GlobalController.g.Control)
                           + CommandReader.GetAxis("HDpad", GlobalController.g.Control);

            if (quanto > 0)
            {
                VerificaModificacao(true);
            }
            else if (quanto < 0)
            {
                VerificaModificacao(false);
            }
            else
            {
                quanto = UiDeOpcoes.VerificaMudarOpcao(true);

                if (quanto > 0)
                {
                    opcaoSelecionada = ContadorCiclico.AlteraContador(1, opcaoSelecionada, destaques.Length);
                }
                else if (quanto < 0)
                {
                    opcaoSelecionada = ContadorCiclico.AlteraContador(-1, opcaoSelecionada, destaques.Length);
                }

                if (quanto != 0)
                {
                    ColocarDestaqueSelecionado();
                }
            }

            bool foi = ActionManager.ButtonUp(0, GlobalController.g.Control);

            if (CommandReader.ButtonDown(2, GlobalController.g.Control)
                ||
                (foi && opcaoSelecionada == destaques.Length - 1))
            {
                BotaoVoltar();
            }
            else

            if (foi && opcaoSelecionada == 2)
            {
                BotaoTodasHabilidades();
            }
        }
    }
Esempio n. 2
0
    // Update is called once per frame
    void Update()
    {
        float quanto = CommandReader.GetAxis("vertical", GlobalController.g.Control);

        if (quanto > 0)
        {
            sb.value += velDoScroll * Time.deltaTime;
        }
        else if (quanto < 0)
        {
            sb.value -= velDoScroll * Time.deltaTime;
        }

        if (CommandReader.ButtonDown(2, GlobalController.g.Control))
        {
            SairDosCreditos();
        }
    }
Esempio n. 3
0
    void VerificaMudarAba()
    {
        Controlador Control = GlobalController.g.Control;

        if (estado != EstadoDaqui.menuDeOpcoesAberto && estado != EstadoDaqui.menuSuspensoAberto)
        {
            int qualSelecionado = qualMenu;
            if (CommandReader.ButtonDown(4, Control))
            {
                qualSelecionado = ContadorCiclico.AlteraContador(-1, qualSelecionado, 6);
            }
            else if (CommandReader.ButtonDown(5, Control))
            {
                qualSelecionado = ContadorCiclico.AlteraContador(1, qualSelecionado, 6);
            }

            if (qualSelecionado != qualMenu)
            {
                BtnTrocarAba(qualSelecionado);
            }
        }
    }
    // Update is called once per frame
    void Update()
    {
        piscaI.Update();
        atk.AttackIntervalUpdate();

        if (Control != Controlador.nulo)
        {
            switch (estado)
            {
            case EstadoDePersonagem.aPasseio:
                #region aPasseio

                bool    noChao = mov.NoChao;
                Vector3 V      = CommandReader.VetorDirecao(Control);
                mov.AplicadorDeMovimentos(V, CommandReader.ButtonDown(1, Control), dados.TemDoubleJump);

                if (V.z <= 0.75f)
                {
                    animador.EfetuarAnimacao(Mathf.Abs(mov.Velocity.x), !noChao);
                }

                atk.UpdateAttack();

                if (CommandReader.ButtonDown(0, Control))
                {
                    BotaoAtacar();
                }

                magic.Update(Control, Dados.PontosDeMana, noChao, dados);

                if (magic.EmTempoDeRecarga && magic.CustoParaRecarga <= Dados.PontosDeMana)
                {
                    estado = EstadoDePersonagem.emCura;
                    mov.AplicadorDeMovimentos(Vector3.zero, false, false);
                }

                if (dados.TemDash && dash.PodeDarDash(noChao) && CommandReader.ButtonDown(3, Control))
                {
                    dash.Start(Mathf.Sign(transform.localScale.x), noChao);
                    estado = EstadoDePersonagem.inDash;
                }

                if (CommandReader.ButtonDown(4, Control))
                {
                    atk.ModificouCorDaEspada(-1, dados);
                }
                else if (CommandReader.ButtonDown(5, Control))
                {
                    atk.ModificouCorDaEspada(1, dados);
                }

                if (V.z > 0.75f && noChao)
                {
                    mov.AplicadorDeMovimentos(Vector3.zero, false, false);
                    animador.EfetuarAnimacao(0, !noChao);
                    ActionManager.VerificaAcao();
                }
                #endregion
                break;

            case EstadoDePersonagem.emCura:
                magic.Update(Control, Dados.PontosDeMana, mov.NoChao, dados);
                break;

            case EstadoDePersonagem.emAtk:
                #region emAtk
                if (!mov.NoChao)
                {
                    mov.AplicadorDeMovimentos(CommandReader.VetorDirecao(Control), CommandReader.ButtonDown(1, Control), dados.TemDoubleJump);
                }
                else
                {
                    mov.AplicadorDeMovimentos(Vector3.Lerp(mov.Velocity.normalized, Vector3.zero, 30 * Time.deltaTime));
                }

                if (atk.UpdateAttack())
                {
                    estado = EstadoDePersonagem.aPasseio;
                }
                #endregion
                break;

            case EstadoDePersonagem.emDano:
                #region emDano
                if (emDano.Update(mov, CommandReader.VetorDirecao(Control)))
                {
                    if (tDamage.agendado)
                    {
                        mov.AplicadorDeMovimentos(Vector3.zero);
                        estado = EstadoDePersonagem.parado;
                        tDamage.Iniciar();
                    }
                    else
                    {
                        estado = EstadoDePersonagem.aPasseio;
                    }
                }
                #endregion
                break;

            case EstadoDePersonagem.downArrowActive:
                #region downArrowActive
                if (!mov.NoChao)
                {
                    piscaI.Start(0.5f, 4);
                    mov.GravityScaled(250);
                }
                else
                {
                    mov.AplicadorDeMovimentos(Vector3.zero, false, false);
                    if (magic.FinalizaDownArrow(mov.NoChao))
                    {
                        estado = EstadoDePersonagem.aPasseio;
                    }
                }
                #endregion
                break;

            case EstadoDePersonagem.inDash:
                #region inDash
                if (dash.Update(Mathf.Sign(transform.localScale.x), Mathf.Sign(CommandReader.VetorDirecao(Control).x)))
                {
                    estado = EstadoDePersonagem.aPasseio;
                }

                if (CommandReader.ButtonDown(0, Control))
                {
                    dash.RetornarAoEstadoDeEspera();
                    estado = EstadoDePersonagem.aPasseio;
                    BotaoAtacar();
                }
                #endregion
                break;

            case EstadoDePersonagem.inCheckPoint:
                #region inCheckPoint

                if (Mathf.Abs(CommandReader.VetorDirecao(GlobalController.g.Control).x) > 0.5f)
                {
                    particulaSaiuDoDescanso.gameObject.SetActive(true);
                    particulaSaiuDoDescanso.Play();
                    particulaDoDescanso.SetActive(false);
                    estado = EstadoDePersonagem.aPasseio;
                    EventAgregator.Publish(EventKey.checkPointExit, null);
                }
                #endregion
                break;

            case EstadoDePersonagem.derrotado:
                #region derrotado
                if (emDano.Update(mov, CommandReader.VetorDirecao(Control)))
                {
                    mov.AplicadorDeMovimentos(Vector3.zero, false, false);
                    particulaDoMorrendo.SetActive(true);
                    if (derrota.Update())
                    {
                        transform.position = dados.ultimoCheckPoint.Pos;
                        dados.SetarVidaMax();
                        //dados.SetarManaMax();

                        GameController.g.MyKeys.ReviverInimigos();

                        SaveDatesManager.SalvarAtualizandoDados(dados.ultimoCheckPoint.nomesDasCenas);
                        SceneLoader.IniciarCarregamento(SaveDatesManager.s.IndiceDoJogoAtualSelecionado,
                                                        () => {
                            estado = EstadoDePersonagem.aPasseio;
                            EventAgregator.Publish(EventKey.requestShowControllers, null);
                            derrota.DesligarLosangulo();
                        });
                        estado = EstadoDePersonagem.naoIniciado;
                    }
                }
                #endregion
                break;

            case EstadoDePersonagem.movimentoRequerido:
                if (positionRequest.UpdateMove())
                {
                    mov.AplicadorDeMovimentos(Vector3.zero);
                    estado = EstadoDePersonagem.parado;
                    EventAgregator.Publish(new StandardGameEvent(positionRequest.Requisitor, EventKey.positionRequeredOk));
                }
                break;
            }
        }
    }