Пример #1
0
 void mensagemDeMorto()
 {
     focandoHeroi();
     mensL = aCamera.AddComponent<mensagemEmLuta>();
     mensL.mensagem = oMOrto.Nome+ falacoes[1];
     passoDaMorte = 1;
 }
Пример #2
0
    public void aplicaGolpe(Criature daki)
    {
        golpe G = daki.Golpes[daki.golpeEscolhido];

        System.GC.Collect();
        Resources.UnloadUnusedAssets();

/*
 *              print(G.UltimoUso+" : "+ Time.time+" : "+heroi.tempoNoJogo+" : "+G.TempoReuso);
 *
 *              print(G.UltimoUso < Time.time -  G.TempoReuso);
 */
        if (G.UltimoUso < Time.time - G.TempoReuso)
        {
            daki.cAtributos[1].Corrente -= daki.Golpes[daki.golpeEscolhido].CustoPE;

            G.UltimoUso = Time.time;
            acaoDeGolpe acao = gameObject.AddComponent <acaoDeGolpe> ();
            acao.ativa = G;
            //acao.emissor = emissor;
        }
        else if (gameObject.GetComponent <movimentoBasico>())
        {
            mensagemEmLuta mL = GetComponent <mensagemEmLuta>();
            if (mL)
            {
                mL.fechador();
            }
            mL          = gameObject.AddComponent <mensagemEmLuta>();
            mL.mensagem = string.Format(textos[1], mostradorDeTempo(G.UltimoUso - (Time.time - G.TempoReuso)));
        }
    }
Пример #3
0
 void mensagemDeMorto()
 {
     focandoHeroi();
     mensL          = aCamera.AddComponent <mensagemEmLuta>();
     mensL.mensagem = oMOrto.Nome + falacoes[1];
     passoDaMorte   = 1;
 }
Пример #4
0
    void informaQueMoreu()
    {
        mensagemEmLuta mL = Camera.main.gameObject.GetComponent <mensagemEmLuta>();

        if (mL)
        {
            mL.fechador();
        }

        mL = Camera.main.gameObject.AddComponent <mensagemEmLuta>();

        mL.mensagem = string.Format(textos[0], oAfetado.Nome);

        Destroy(this);
    }
Пример #5
0
    void retornaMenusEscondidos()
    {
        Menu[] menus = GetComponents <Menu>();
        foreach (Menu menu in menus)
        {
            menu.entrando = true;
        }


        mensagemEmLuta mL = GetComponent <mensagemEmLuta>();

        if (mL)
        {
            mL.entrando = true;
        }
    }
Пример #6
0
 void perguntaVivo()
 {
     passoDaMorte = 3;
     if (H.criaturesAtivos[(int)quemEntra.escolha].cAtributos[0].Corrente > 0)
     {
         coloqueEleEmCampo();
     }
     else
     {
         quemEntra.entrando  = false;
         quemEntra.podeMudar = false;
         mensB.entrando      = false;
         mensL          = aCamera.AddComponent <mensagemEmLuta>();
         mensL.mensagem = H.criaturesAtivos[(int)quemEntra.escolha].Nome +
                          falacoes[2];
     }
 }
Пример #7
0
    void mostraItens()
    {
        if (aVenda.Count > 0)
        {
            menu          = G.AddComponent <Menu>();
            menu.posXalvo = 0.01f;
            menu.posYalvo = 0.01f;


            menu.skin  = skin;
            menu.lMenu = 0.3f;

            menu.destaque    = destaque;
            menu.sobraAbaixo = 0.35f;


            menu2          = G.AddComponent <Menu>();
            menu2.posXalvo = 0.31f;
            menu2.posYalvo = 0.01f;


            menu2.skin  = skin;
            menu2.lMenu = 0.15f;

            menu2.destaque    = destaque;
            menu2.sobraAbaixo = 0.35f;

            opcoesMenu();

            mL             = G.AddComponent <mensagemEmLuta>();
            mL.posX        = 0.5f;
            mL.posY        = 0.01f;
            mL.tempoDeFuga = 0;
            mL.emY         = true;
            mL.mensagem    = "CRISTAIS: \r\n " + H.cristais;

            mL2             = G.AddComponent <mensagemEmLuta>();
            mL2.posX        = 0.57f;
            mL2.posY        = 0.52f;
            mL2.lCaixa      = 0.4f;
            mL2.tempoDeFuga = 0;
            mL2.positivo    = true;
            mL2.mensagem    = info[(int)(aVenda[0].nomeItem)];
        }
    }
Пример #8
0
    protected void mensagemDeAplicaDanoEnvenenado(string name)
    {
        mensagemEmLuta mL = Camera.main.gameObject.GetComponent <mensagemEmLuta>();

        if (mL)
        {
            mL.fechador();
        }

        mL = Camera.main.gameObject.AddComponent <mensagemEmLuta>();
        if (name == "CriatureAtivo")
        {
            mL.mensagem = string.Format(textos[1], oAfetado.Nome, ((int)forcaDoDano).ToString());
        }
        else
        {
            mL.mensagem = string.Format(textos[2], ((int)forcaDoDano).ToString());
        }
    }
Пример #9
0
 void perguntaVivo()
 {
     passoDaMorte = 3;
     if(H.criaturesAtivos[(int)quemEntra.escolha].cAtributos[0].Corrente>0)
         coloqueEleEmCampo();
     else
     {
         quemEntra.entrando = false;
         quemEntra.podeMudar = false;
         mensB.entrando = false;
         mensL = aCamera.AddComponent<mensagemEmLuta>();
         mensL.mensagem = H.criaturesAtivos[(int)quemEntra.escolha].Nome+
             falacoes[2];
     }
 }
Пример #10
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;
        }
    }
