Esempio n. 1
0
 public void ChangeOption(int val)
 {
     if (barActive)
     {
         selectedOption = ContadorCiclico.Contar(val, selectedOption, options.Length);
         localTxt.text  = options[selectedOption];
     }
 }
Esempio n. 2
0
    void Update_b()
    {
        Material material = mesh.material;

        int change = 0;

        if (Input.GetKeyDown(KeyCode.RightArrow))
        {
            change = 1;
        }
        else if (Input.GetKeyDown(KeyCode.LeftArrow))
        {
            change = -1;
        }

        ConjuntoDasPartes cdp = partes[(int)cAtual];

        if (change != 0)
        {
            cdp.contador = ContadorCiclico.Contar(change, cdp.contador, cdp.possiveis.Length);
            MudarMesh(ref cdp.atual, cdp.possiveis, cdp.contador);
        }

        change = 0;

        if (Input.GetKeyDown(KeyCode.UpArrow))
        {
            change = 1;
        }
        else if (Input.GetKeyDown(KeyCode.DownArrow))
        {
            change = -1;
        }

        if (change != 0)
        {
            cAtual = (ContadorAtual)ContadorCiclico.Contar(change, (int)cAtual, partes.Count);
        }

        change = 0;

        if (Input.GetKeyDown(KeyCode.W))
        {
            change = 1;
        }
        else if (Input.GetKeyDown(KeyCode.S))
        {
            change = -1;
        }

        if (change != 0)
        {
            tamanho = ContadorCiclico.Contar(change, tamanho, 5);

            MudarMeshComTamanho();
        }
    }
    // Update is called once per frame
    void Update()
    {
        tempoDecorrido += Time.deltaTime;

        switch (estado)
        {
        case EstadoDaqui.movimentando:
            if (tempoDecorrido < loopTime)
            {
                float interpolation = //ZeroOneInterpolation.PolinomialInterpolation(tempoDecorrido / loopTime, 12);

                                      //ZeroOneInterpolation.RadicalOddInterpolation(tempoDecorrido / loopTime,3);

                                      ZeroOneInterpolation.LagrangeInterppolation(tempoDecorrido / loopTime,
                                                                                  new Vector2(0.75f, 1),
                                                                                  new Vector2(0.95f, 0.65f));

                if (tempoDecorrido > 0f && !somUm)
                {
                    doSomUm.Play();
                    somUm = true;
                }

                if (tempoDecorrido > 1.75f && !somDois)
                {
                    doSomDois.Play();
                    somDois = true;
                }

                //Debug.Log(interpolation + " : " + (tempoDecorrido / loopTime));

                transform.position = Vector3.Lerp(posAuxGuardada, pos[indiceDaPos].position,
                                                  interpolation
                                                  );
            }
            else
            {
                estado         = EstadoDaqui.esperando;
                tempoDecorrido = 0;
                somUm          = false;
                somDois        = false;
            }
            break;

        case EstadoDaqui.esperando:
            if (tempoDecorrido > standTime)
            {
                tempoDecorrido = 0;
                indiceDaPos    = ContadorCiclico.AlteraContador(1, indiceDaPos, pos.Length);
                posAuxGuardada = transform.position;
                estado         = EstadoDaqui.movimentando;
            }
            break;
        }
    }
Esempio n. 4
0
    void TrocaMesh(int change)
    {
        SectionDataBase meuDb = StringParaEnum.ObterEnum(cAtual.ToString(), SectionDataBase.cabelo);

        SimpleChangebleMesh[] m = S.GetDbMeshWithId(meuDb);

        int index = guardCont[cAtual];

        Color[] C = GuardColor(partes_b[index].atual, m[partes_b[index].contador].coresEditaveis);
        partes_b[index].contador = ContadorCiclico.Contar(change, partes_b[index].contador, m.Length);
        MudarMesh(ref partes_b[index].atual, m[partes_b[index].contador].mesh);
        SetRememberedColors(C, m[partes_b[index].contador].coresEditaveis, partes_b[index].atual);
    }
Esempio n. 5
0
    void GloboOcular(int change)
    {
        int cont = guardCont[ContadorAtual.globoOcular];

        MaskedTexture[] m = S.GetMaskedTexDbWithId(SectionDataBase.globoOcular);
        cont = ContadorCiclico.Contar(change, cont, m.Length);
        Material material = mesh.material;

        material.SetTexture(textureTarget, m[cont].baseTex);
        material.SetTexture(textureMaskTarget, m[cont].maskTex);

        guardCont[ContadorAtual.globoOcular] = cont;
    }
