Пример #1
0
    protected void alternanciaParaCriature()
    {
        alternancia a = X.GetComponent <alternancia> ();

        a.aoCriature();
    }
Пример #2
0
    void andaCorean()
    {
        if (Input.GetButtonDown("paraCriature") && heroi.emLuta == false && !variaveisChave.shift["alternaParaCriature"])
        {
            alternancia a = GameObject.Find("CriatureAtivo").GetComponent <alternancia>();
            a.aoCriature();
        }


        //criatureVerificaTrocaGolpe(criature.X);

        criatureScroll();


        //bool grounded = noChao(.distanciaFundamentadora );

        // Forward vector relative to the camera along the x-z plane

        float h = Input.GetAxis("Horizontal");
        float v = Input.GetAxis("Vertical");


        Vector3 forward = direcaoInduzida(h, v);

        forward.y = 0;
        forward   = forward.normalized;

        // Right vector relative to the camera
        // Always orthogonal to the forward vector
        Vector3 right = new Vector3(forward.z, 0, -forward.x);


        Vector3 direcaoAlvo = (h * right + v * forward);

//		float targetSpeed= Mathf.Min(direcaoAlvo.magnitude, 1.0f);
        //targetSpeed *= criature.X.velocidadeAndando;
        if (Input.GetButtonDown("Jump") && noChao(Y.distanciaFundamentadora))
        {
            ultimoYFundamentado = transform.position.y;
            pulo = true;
            controle.Move(Vector3.up * (Y.distanciaFundamentadora + 0.05f));
        }

        if (noChao(Y.distanciaFundamentadora))
        {
            pulo = false;


            maisUmAtualizaSuavemente(v, h, Y, direcaoAlvo);

            direcaoMovimento = direcaoMovimento                                      // * targetSpeed
                               + Y.apliqueGravidade(Vector3.zero, direcaoMovimento); //+ Vector3.down * criature.X.gravidade;
            //controle.Move ((direcaoMovimento) * Time.deltaTime);
        }
        else
        {
            verificaPulo(direcaoAlvo, Y);
        }
        if (noChao(Y.distanciaFundamentadora))
        {
            if (Mathf.Abs(v) > 0.3f || Mathf.Abs(h) > 0.3f)
            {
                transform.rotation = Quaternion.LookRotation(new Vector3(direcaoMovimento.x, 0, direcaoMovimento.z));
            }
        }
        else
        {
            Vector3 xzMove = direcaoMovimento * Time.deltaTime;
            xzMove.y = 0;
            if (xzMove.sqrMagnitude > 0.001f)
            {
                transform.rotation = Quaternion.LookRotation(xzMove);
            }
        }

        float vel = Mathf.Min(Mathf.Abs(v) + Mathf.Abs(h), 1);

        if (vel < 0.1f)
        {
            vel = 0;
        }

        if (Input.GetButton("Correr"))
        {
            vel *= 3;
        }

        animator.SetBool("noChao", noChao(Y.distanciaFundamentadora));
        animator.SetBool("pulo", pulo);
        animator.SetFloat("velocidade", vel);
    }