Пример #11
0
    // Update is called once per frame
    void Update()
    {
        if (Input.GetButtonDown ("menu e auxiliar"))
                menuEAux = true;

        if (Input.GetButtonDown ("acao"))
            acao = true;

        if (Input.GetButtonDown ("acaoAlt"))
            acaoAlt = true;

        switch(nomeMenu)
        {
        case "emEspera":
            if(menuEAux == true&&!pausaJogo.pause)
            {
                alternancia.focandoHeroi();
                mB.podeAndar = false;
                cameraCorean.enabled = false;
                mB.pararOHeroi();
                menu = gameObject.AddComponent<Menu>();
                string[] opcoes = tMIT2["mitPrincipal"].ToArray();//{"Status","Itens","Suporte","Organizaçao","Salvar"};
                menu.skin = skin;
                menu.destaque = destaque;
                menu.opcoes = opcoes;
                menu.posXalvo = 0.01f;
                menu.posYalvo = 0.01f;
                menu.lMenu = 0.2f;
                menu.aMenu = 0.1f*opcoes.Length;
                nomeMenu = "Principal";
                menu.Nome = nomeMenu;

                mL = gameObject.AddComponent<mensagemEmLuta>();
                mL.posX = 0.01f;
                mL.posY = 0.52f;
                mL.aCaixa = 0.1f;
                mL.lCaixa = 0.2f;
                mL.tempoDeFuga = 0;
                mL.mensagem = tMIT2["mitSoltos"][5]+H.cristais;

            }
        break;

        case "Status":
            if(acaoAlt)
                poderDoClick("Principal");

            if(menuEAux == true)
                fechaEVai(nomeMenu,"Principal");

            if(acao == true)
                escolhaStatus();
        break;
        case "StatusDeCriature":
            if (Input.GetButtonDown ("acao") || Input.GetButtonDown ("menu e auxiliar")||acaoAlt){
                painelStatus painel = GetComponent<painelStatus>();
                painel.fechaJanela ();
                nomeMenu = "Status";
                try{
                retornaMenu(nomeMenu).podeMudar = true;
                }catch(NullReferenceException e)
                {
                    Debug.LogWarning("nulidade de Menu, "+e.InnerException);
                }

            }
        break;
        case "Principal":
            if(menuEAux == true){
                FechaMenu(nomeMenu);
                nomeMenu = "emEspera";
                mB.podeAndar = true;
                cameraCorean.enabled = true;
                if(mL!=null)
                    mL.fechaJanela();
            }

            if(acaoAlt)
            {
                Menu daKi = retornaMenu(nomeMenu);
                if(daKi.dentroOuFora()>-1)

                    acao = true;
                else
                {
                    FechaMenu(nomeMenu);
                    nomeMenu = "emEspera";
                    mB.podeAndar = true;
                    cameraCorean.enabled = true;
                    if(mL!=null)
                        mL.fechaJanela();
                }

            }

            if(acao == true)
            {
                escolhaPrincipal();
            }
        break;
        case "Suporte":
            if(acaoAlt)
                poderDoClick("Principal");

            if(menuEAux == true)
                fechaEVai(nomeMenu,"Principal");

            if(acao == true)
            {
                escolhaSuporte();
            }
        break;
        case "semSuporte":
            if(menuEAux||acao||acaoAlt)
                fechaEVai(nomeMenu,"Suporte",false);
        break;
        case "Itens":
            uint escolhaAtual = retornaMenu("Itens").escolha;
            if(escolhaAtual != escolhaAntiga)
            {
                if(!mL2)
                {
                    mL2 = gameObject.AddComponent<mensagemEmLuta>();
                    mL2.posX = 0.57f;
                    mL2.posY = 0.52f;
                    mL2.lCaixa = 0.4f;
                    mL2.tempoDeFuga = 0;
                    mL2.positivo = true;
                }
                escolhaAntiga = (int)retornaMenu("Itens").escolha;
                trocaInfo();
            }
            if(acaoAlt)
                poderDoClick("Principal");

            if(acao)
                useiOItem();
            if(menuEAux)
            {
                fechaEVai(nomeMenu,"Principal");
                mL2.fechaJanela();
                escolhaAntiga = -1;
            }
        break;
        case "usandoItem":
            nomeMenu = GetComponent<acaoDeItem2>().estadoPublico;
        break;
        case "retornarAosItens":
            nomeMenu = "Itens";
            int escolha  = (int)retornaMenu(nomeMenu).escolha;
            if(escolha>=H.itens.Count)
            {
                if(H.itens.Count>0)
                    retornaMenu(nomeMenu).escolha--;
                else
                {
                    fechaEVai(nomeMenu,"Principal");
                    if(mL2)
                        mL2.fechaJanela();
                }
            }else
            {
                if(mL2)
                    mL2.entrando = true;

                retornaMenu(nomeMenu).podeMudar = true;
            }
            if(GetComponent<vidaEmLuta>())
                GetComponent<vidaEmLuta>().fechaJanela();
        break;
        case "semItem":
            if(menuEAux)
                fechaEVai(nomeMenu,"Principal",false);
        break;

        case "Organizaçao":

            if(acaoAlt)
                poderDoClick("Principal");

            if(menuEAux)
                fechaEVai(nomeMenu,"Principal");

            if(acao)
                perguntaDeOrganizacao();
        break;

        case "organizaCriatures":
            if(menuEAux)
                fechaEVai(nomeMenu,"Organizaçao");

            if(acaoAlt)
                poderDoClick("Organizaçao");

            if(acao)
                segundaOrganizacao();
        break;

        case "segundaOrganizaçao":
            if(menuEAux)
                fechaEVai(nomeMenu,"organizaCriatures");

            if(acaoAlt)
                poderDoClick("organizaCriatures");

            if(acao)
                trocaCriatures();
        break;
        case "animandoTroca":
            if(!GetComponent<animaTroca>())
            {
                GameObject meuHeroi = GameObject.FindGameObjectWithTag("Player");
                Animator animator = meuHeroi.GetComponent<Animator> ();
                animator.SetBool("envia",true);

                animaEnvia a = gameObject.AddComponent<animaEnvia>();
                a.posCriature = posTroca;
                a.oInstanciado = H.criaturesAtivos[0].nomeID;
                nomeMenu = "trocou";

            }
        break;
        case "trocou":
            if(!GetComponent<animaEnvia>())
            {
                Menu[] menus = GetComponents<Menu> ();
                foreach (Menu menu in menus)
                    menu.entrando = true;

                if(mL!=null)
                    mL.entrando = true;

                fechaEVai("segundaOrganizaçao","organizaCriatures");
                fechaEVai("organizaCriatures","Organizaçao");
                Animator animator = GameObject.FindGameObjectWithTag("Player").GetComponent<Animator>();
                    animator.SetBool("envia",false);
                animator.SetBool("chama",false);
            }

        break;
        case "escolhaSave":
            if(acaoAlt)
                poderDoClick("Principal");

            if(menuEAux == true){
                FechaMenu(nomeMenu);
                nomeMenu = "Principal";
                retornaMenu(nomeMenu).podeMudar = true;
            }

            if(acao == true)
            {
                perguntaDeSave();
            }
        break;
        case "novoSave":
            if(nomeie == null)
            {
                nomeMenu = "escolhaSave";
                    retornaMenu(nomeMenu).podeMudar = true;
            }

            if(Input.GetButtonDown("Submit"))
                if(nomeie!= null)
                    if(nomeie.entrando == true)
                        nomeie.acaoDoBotaoSalvar();

            if(Input.GetButtonDown("paraCriature"))
                nomeie.fechaJanela();

        break;
        case "mensagemDeSave":
            if(acao || menuEAux||acaoAlt)
            {
                mensS.fechaJanela();
                Menu m = retornaMenu("Principal");
                m.entrando = true;
                m.podeMudar = true;
                nomeMenu = m.Nome;
            }
        break;
        case "mensagemOrganizacaoFail":
            if(acao || menuEAux||acaoAlt)
            {
                mensS.fechaJanela();
                retornaParaOrganizacao();
            }
        break;
        case "limpaMIT":
            limpaOMIT();
        break;
        }

        acao = false;
        menuEAux = false;
        acaoAlt = false;
    }