Esempio n. 6
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. 7
0
    void ChangeCombinedMesh(int change)
    {
        ConjuntoDasPartesComTamanhoCombinado_b c   = ConjuntoCombinadoPorID(cAtual);
        ConjuntoDasPartesComTamanhoCombinado_b c_2 = ConjuntoCombinadoPorID(c.combinadoCom);

        SectionDataBase meuDb = StringParaEnum.ObterEnum <SectionDataBase>(cAtual.ToString());

        CombinedChangebleMesh[] m = S.GetCombinedMeshDbWithID(meuDb);
        meuDb = StringParaEnum.ObterEnum <SectionDataBase>(c.combinadoCom.ToString());
        CombinedChangebleMesh[] m2 = S.GetCombinedMeshDbWithID(meuDb);

        c.contador = ContadorCiclico.Contar(change, c.contador, m.Length);
        Color[] guard_1 = GuardColor(c.atual, m[c.contador].coresEditaveis);
        Color[] guard_2 = GuardColor(c_2.atual, m2[c_2.contador].coresEditaveis);
        MudarMesh(ref c.atual, m[c.contador].mesh);
        MudarMesh(ref c_2.atual, GetMeshCombinedWithId(m2, m[c.contador].combinedWithId[0]));

        SetRememberedColors(guard_1, m[c.contador].coresEditaveis, c.atual);
        SetRememberedColors(guard_2, m2[c_2.contador].coresEditaveis, c_2.atual);
    }
Esempio n. 8
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);
            }
        }
    }
Esempio n. 9
0
    void VerifyChangePart()
    {
        int change = 0;

        if (Input.GetKeyDown(KeyCode.UpArrow))
        {
            change = 1;
        }
        else if (Input.GetKeyDown(KeyCode.DownArrow))
        {
            change = -1;
        }

        ContadorAtual ant = cAtual;

        cAtual = (ContadorAtual)ContadorCiclico.Contar(change, (int)cAtual, System.Enum.GetValues(typeof(ContadorAtual)).Length);

        if (cAtual != ant)
        {
            umLabel.text = cAtual.ToString();
        }
    }