Пример #3
0
    void Update()
    {
        Vector3 posAlvo = Vector3.zero;

        switch (fase)
        {
        case faseDaEntrada.jogoDeCameraInicial:
            posAlvo            = CaesarTransform.position + 2.5f * Vector3.up - 2 * transform.right - 6 * transform.forward;
            transform.position = Vector3.Lerp(transform.position, posAlvo, Time.deltaTime);
            if (Vector3.Distance(posAlvo, transform.position) < 0.5f)
            {
                fase          = faseDaEntrada.focoNoCaesar;
                mens.entrando = true;
            }
            break;

        case faseDaEntrada.focoNoCaesar:
            transform.rotation = Quaternion.Lerp(
                transform.rotation,
                Quaternion.LookRotation(CaesarTransform.position - transform.position + Vector3.up),
                Time.deltaTime);

            olhaPraMimPo(CaesarTransform, animatorDoCaesar);
            olhaPraMimPo(LutzTransform, animatorDoLutz);
            trocaMensagem();

            if (mensagemAtual == 2)
            {
                fase          = faseDaEntrada.focoNoCorean;
                mens.entrando = false;
                animatorDoCorean.SetFloat("velocidade", 0.5f);
                animatorDoCorean.speed   = 0.5f;
                CoreanTransform.position = posicoesDeCamera[2].position;                /*new melhoraPos().novaPos(
                                                                                         * transform.position+Vector3.forward*9,1);*/
                posAlvo = new Vector3(transform.position.x - CoreanTransform.position.x, 0, transform.position.z - CoreanTransform.position.z);
                CoreanTransform.rotation = Quaternion.LookRotation(posAlvo);
                transform.position      -= 1.5f * Vector3.up;
                animatorDoLutz.SetBool("girando", false);
                posAlvo = new Vector3(
                    CoreanTransform.position.x - LutzTransform.position.x,
                    0,
                    CoreanTransform.position.z - LutzTransform.position.z);
                LutzTransform.rotation = Quaternion.LookRotation(posAlvo);
                animatorDoCaesar.SetBool("girando", false);
                posAlvo = new Vector3(
                    CoreanTransform.position.x - CaesarTransform.position.x,
                    0,
                    CoreanTransform.position.z - CaesarTransform.position.z);
                CaesarTransform.rotation = Quaternion.LookRotation(posAlvo);
            }
            break;

        case faseDaEntrada.focoNoCorean:
            transform.LookAt(CoreanTransform);
            if (Vector3.Distance(transform.position, CoreanTransform.position) < 5f)
            {
                animatorDoCorean.SetFloat("velocidade", 0);
                mens.entrando = true;
                fase          = faseDaEntrada.fala1Corean;
            }
            break;

        case faseDaEntrada.fala1Corean:
            trocaMensagem();
            if (mensagemAtual == 4)
            {
                fase = faseDaEntrada.fala2Caesar;
                //mens.entrando = false;
                transform.position = CaesarTransform.position + CaesarTransform.forward * 2 + 2f * Vector3.up;
                transform.LookAt(CaesarTransform.position + 2 * Vector3.up);
            }
            break;

        case faseDaEntrada.fala2Caesar:
            trocaMensagem();
            switch (mensagemAtual)
            {
            case 6:
            case 7:
                posAlvo            = LutzTransform.position + LutzTransform.forward * 2 + 1.5f * Vector3.up;
                transform.position = Vector3.Lerp(transform.position, posAlvo, Time.deltaTime);
                break;

            case 8:
                posAlvo = HooliganTransform.position
                          + HooliganTransform.forward * 2
                          + 1.2f * Vector3.up
                          - HooliganTransform.right * 2;
                transform.position = Vector3.Lerp(transform.position, posAlvo, Time.deltaTime);
                transform.LookAt(HooliganTransform.position + 1.2f * Vector3.up);
                break;

            case 9:
            case 10:
            case 11:
            case 12:
            case 13:
            case 14:
                CoreanTransform.position = posicoesDeCamera[3].position;
                posAlvo            = posicoesDeCamera[1].position;
                transform.position = Vector3.Lerp(transform.position, posAlvo, 2 * Time.deltaTime);
                transform.rotation = Quaternion.Lerp(transform.rotation, posicoesDeCamera[1].rotation, Time.deltaTime);

                break;
            }
            break;

        case faseDaEntrada.assumindoOControle:
            andeAteOsPontos();
            break;

        case faseDaEntrada.iniciaConversa2:
            andeAteOsPontos();

            if (Vector3.Distance(CaesarTransform.position, posicoesNavMesh[2].position) < 3
                &&
                Vector3.Distance(LutzTransform.position, posicoesNavMesh[2].position) < 3
                &&
                Vector3.Distance(HooliganTransform.position, posicoesNavMesh[2].position) < 3)
            {
                CaesarNavMesh.Stop();
                HooliganNavMesh.Stop();
                LutzNavMesh.Stop();

                Vector3 olharSegundo = new Vector3(CaesarTransform.position.x - CoreanTransform.position.x,
                                                   0,
                                                   CaesarTransform.position.z - CoreanTransform.position.z);
                CoreanTransform.rotation = Quaternion.LookRotation(olharSegundo);
                CaesarTransform.rotation = Quaternion.LookRotation(-olharSegundo);
                mensagemAtual            = 16;
                mens.mensagem            = essaConversa[mensagemAtual];
                fase = faseDaEntrada.conversa2;
            }
            break;

        case faseDaEntrada.conversa2:
            animatorDoCaesar.SetFloat("velocidade", 0);
            animatorDoHooligan.SetFloat("velocidade", 0);
            animatorDoLutz.SetFloat("velocidade", 0);

            mens.entrando = true;
            trocaMensagem();
            if (mensagemAtual == 18)
            {
                fase = faseDaEntrada.vaoEmboraExcedentes;
                LutzNavMesh.destination     = posicoesNavMesh[3].position;
                HooliganNavMesh.destination = posicoesNavMesh[3].position;
                mudaParent(posicoesDeCamera[6]);
                HooliganTransform.gameObject.AddComponent <destruaQUandoProximo>().local = posicoesNavMesh[3].position;
                LutzTransform.gameObject.AddComponent <destruaQUandoProximo>().local     = posicoesNavMesh[3].position;
            }
            break;

        case faseDaEntrada.vaoEmboraExcedentes:
            if (HooliganTransform)
            {
                animatorDoHooligan.SetFloat("velocidade", HooliganNavMesh.velocity.magnitude);
            }
            if (LutzTransform)
            {
                animatorDoLutz.SetFloat("velocidade", LutzNavMesh.velocity.magnitude);
            }

            if (mensagemAtual + 1 == 21)
            {
                mudaParent(posicoesDeCamera[5]);
            }
            trocaMensagem();
            break;

        case faseDaEntrada.enviaCriature:
            if (!aE)
            {
                animatorDoCorean.SetBool("chama", false);
                //mB.enabled = true;
                transform.parent = null;
                //cam.enabled = true;
                if (!tuto)
                {
                    tuto = GetComponent <Tutorial>();
                }
                tuto.ensinaUsarCriature();
                tuto.ePlus = this;
                fase       = faseDaEntrada.esperaAlternar;
            }
            break;

        case faseDaEntrada.esperaAlternar:
            if (Input.GetButtonDown("paraCriature"))
            {
                fase = faseDaEntrada.comOCriature;
                alternancia a = GameObject.Find("CriatureAtivo").GetComponent <alternancia>();
                a.aoCriature();
                if (LutzTransform)
                {
                    Destroy(LutzTransform.gameObject);
                }

                if (HooliganTransform)
                {
                    Destroy(HooliganTransform.gameObject);
                }
            }
            break;

        case faseDaEntrada.comOCriature:
            if (Input.GetButtonDown("paraCriature"))
            {
                faseAteOEncontro();
            }

            break;

        case faseDaEntrada.ateOEncontro:
            if (mensagemAtual == 21)
            {
                //mens.entrando = true;
                trocaMensagem();
            }
            else
            {
                mens.entrando = false;
            }

            animatorDoCaesar.SetFloat("velocidade", CaesarNavMesh.velocity.magnitude);
            break;

        case faseDaEntrada.habilitaAlternador:

            if (!Input.GetButtonDown("gatilho"))
            {
                mB.criatureScroll();
            }
            else if (H.itemAoUso == 3 && !Input.GetButton("Correr"))
            {
                GameObject.Find("CriatureAtivo").GetComponent <movimentoBasico>().criatureScroll();
                vidaEmLuta[] vS = GameObject.Find("encontreEle").GetComponents <vidaEmLuta>();
                foreach (vidaEmLuta v in vS)
                {
                    v.entrando = true;
                }
                tuto.removeEsbranquicado();
                tuto.UsarGatilhoDoItem();
                fase = faseDaEntrada.useiMaca;
                heroi.contraTreinador = true;
            }
            else if (!Input.GetButton("Correr"))
            {
                if (mL)
                {
                    mL.fechador();
                }
                mL          = gameObject.AddComponent <mensagemEmLuta>();
                mL.mensagem = bancoDeTextos.falacoes[heroi.lingua]["tuto"][1];
            }

            if (H.itemAoUso == 3)
            {
                tuto.vejaQualMens();
            }

            break;

        case faseDaEntrada.ultimoSigaCaesar:
            contadorDeTempo += Time.deltaTime;

            if (contadorDeTempo > 3)
            {
                if (!mens)
                {
                    mens = gameObject.AddComponent <mensagemBasica>();
                }
                mens.entrando = true;
                mensagemAtual = 22;
                mens.mensagem = essaConversa[22];
                fase          = faseDaEntrada.mensDoUltimoSigaCaesar;
                //CaesarTransform.position = new melhoraPos().novaPos( CoreanTransform.position+Vector3.right,1);
            }
            break;

        case faseDaEntrada.mensDoUltimoSigaCaesar:
            trocaMensagem();
            animatorDoCaesar.SetFloat("velocidade", CaesarNavMesh.velocity.magnitude);
            break;

        case faseDaEntrada.caesarAndandoFinal:
            animatorDoCaesar.SetFloat("velocidade", CaesarNavMesh.velocity.magnitude);
            break;

        case faseDaEntrada.giraProGlark:
            Vector3 V = GlarkTransform.position - CoreanTransform.position;
            V = new Vector3(V.x, 0, V.z);
            Quaternion Q = Quaternion.LookRotation(V);
            CoreanTransform.rotation = Quaternion.Lerp(CoreanTransform.rotation, Q, Time.deltaTime);
            V = GlarkTransform.position - CaesarTransform.position;
            V = new Vector3(V.x, 0, V.z);
            Q = Quaternion.LookRotation(V);
            CaesarTransform.rotation = Quaternion.Lerp(CaesarTransform.rotation, Q, Time.deltaTime);
            break;

        case faseDaEntrada.encontroComGlark:
            trocaMensagem();
            break;

        case faseDaEntrada.cameraParaGlar:
            trocaMensagem();
            transform.position = Vector3.Lerp(transform.position, posicoesDeCamera[9].position, 5 * Time.deltaTime);
            transform.rotation = Quaternion.Lerp(transform.rotation, posicoesDeCamera[9].rotation, 5 * Time.deltaTime);
            break;

        case faseDaEntrada.voltaCameraProCorean:
            trocaMensagem();
            transform.position = Vector3.Lerp(transform.position, posicoesDeCamera[7].position, 5 * Time.deltaTime);
            transform.rotation = Quaternion.Lerp(transform.rotation, posicoesDeCamera[7].rotation, 5 * Time.deltaTime);
            break;

        case faseDaEntrada.rajadaDeAgua:
            contadorDeTempo += Time.deltaTime;
            if (contadorDeTempo > 0.75f)
            {
                transform.position = Vector3.Lerp(transform.position, posicoesDeCamera[7].position, 5 * Time.deltaTime);
                transform.rotation = Quaternion.Lerp(transform.rotation, posicoesDeCamera[7].rotation, 5 * Time.deltaTime);
            }

            if (contadorDeTempo > 1.5f)
            {
                fase = faseDaEntrada.empurrandoParaQueda;
                transform.position = posicoesDeCamera[7].position;
                transform.rotation = posicoesDeCamera[7].rotation;
                animatorDoCaesar.Play("damage_25");
                animatorDoCorean.Play("damage_25");
                colDaPonte.enabled    = false;
                CaesarNavMesh.enabled = false;
                contadorDeTempo       = 0;
            }
            break;

        case faseDaEntrada.empurrandoParaQueda:
            contadorDeTempo += Time.deltaTime;
            if (contadorDeTempo < 1f)
            {
                CoreanTransform.position += 15 * Vector3.forward * Time.deltaTime;
                CaesarTransform.position += 15 * Vector3.forward * Time.deltaTime;
            }
            else
            {
                fase = faseDaEntrada.estadoNulo;
                p    = gameObject.AddComponent <pretoMorte>();
                StartCoroutine(pretoMorteVoltaFInal());
            }

            break;

        case faseDaEntrada.QuedaFinal:
            contadorDeTempo += Time.deltaTime;
            if (contadorDeTempo < 2)
            {
                CaesarTransform.position += Vector3.down * 15 * Time.deltaTime;
                CoreanTransform.position += Vector3.down * 15 * Time.deltaTime;
                pedrasFInais.position    += Vector3.down * 15 * Time.deltaTime;
            }
            else
            {
                p = gameObject.AddComponent <pretoMorte>();
                Invoke("novaCena", 2.75f);
            }
            break;
        }
    }