Пример #12
0
    // Update is called once per frame
    void Update()
    {
        contadorDeTempo += Time.deltaTime;
        if (iniciou)
        {
            desliza(painel[qual]);

            if ((contadorDeTempo > 25 || tempoDestaAcao > 5) && tempoLimitado)
            {
                entrando = false;
                //qual++;
            }
            switch (ensinando)
            {
            case estouEnsinando.movimentoCorrerEPulo:
                if (Mathf.Abs(Input.GetAxis("Horizontal")) > 0 ||
                    Mathf.Abs(Input.GetAxis("Vertical")) > 0 ||
                    Input.GetButtonDown("Correr"))
                {
                    entendeu = true;
                }

                if (Vector3.Distance(CoreanTransform.position, pontoParaEnsinarACamera.position) < 3)
                {
                    qual      = 1;
                    ensinando = estouEnsinando.camera;
                    renovandoMensagem();
                }
                break;

            case estouEnsinando.camera:
                if (Input.GetAxis("Mouse Y") != 0 || Input.GetAxis("Mouse X") != 0 || Input.GetButtonDown("centraCamera"))
                {
                    entendeu = true;
                }
                break;

            case estouEnsinando.usarCriature:
                if (Input.GetButtonDown("paraCriature"))
                {
                    painel[qual].anchoredPosition = new Vector2(painel[qual].anchoredPosition.x, -300);
                    qual++;
                    ensinando = estouEnsinando.atacar;
                }
                break;

            case estouEnsinando.atacar:
                if (Input.GetButtonDown("acao"))
                {
                    entendeu = true;
                }

                if (Input.GetButtonDown("paraCriature"))
                {
                    entrando = false;
                }
                break;

            case estouEnsinando.usarMaca:
                if (!ensinouMaca)
                {
                    tCaesar.position = CoreanTransform.position + CoreanTransform.right;
                    tCaesar.rotation = CoreanTransform.rotation;
                    painel[4].gameObject.SetActive(true);
                    GameObject G = GameObject.Find("CriatureAtivo");
                    cam         = G.GetComponent <cameraPrincipal>();
                    mB          = G.GetComponent <movimentoBasico>();
                    cam.enabled = false;
                    mB.enabled  = false;
                    vidaEmLuta[] vS = GameObject.Find("encontreEle").GetComponents <vidaEmLuta>();
                    foreach (vidaEmLuta v in vS)
                    {
                        v.entrando = false;
                    }
                    ensinouMaca = true;
                }
                //Vector3 posAlvo = focoNoCaesar();

                if (Vector3.Distance(focoNoCaesar(), transform.position) < 0.3f)
                {
                    transform.rotation = Quaternion.LookRotation(tCaesar.position - transform.position);
                    ensinando          = estouEnsinando.mudaItem;
                    mens          = gameObject.AddComponent <mensagemBasica>();
                    mens.posY     = 0.67f;
                    mens.skin     = elementosDoJogo.el.skin;
                    mens.destaque = elementosDoJogo.el.destaque;
                    mens.mensagem = mensDeTuto[0];
                    H.criaturesAtivos[0].cAtributos[0].Corrente--;
                    tempoLimitado = false;
                }
                break;

            case estouEnsinando.mudaItem:
                trocaMensagem();
                break;

            case estouEnsinando.usarGatilhoDoItem:
                if (Input.GetButtonDown("menu e auxiliar"))
                {
                    jaFocou = true;
                }
                desliza2(painel[7], !jaFocou);

                if (!IA2)
                {
                    IA2 = GameObject.Find("inimigo").GetComponent <IA_paraTutu>();
                }
                if (mB.enabled && mB.podeAndar)
                {
                    IA2.enabled = true;
                }

                /*
                 * if(!mB.enabled&&!mB.podeAndar&&!IA2.enabled)
                 * {
                 *      //print("por aqui");
                 *      useAEnergiaDeGarras();
                 *      IA2.enabled = false;
                 * }
                 */


                break;

            case estouEnsinando.outroGolpe:
                desliza2(painel[8], true);
                if (Input.GetButtonDown("trocaGolpe"))
                {
                    mB.criatureVerificaTrocaGolpe();
                }

                if (H.criaturesAtivos[0].golpeEscolhido == 1)
                {
                    jaFocou = true;
                    if (Input.GetButtonDown("acao"))
                    {
                        mB.aplicaGolpe(H.criaturesAtivos[0]);
                        ensinando = estouEnsinando.usaEnergiaDeGarras;
                        jaFocou   = false;
                    }
                }
                else if (Input.GetButtonDown("acao"))
                {
                    if (mL)
                    {
                        mL.fechador();
                    }
                    mL            = gameObject.AddComponent <mensagemEmLuta>();
                    mL.posY       = 0.01f;
                    mL.mensagem   = mensDeTuto[3];
                    mensagemAtual = 3;
                }



                desliza2(painel[9], jaFocou, -1);


                break;

            case estouEnsinando.usaEnergiaDeGarras:
                desliza2(painel[8], false);
                desliza2(painel[9], false, -1);

                if (mB)
                {
                    if (mB.enabled && mB.podeAndar)
                    {
                        ensinando             = estouEnsinando.capturar;
                        heroi.contraTreinador = false;
                        mB.enabled            = false;
                        cam.enabled           = false;
                        GameObject  Inimigo = GameObject.Find("inimigo");
                        IA_paraTutu IA      = Inimigo.GetComponent <IA_paraTutu>();
                        IA.enabled = false;
                        IA.paraMovimento();
                        Inimigo.GetComponent <umCriature>().X.cAtributos[0].Corrente = 1;
                    }
                }
                else
                {
                    ensinando = estouEnsinando.estadoNulo;
                }
                break;

            case estouEnsinando.capturar:
                if (Vector3.Distance(focoNoCaesar(), transform.position) < 0.3f)
                {
                    transform.rotation = Quaternion.LookRotation(tCaesar.position - transform.position);
                    vidaEmLuta[] vS = GameObject.Find("encontreEle").GetComponents <vidaEmLuta>();
                    foreach (vidaEmLuta v in vS)
                    {
                        v.entrando = false;
                    }

                    mens.entrando = true;
                    mens.mensagem = mensDeTuto[2];
                    mensagemAtual = 2;
                }

                trocaMensagem();
                break;

            case estouEnsinando.usarCartaLuva:

                if (!Input.GetButtonDown("gatilho"))
                {
                    mB.criatureScroll();
                }
                else if (H.itemAoUso == 4 && !Input.GetButton("Correr"))
                {
                    GameObject.Find("CriatureAtivo").GetComponent <movimentoBasico>().criatureScroll();
                    ensinando = estouEnsinando.queroEnsinarTrocarDeCriature;
                    removeEsbranquicado();
                }
                else if (!Input.GetButton("Correr"))
                {
                    if (mL)
                    {
                        mL.fechador();
                    }
                    mL          = gameObject.AddComponent <mensagemEmLuta>();
                    mL.mensagem = mensDeTuto[1];
                }

                if (H.itemAoUso == 4)
                {
                    vejaQualMens((int)estouEnsinando.usarCartaLuva);
                }
                break;

            case estouEnsinando.queroEnsinarTrocarDeCriature:
                if (!heroi.emLuta)
                {
                    mB         = H.GetComponent <movimentoBasico>();
                    mB.enabled = false;
                    variaveisChave.shift["HUDItens"] = true;
                    ensinando     = estouEnsinando.trocarCriature;
                    mens.entrando = true;
                    mens.mensagem = mensDeTuto[6];
                    mensagemAtual = 6;
                }
                break;

            case estouEnsinando.trocarCriature:
                if (encontros.botoesPrincipais())
                {
                    mens.entrando = false;
                    ensinando     = estouEnsinando.botaoTrocarCriature;
                    qual          = 10;
                    entrando      = true;
                    variaveisChave.shift["HUDCriatures"] = false;
                    jaFocou = false;
                }
                break;

            case estouEnsinando.botaoTrocarCriature:
                mB.criatureScroll();

                if (!jaFocou)
                {
                    if (GameObject.FindGameObjectWithTag("MainCamera").GetComponent <HUDCriatures>())
                    {
                        vejaQualMens((int)estouEnsinando.botaoTrocarCriature);
                        jaFocou = true;
                    }
                }

                if (Input.GetButton("Correr") && Input.GetButtonDown("gatilho"))
                {
                    ensinando = estouEnsinando.estadoNulo;
                    entrando  = false;
                    variaveisChave.shift["HUDItens"]            = false;
                    variaveisChave.shift["alternaParaCriature"] = false;
                    variaveisChave.shift["trocaGolpes"]         = false;

                    ePlus.maisDoCaesar();
                }
                break;
            }


            if (entendeu)
            {
                tempoDestaAcao += Time.deltaTime;
            }
        }
    }