Esempio n. 10
0
    // Update is called once per frame
    void Update()
    {
        if (estado != EstadoDaqui.emEspera)
        {
            tempoDecorrido += Time.deltaTime;
            BaseMoveRigidbody.PositionWithAndador(andador, transform);
        }

        switch (estado)
        {
        case EstadoDaqui.pulinhosPreparatorios:
            #region pulinhosPreparatorios
            if (VerifiqueContFurias())
            {
                _Animator.SetTrigger("queda");
                InstanciaLigando.Instantiate(particulaEnfaseDoBoss, transform.position, 5);
                EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, gritoDaFuria));
                EventAgregator.Publish(EventKey.abriuPainelSuspenso, null);
                estado = EstadoDaqui.prepararGiroDeFuria;
            }
            else
            if (tempoDecorrido > TEMPO_ENTRE_PULINHO && contDePulinhos < PULINHOS_ATE_ATAQUE)
            {
                int qual = Random.Range(0, uhuhah.Length);

                EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, uhuhah[qual]));
                _Animator.SetTrigger("preparaPulo");
                estado         = EstadoDaqui.preparaPulinho;
                tempoDecorrido = 0;
            }
            else if (tempoDecorrido > TEMPO_ENTRE_PULINHO && contDePulinhos >= PULINHOS_ATE_ATAQUE)
            {
                int qual = Random.Range(0, 2);

                if (qual == 0)
                {
                    InstanciaLigando.Instantiate(
                        particulaDoAtaqueAlto,
                        particulaDoAtaqueAlto.transform.position, 5,
                        Quaternion.identity);

                    estado = EstadoDaqui.giroAlto;
                    PreparaParabolaLocal();
                }
                else if (qual == 1)
                {
                    EscolheDestino();
                    InstanciaLigando.Instantiate(particulaDoAtaqueReto, particulaDoAtaqueReto.transform.position, 5);
                    estado = EstadoDaqui.giroReto;
                }
                else
                {
                    Debug.Log("numero não esperado: " + qual);
                }

                EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, urroDeAtaque));
                tempoDecorrido = 0;
            }
            #endregion
            break;

        case EstadoDaqui.prepararGiroDeFuria:
            #region preparandoGiroFuria
            if (tempoDecorrido > TEMPO_PREPARANDO_FURIA)
            {
                _Animator.SetTrigger("tocouChao");
                EventAgregator.Publish(EventKey.fechouPainelSuspenso);
                EscolheMelhorCantoAlto();
                estado         = EstadoDaqui.giroDeFuria;
                tempoDecorrido = 0;
                contDePulinhos = 0;
                indice         = 0;
                mov.ChangeGravityScale(0);
            }
            #endregion
            break;

        case EstadoDaqui.giroDeFuria:
            #region giroFuria
            andador.position = Vector3.Lerp(posInicial, targets[indice], velocidadeGiroFuria * tempoDecorrido / distancia);
            transform.Rotate(new Vector3(0, 0, 20));

            if (tempoDecorrido * velocidadeGiroFuria > distancia)
            {
                EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, SoundEffectID.pedrasQuebrando));
                EventAgregator.Publish(new StandardSendGameEvent(EventKey.requestShakeCam, ShakeAxis.z, 5, 2f));
                tempoDecorrido = 0;
                posInicial     = targets[indice];
                indice         = ContadorCiclico.AlteraContador(1, indice, 4);
                contDePulinhos++;
            }

            if (contDePulinhos >= 19)
            {
                _Animator.SetTrigger("retornaAoPadrao");
                FinalizaGiro();
            }
            #endregion
            break;

        case EstadoDaqui.giroReto:
            #region giroReto
            if (tempoDecorrido > TEMPO_TELEGRAFANDO_GIRO + TEMPO_GIRO_ALTO)
            {
                FinalizaGiro();
                //mov.AplicadorDeMovimentos(Vector3.zero);
            }
            else if (tempoDecorrido > TEMPO_TELEGRAFANDO_GIRO)
            {
                float time = (tempoDecorrido - TEMPO_TELEGRAFANDO_GIRO) / TEMPO_GIRO_ALTO;

                transform.Rotate(new Vector3(0, 0, 20));

                andador.position = Vector3.Lerp(posInicial, target, ZeroOneInterpolation.PolinomialInterpolation(time, 2));
            }
            #endregion
            break;

        case EstadoDaqui.giroAlto:
            #region giroAlto
            if (tempoDecorrido > TEMPO_TELEGRAFANDO_GIRO + TEMPO_GIRO_ALTO)
            {
                FinalizaGiro();
                //mov.AplicadorDeMovimentos(Vector3.zero);
            }
            else if (tempoDecorrido > TEMPO_TELEGRAFANDO_GIRO)
            {
                float time = (tempoDecorrido - TEMPO_TELEGRAFANDO_GIRO) / TEMPO_GIRO_ALTO;

                transform.Rotate(new Vector3(0, 0, 20));
                andador.position = ZeroOneInterpolation.ParabolaDeDeslocamento(
                    new Vector2(posInicial.x, posInicial.y),
                    new Vector2(target.x, target.y),
                    new Vector2(vertice.position.x, vertice.position.y),
                    ZeroOneInterpolation.OddPolynomialInterpolation(time, 3));

                //Debug.Log(target.x+" : "+posInicial.x);
            }
            #endregion
            break;

        case EstadoDaqui.preparaPulinho:
            #region preparaPulinhos
            if (tempoDecorrido > TEMPO_PREPARANDO_PULINHO)
            {
                mov.JumpForce();
                _Animator.SetTrigger("disparaPulo");
                tempoDecorrido = 0;
                contDePulinhos++;
                estado = EstadoDaqui.atualizaPulinho;
            }
            #endregion
            break;

        case EstadoDaqui.atualizaPulinho:
            #region atualizaPulinhos
            if (tempoDecorrido > TEMPO_NO_PULINHO)
            {
                if (requisicaoDeEspinhos)
                {
                    lancados = new EspinhosDoCirculoImperfeito[conjuntoDeEspinhos.childCount];

                    for (int i = 0; i < conjuntoDeEspinhos.childCount; i++)
                    {
                        GameObject G = InstanciaLigando.Instantiate(conjuntoDeEspinhos.GetChild(i).gameObject,
                                                                    conjuntoDeEspinhos.GetChild(i).position, 10);

                        lancados[i] = G.GetComponent <EspinhosDoCirculoImperfeito>();
                    }

                    _Animator.SetTrigger("retornaAoPadrao");
                    _Animator.SetTrigger("queda");

                    EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, preparaEspinhos));
                    estado = EstadoDaqui.preparaEspinhos;
                    requisicaoDeEspinhos = false;
                }
                else
                {
                    _Animator.SetTrigger("retornaAoPadrao");
                    estado = EstadoDaqui.pulinhosPreparatorios;
                }

                tempoDecorrido = 0;
            }
            #endregion
            break;

        case EstadoDaqui.preparaEspinhos:
            #region preparaEspinhos
            if (tempoDecorrido > TEMPO_PREPARANDO_ESPINHOS)
            {
                EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, lancaEspinhos));
                _Animator.SetTrigger("tocouChao");
                mov.JumpForce();
                tempoDecorrido = 0;
                estado         = EstadoDaqui.lancaEspinhos;
            }
            #endregion
            break;

        case EstadoDaqui.lancaEspinhos:
            #region lancaEspinhos
            if (tempoDecorrido > TEMPO_PARA_LANCAR_ESPINHOS)
            {
                _Animator.SetTrigger("retornaAoPadrao");

                for (int i = 0; i < lancados.Length; i++)
                {
                    lancados[i].circulo.SetActive(false);
                    lancados[i].espinhos.SetActive(true);
                    lancados[i].particulaDosEspinhos.SetActive(true);
                }

                estado         = EstadoDaqui.pulinhosPreparatorios;
                tempoDecorrido = 0;
            }
            #endregion
            break;
        }
    }