Пример #13
0
    void primeiraEscolha()
    {
        switch (menu.escolha)
        {
        case 0:
            if (acaoAlt && menu.dentroOuFora() > -1)
            {
                acao = true;
            }
            if (acao)
            {
                GameObject.Find("Canvas").GetComponentInChildren <Text>().enabled = true;
                Destroy(menu);
                Application.LoadLevel("Entradinha2");
            }
            break;

        case 1:
            if (acaoAlt && menu.dentroOuFora() > -1)
            {
                acao = true;
            }
            if (acao)
            {
                if (menu2 == null)
                {
                    saveGame.Load();
                    if (saveGame.savedGames.Count > 0)
                    {
                        entrandoPainel = false;
                        canvas3.SetActive(false);
                        //	acao = false;

                        menu.podeMudar = false;
                        menu.entrando  = false;
                        menu2          = gameObject.AddComponent <Menu>();
                        menu2.posXalvo = menu.posXalvo;
                        menu2.posYalvo = 0.01f;
                        menu2.aMenu    = 0.1f * saveGame.savedGames.Count;
                        menu2.lMenu    = menu.lMenu;
                        menu2.opcoes   = saveGame.jogosSalvos().ToArray();
                        menu2.skin     = skin;
                        menu2.destaque = destaque;

                        situacao = "menuCarrega";
                    }
                    else
                    {
                        mensagemEmLuta mL = Camera.main.gameObject.GetComponent <mensagemEmLuta>();
                        if (mL)
                        {
                            mL.fechador();
                        }
                        mL          = Camera.main.gameObject.AddComponent <mensagemEmLuta>();
                        mL.skin     = skin;
                        mL.posX     = 0.67f;
                        mL.positivo = true;
                        mL.mensagem = "nao foram encontrados jogos salvos";
                    }
                }
            }


            break;

        case 2:
            if (acaoAlt && menu.dentroOuFora() > -1)
            {
                acao = true;
            }
            if (acao)
            {
                Application.Quit();
            }
            break;
        }
    }
Пример #14
0
    // Update is called once per frame
    void Update()
    {
        if (Input.GetButtonDown("menu e auxiliar"))
        {
            menuEAux = true;
        }

        if (Input.GetButtonDown("acao"))
        {
            acao = true;
        }

        if (Input.GetButtonDown("acaoAlt"))
        {
            acaoAlt = true;
        }

        switch (nomeMenu)
        {
        case "emEspera":
            if (menuEAux == true && !pausaJogo.pause)
            {
                alternancia.focandoHeroi();
                mB.podeAndar         = false;
                cameraCorean.enabled = false;
                mB.pararOHeroi();
                menu = gameObject.AddComponent <Menu>();
                string[] opcoes = tMIT2["mitPrincipal"].ToArray();                //{"Status","Itens","Suporte","Organizaçao","Salvar"};
                menu.skin     = skin;
                menu.destaque = destaque;
                menu.opcoes   = opcoes;
                menu.posXalvo = 0.01f;
                menu.posYalvo = 0.01f;
                menu.lMenu    = 0.2f;
                menu.aMenu    = 0.1f * opcoes.Length;
                nomeMenu      = "Principal";
                menu.Nome     = nomeMenu;

                mL             = gameObject.AddComponent <mensagemEmLuta>();
                mL.posX        = 0.01f;
                mL.posY        = 0.52f;
                mL.aCaixa      = 0.1f;
                mL.lCaixa      = 0.2f;
                mL.tempoDeFuga = 0;
                mL.mensagem    = tMIT2["mitSoltos"][5] + H.cristais;
            }
            break;


        case "Status":
            if (acaoAlt)
            {
                poderDoClick("Principal");
            }

            if (menuEAux == true)
            {
                fechaEVai(nomeMenu, "Principal");
            }

            if (acao == true)
            {
                escolhaStatus();
            }
            break;

        case "StatusDeCriature":
            if (Input.GetButtonDown("acao") || Input.GetButtonDown("menu e auxiliar") || acaoAlt)
            {
                painelStatus painel = GetComponent <painelStatus>();
                painel.fechaJanela();
                nomeMenu = "Status";
                try{
                    retornaMenu(nomeMenu).podeMudar = true;
                }catch (NullReferenceException e)
                {
                    Debug.LogWarning("nulidade de Menu, " + e.InnerException);
                }
            }
            break;

        case "Principal":
            if (menuEAux == true)
            {
                FechaMenu(nomeMenu);
                nomeMenu             = "emEspera";
                mB.podeAndar         = true;
                cameraCorean.enabled = true;
                if (mL != null)
                {
                    mL.fechaJanela();
                }
            }

            if (acaoAlt)
            {
                Menu daKi = retornaMenu(nomeMenu);
                if (daKi.dentroOuFora() > -1)
                {
                    acao = true;
                }
                else
                {
                    FechaMenu(nomeMenu);
                    nomeMenu             = "emEspera";
                    mB.podeAndar         = true;
                    cameraCorean.enabled = true;
                    if (mL != null)
                    {
                        mL.fechaJanela();
                    }
                }
            }

            if (acao == true)
            {
                escolhaPrincipal();
            }
            break;

        case "Suporte":
            if (acaoAlt)
            {
                poderDoClick("Principal");
            }

            if (menuEAux == true)
            {
                fechaEVai(nomeMenu, "Principal");
            }

            if (acao == true)
            {
                escolhaSuporte();
            }
            break;

        case "semSuporte":
            if (menuEAux || acao || acaoAlt)
            {
                fechaEVai(nomeMenu, "Suporte", false);
            }
            break;

        case "Itens":
            uint escolhaAtual = retornaMenu("Itens").escolha;
            if (escolhaAtual != escolhaAntiga)
            {
                if (!mL2)
                {
                    mL2             = gameObject.AddComponent <mensagemEmLuta>();
                    mL2.posX        = 0.57f;
                    mL2.posY        = 0.52f;
                    mL2.lCaixa      = 0.4f;
                    mL2.tempoDeFuga = 0;
                    mL2.positivo    = true;
                }
                escolhaAntiga = (int)retornaMenu("Itens").escolha;
                trocaInfo();
            }
            if (acaoAlt)
            {
                poderDoClick("Principal");
            }

            if (acao)
            {
                useiOItem();
            }
            if (menuEAux)
            {
                fechaEVai(nomeMenu, "Principal");
                mL2.fechaJanela();
                escolhaAntiga = -1;
            }
            break;

        case "usandoItem":
            nomeMenu = GetComponent <acaoDeItem2>().estadoPublico;
            break;

        case "retornarAosItens":
            nomeMenu = "Itens";
            int escolha = (int)retornaMenu(nomeMenu).escolha;
            if (escolha >= H.itens.Count)
            {
                if (H.itens.Count > 0)
                {
                    retornaMenu(nomeMenu).escolha--;
                }
                else
                {
                    fechaEVai(nomeMenu, "Principal");
                    if (mL2)
                    {
                        mL2.fechaJanela();
                    }
                }
            }
            else
            {
                if (mL2)
                {
                    mL2.entrando = true;
                }

                retornaMenu(nomeMenu).podeMudar = true;
            }
            if (GetComponent <vidaEmLuta>())
            {
                GetComponent <vidaEmLuta>().fechaJanela();
            }
            break;

        case "semItem":
            if (menuEAux)
            {
                fechaEVai(nomeMenu, "Principal", false);
            }
            break;

        case "Organizaçao":

            if (acaoAlt)
            {
                poderDoClick("Principal");
            }

            if (menuEAux)
            {
                fechaEVai(nomeMenu, "Principal");
            }


            if (acao)
            {
                perguntaDeOrganizacao();
            }
            break;

        case "organizaCriatures":
            if (menuEAux)
            {
                fechaEVai(nomeMenu, "Organizaçao");
            }

            if (acaoAlt)
            {
                poderDoClick("Organizaçao");
            }

            if (acao)
            {
                segundaOrganizacao();
            }
            break;

        case "segundaOrganizaçao":
            if (menuEAux)
            {
                fechaEVai(nomeMenu, "organizaCriatures");
            }

            if (acaoAlt)
            {
                poderDoClick("organizaCriatures");
            }



            if (acao)
            {
                trocaCriatures();
            }
            break;

        case "animandoTroca":
            if (!GetComponent <animaTroca>())
            {
                GameObject meuHeroi = GameObject.FindGameObjectWithTag("Player");
                Animator   animator = meuHeroi.GetComponent <Animator> ();
                animator.SetBool("envia", true);

                animaEnvia a = gameObject.AddComponent <animaEnvia>();
                a.posCriature  = posTroca;
                a.oInstanciado = H.criaturesAtivos[0].nomeID;
                nomeMenu       = "trocou";
            }
            break;

        case "trocou":
            if (!GetComponent <animaEnvia>())
            {
                Menu[] menus = GetComponents <Menu> ();
                foreach (Menu menu in menus)
                {
                    menu.entrando = true;
                }

                if (mL != null)
                {
                    mL.entrando = true;
                }


                fechaEVai("segundaOrganizaçao", "organizaCriatures");
                fechaEVai("organizaCriatures", "Organizaçao");
                Animator animator = GameObject.FindGameObjectWithTag("Player").GetComponent <Animator>();
                animator.SetBool("envia", false);
                animator.SetBool("chama", false);
            }

            break;

        case "escolhaSave":
            if (acaoAlt)
            {
                poderDoClick("Principal");
            }

            if (menuEAux == true)
            {
                FechaMenu(nomeMenu);
                nomeMenu = "Principal";
                retornaMenu(nomeMenu).podeMudar = true;
            }



            if (acao == true)
            {
                perguntaDeSave();
            }
            break;

        case "novoSave":
            if (nomeie == null)
            {
                nomeMenu = "escolhaSave";
                retornaMenu(nomeMenu).podeMudar = true;
            }

            if (Input.GetButtonDown("Submit"))
            {
                if (nomeie != null)
                {
                    if (nomeie.entrando == true)
                    {
                        nomeie.acaoDoBotaoSalvar();
                    }
                }
            }

            if (Input.GetButtonDown("paraCriature"))
            {
                nomeie.fechaJanela();
            }

            break;

        case "mensagemDeSave":
            if (acao || menuEAux || acaoAlt)
            {
                mensS.fechaJanela();
                Menu m = retornaMenu("Principal");
                m.entrando  = true;
                m.podeMudar = true;
                nomeMenu    = m.Nome;
            }
            break;

        case "mensagemOrganizacaoFail":
            if (acao || menuEAux || acaoAlt)
            {
                mensS.fechaJanela();
                retornaParaOrganizacao();
            }
            break;

        case "limpaMIT":
            limpaOMIT();
            break;
        }

        acao     = false;
        menuEAux = false;
        acaoAlt  = false;
    }
Пример #15
0
    public void criatureScroll()
    {
        float alt2 = alternador2();

        if (alt2 == 0)
        {
            alt2 = alternador3();
        }



        if (!Input.GetButton("Correr"))
        {
            if (Input.GetButtonDown("gatilho") && !variaveisChave.shift["HUDItens"])
            {
                if (Time.time - H.tempoDoUltimoUsoDeItem > H.intervaloParaUsarItem || !heroi.emLuta)
                {
                    GameObject.FindGameObjectWithTag("Player").AddComponent <usaItemEmLuta>();
                }
                else
                {
                    usaItemEmLuta.mensagemDuranteALuta(
                        string.Format(textos[0],
                                      comandos.mostradorDeTempo(
                                          H.tempoDoUltimoUsoDeItem - (Time.time - H.intervaloParaUsarItem))
                                      ));
                }
            }


            if ((Input.GetAxis("alternador") != 0 || alt2 != 0) && !variaveisChave.shift["HUDItens"])
            {
                if (!hudI)
                {
                    hudI = GameObject.FindGameObjectWithTag("MainCamera").AddComponent <HUDItens>();
                }

                hudI.zeraTempo();

                if (Input.GetAxis("alternador") < 0 || alt2 < 0)
                {
                    if (!H)
                    {
                        H = GameObject.FindWithTag("Player").GetComponent <heroi>();
                    }

                    if (H.itemAoUso < H.itens.Count - 1)
                    {
                        H.itemAoUso++;
                    }
                    else if (H.itens.Count > 0)
                    {
                        H.itemAoUso = 0;
                    }
                }
                else if (Input.GetAxis("alternador") > 0 || alt2 > 0)
                {
                    if (H.itemAoUso > 0)
                    {
                        H.itemAoUso--;
                    }
                    else if (H.itens.Count > 0)
                    {
                        H.itemAoUso = H.itens.Count - 1;
                    }
                }
            }
        }
        else
        {
            if ((Input.GetAxis("alternador") != 0 || alt2 != 0) && !variaveisChave.shift["HUDCriatures"])
            {
                if (!hud)
                {
                    hud = GameObject.FindGameObjectWithTag("MainCamera").AddComponent <HUDCriatures>();
                }

                hud.zeraTempo();

                if (Input.GetAxis("alternador") < 0 || alt2 < 0)
                {
                    if (H.criatureSai < H.criaturesAtivos.Count - 1)
                    {
                        H.criatureSai++;
                    }
                    else if (H.criaturesAtivos.Count > 1)
                    {
                        H.criatureSai = 1;
                    }
                }
                else if (Input.GetAxis("alternador") > 0 || alt2 > 0)
                {
                    if (H.criatureSai > 1)
                    {
                        H.criatureSai--;
                    }
                    else if (H.criaturesAtivos.Count > 1)
                    {
                        H.criatureSai = H.criaturesAtivos.Count - 1;
                    }
                }

                if (H.criaturesAtivos.Count < 2)
                {
                    H.criatureSai = 0;
                }
            }

            if (Input.GetButtonDown("gatilho") && H.criaturesAtivos.Count > 1 && !variaveisChave.shift["HUDCriatures"])
            {
                if (H.criaturesAtivos[H.criatureSai].cAtributos[0].Corrente > 0)
                {
                    GameObject.FindGameObjectWithTag("Player").AddComponent <alternanciaEmLuta>();
                }
                else if (!variaveisChave.shift["HUDCriatures"])
                {
                    GameObject maeCamera = GameObject.Find("Main Camera");
                    if (maeCamera.GetComponent <mensagemEmLuta>())
                    {
                        maeCamera.GetComponent <mensagemEmLuta>().fechador();
                    }
                    mensagemEmLuta mL = maeCamera.AddComponent <mensagemEmLuta>();
                    mL.mensagem = string.Format(textos[2], H.criaturesAtivos[H.criatureSai].Nome);
                }
            }
        }
    }
Пример #16
0
    void mostraItens()
    {
        if(aVenda.Count>0)
        {

            menu = G.AddComponent<Menu>();
            menu.posXalvo = 0.01f;
            menu.posYalvo = 0.01f;

            menu.skin = skin;
            menu.lMenu = 0.3f;

            menu.destaque = destaque;
            menu.sobraAbaixo = 0.35f;

            menu2 = G.AddComponent<Menu>();
            menu2.posXalvo = 0.31f;
            menu2.posYalvo = 0.01f;

            menu2.skin = skin;
            menu2.lMenu = 0.15f;

            menu2.destaque = destaque;
            menu2.sobraAbaixo = 0.35f;

            opcoesMenu();

            mL = G.AddComponent<mensagemEmLuta>();
            mL.posX = 0.5f;
            mL.posY = 0.01f;
            mL.tempoDeFuga = 0;
            mL.emY = true;
            mL.mensagem = "CRISTAIS: \r\n "+H.cristais;

            mL2 = G.AddComponent<mensagemEmLuta>();
            mL2.posX = 0.57f;
            mL2.posY = 0.52f;
            mL2.lCaixa = 0.4f;
            mL2.tempoDeFuga = 0;
            mL2.positivo = true;
            mL2.mensagem = info[(int)(aVenda[0].nomeItem)];
        }
    }
Пример #17
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;
        }
    }
Пример #18
0
    // Update is called once per frame
    void Update()
    {
        contadorDeTempo+=Time.deltaTime;
        if(iniciou)
        {
            desliza(painel[qual]);

            if((contadorDeTempo>25 || tempoDestaAcao>5)&&tempoLimitado)
            {
                entrando = false;
                //qual++;
            }
            switch(ensinando)
            {
            case estouEnsinando.movimentoCorrerEPulo:
                if(Mathf.Abs(Input.GetAxis("Horizontal"))>0
                   || Mathf.Abs(Input.GetAxis("Vertical"))>0
                   ||Input.GetButtonDown("Correr"))
                {
                    entendeu = true;
                }

                if(Vector3.Distance(CoreanTransform.position,pontoParaEnsinarACamera.position)<3)
                {
                    qual = 1;
                    ensinando = estouEnsinando.camera;
                    renovandoMensagem();
                }
            break;
            case estouEnsinando.camera:
                if(Input.GetAxis("Mouse Y")!=0 || Input.GetAxis("Mouse X")!=0 || Input.GetButtonDown("centraCamera"))
                {
                    entendeu = true;
                }
            break;
            case estouEnsinando.usarCriature:
                if(Input.GetButtonDown("paraCriature"))
                {
                    painel[qual].anchoredPosition = new Vector2(painel[qual].anchoredPosition.x,-300);
                    qual++;
                    ensinando = estouEnsinando.atacar;
                }
            break;
            case estouEnsinando.atacar:
                if(Input.GetButtonDown("acao"))
                {
                    entendeu = true;
                }

                if(Input.GetButtonDown("paraCriature"))
                {
                    entrando = false;
                }
            break;
            case estouEnsinando.usarMaca:
                if(!ensinouMaca)
                {
                    tCaesar.position = CoreanTransform.position+CoreanTransform.right;
                    tCaesar.rotation = CoreanTransform.rotation;
                    painel[4].gameObject.SetActive(true);
                    GameObject G =  GameObject.Find("CriatureAtivo");
                    cam = G.GetComponent<cameraPrincipal>();
                    mB = G.GetComponent<movimentoBasico>();
                    cam.enabled = false;
                    mB.enabled = false;
                    vidaEmLuta[] vS =  GameObject.Find("encontreEle").GetComponents<vidaEmLuta>();
                    foreach(vidaEmLuta v in vS)
                    {
                        v.entrando = false;
                    }
                    ensinouMaca = true;

                }
                //Vector3 posAlvo = focoNoCaesar();

                if(Vector3.Distance(focoNoCaesar(),transform.position)<0.3f)
                {
                    transform.rotation = Quaternion.LookRotation(tCaesar.position-transform.position);
                    ensinando = estouEnsinando.mudaItem;
                    mens = gameObject.AddComponent<mensagemBasica>();
                    mens.posY = 0.67f;
                    mens.skin = elementosDoJogo.el.skin;
                    mens.destaque = elementosDoJogo.el.destaque;
                    mens.mensagem = mensDeTuto[0];
                    H.criaturesAtivos[0].cAtributos[0].Corrente--;
                    tempoLimitado = false;
                }
            break;
            case estouEnsinando.mudaItem:
                trocaMensagem();
            break;
            case estouEnsinando.usarGatilhoDoItem:
                if(Input.GetButtonDown("menu e auxiliar"))
                    jaFocou = true;
                desliza2(painel[7],!jaFocou);

                if(!IA2)
                    IA2 = GameObject.Find("inimigo").GetComponent<IA_paraTutu>();
                if(mB.enabled&&mB.podeAndar)
                    IA2.enabled = true;
                /*
                if(!mB.enabled&&!mB.podeAndar&&!IA2.enabled)
                {
                    //print("por aqui");
                    useAEnergiaDeGarras();
                    IA2.enabled = false;
                }
                */

            break;
            case estouEnsinando.outroGolpe:
                desliza2(painel[8],true);
                if(Input.GetButtonDown("trocaGolpe"))
                {

                    mB.criatureVerificaTrocaGolpe();
                }

                if(H.criaturesAtivos[0].golpeEscolhido==1)
                {
                    jaFocou = true;
                    if(Input.GetButtonDown("acao"))
                    {
                        mB.aplicaGolpe(H.criaturesAtivos[0]);
                        ensinando = estouEnsinando.usaEnergiaDeGarras;
                        jaFocou = false;
                    }
                }else if(Input.GetButtonDown("acao"))
                {
                    if(mL)
                        mL.fechador();
                    mL = gameObject.AddComponent<mensagemEmLuta>();
                    mL.posY = 0.01f;
                    mL.mensagem = mensDeTuto[3];
                    mensagemAtual = 3;
                }

                desliza2(painel[9],jaFocou,-1);

            break;
            case estouEnsinando.usaEnergiaDeGarras:
                desliza2(painel[8],false);
                desliza2(painel[9],false,-1);

                if(mB){
                if(mB.enabled && mB.podeAndar)
                {
                    ensinando = estouEnsinando.capturar;
                    heroi.contraTreinador = false;
                    mB.enabled = false;
                    cam.enabled = false;
                    GameObject Inimigo = GameObject.Find("inimigo");
                    IA_paraTutu IA =  Inimigo.GetComponent<IA_paraTutu>();
                    IA.enabled = false;
                    IA.paraMovimento();
                    Inimigo.GetComponent<umCriature>().X.cAtributos[0].Corrente = 1;
                }
                }else
                    ensinando = estouEnsinando.estadoNulo;
            break;

            case estouEnsinando.capturar:
                if(Vector3.Distance(focoNoCaesar(),transform.position)<0.3f)
                {
                    transform.rotation = Quaternion.LookRotation(tCaesar.position-transform.position);
                    vidaEmLuta[] vS =  GameObject.Find("encontreEle").GetComponents<vidaEmLuta>();
                    foreach(vidaEmLuta v in vS)
                    {
                        v.entrando = false;
                    }

                    mens.entrando = true;
                    mens.mensagem = mensDeTuto[2];
                    mensagemAtual = 2;
                }

                trocaMensagem();
            break;
            case estouEnsinando.usarCartaLuva:

                if(!Input.GetButtonDown("gatilho"))
                    mB.criatureScroll();
                else if(H.itemAoUso==4&&!Input.GetButton("Correr"))
                {
                    GameObject.Find("CriatureAtivo").GetComponent<movimentoBasico>().criatureScroll();
                    ensinando = estouEnsinando.queroEnsinarTrocarDeCriature;
                    removeEsbranquicado();

                }else if(!Input.GetButton("Correr"))
                {
                    if(mL)
                        mL.fechador();
                    mL = gameObject.AddComponent<mensagemEmLuta>();
                    mL.mensagem = mensDeTuto[1];
                }

                if(H.itemAoUso==4)
                    vejaQualMens((int)estouEnsinando.usarCartaLuva);
            break;
            case estouEnsinando.queroEnsinarTrocarDeCriature:
                if(!heroi.emLuta)
                {
                    mB = H.GetComponent<movimentoBasico>();
                    mB.enabled = false;
                    variaveisChave.shift["HUDItens"] = true;
                    ensinando = estouEnsinando.trocarCriature;
                    mens.entrando = true;
                    mens.mensagem = mensDeTuto[6];
                    mensagemAtual = 6;
                }
            break;
            case estouEnsinando.trocarCriature:
                if(encontros.botoesPrincipais())
                {
                    mens.entrando = false;
                    ensinando = estouEnsinando.botaoTrocarCriature;
                    qual = 10;
                    entrando = true;
                    variaveisChave.shift["HUDCriatures"] = false;
                    jaFocou = false;
                }
            break;
            case estouEnsinando.botaoTrocarCriature:
                mB.criatureScroll();

                if(!jaFocou)
                if(GameObject.FindGameObjectWithTag("MainCamera").GetComponent<HUDCriatures>())
                {
                    vejaQualMens((int)estouEnsinando.botaoTrocarCriature);
                    jaFocou = true;
                }

                if(Input.GetButton("Correr")&&Input.GetButtonDown("gatilho"))
                {
                    ensinando =  estouEnsinando.estadoNulo;
                    entrando = false;
                    variaveisChave.shift["HUDItens"] = false;
                    variaveisChave.shift["alternaParaCriature"] = false;
                    variaveisChave.shift["trocaGolpes"] = false;

                    ePlus.maisDoCaesar();
                }
            break;
            }

            if(entendeu)
            {
                tempoDestaAcao+=Time.deltaTime;
            }

        }
    }