public void ImpatoAtivo(GameObject G, IGolpeBase ativa, CaracteristicasDeImpacto caracteristica)
    {
        tempoDecorrido += Time.deltaTime;
        if (!procurouAlvo)
        {
            alvoProcurado = CriaturesPerto.procureUmBomAlvo(G);
            procurouAlvo  = true;
            Debug.Log(alvoProcurado + "  esse é o alvo");
            ajudaAtaque(alvoProcurado, G.transform);
        }

        if (!addView)
        {
            tempoDecorrido += ativa.TempoDeMoveMin;
            ColisorDeGolpe.AdicionaOColisor(G, ativa, caracteristica, tempoDecorrido);

            addView = true;
        }

        if (tempoDecorrido < ativa.TempoDeMoveMax)
        {
            if (((int)(tempoDecorrido * 10)) % 2 == 0 && alvoProcurado)
            {
                ajudaAtaque(alvoProcurado, G.transform);
            }

            ativa.DirDeREpulsao = G.transform.forward;

            if (!controle)
            {
                controle = G.GetComponent <CharacterController>();
            }
            controle.Move(ativa.VelocidadeDeGolpe * G.transform.forward * Time.deltaTime + Vector3.down * 9.8f);
        }
    }
Esempio n. 2
0
    protected void instanciaEletricidade(GameObject G, Vector3 paraOnde, float tempoMax = 10)
    {
        GolpePersonagem golpeP = GolpePersonagem.RetornaGolpePersonagem(G, Nome);

        if (golpeP.TempoDeInstancia > 0)
        {
            carac.posInicial = Emissor.UseOEmissor(G, Nome);
        }

        GameObject KY  = AuxiliarDeInstancia.InstancieEDestrua(DoJogo.raioEletrico, carac.posInicial, DirDeREpulsao, TempoDeDestroy);
        Transform  KXY = KY.transform.GetChild(0);

        MonoBehaviour.Destroy(KXY.gameObject, 4.9f);

        KXY.parent        = G.transform.Find(golpeP.Colisor.osso).transform;
        KXY.localPosition = Vector3.zero;
        projeteis.Add(KY.transform);
        MbProjetilEletrico proj = KY.transform.GetChild(2).gameObject.AddComponent <MbProjetilEletrico>();

        proj.transform.position += golpeP.DistanciaEmissora * G.transform.forward + golpeP.AcimaDoChao * Vector3.up;
        proj.KXY                = KXY;
        proj.criatureAlvo       = CriaturesPerto.procureUmBomAlvo(G, 350);
        proj.forcaInicial       = paraOnde.normalized;
        proj.velocidadeProjetil = 9;
        proj.tempoMax           = tempoMax;
        proj.noImpacto          = carac.noImpacto.ToString();
        proj.dono               = G;
        proj.esseGolpe          = this;
        addView = true;
    }
Esempio n. 3
0
        public void ImpatoAtivo(GameObject G, PetAttackBase ativa, ImpactFeatures caracteristica, GameObject focado = null)
        {
            if (focado)
            {
                alvoProcurado = focado.transform;
            }
            else
            {
                alvoProcurado = FindBestTarget.Procure(G, new string[1] {
                    "Criature"
                });
            }

            tempoDecorrido += Time.deltaTime;
            if (!procurouAlvo)
            {
                alvoProcurado = CriaturesPerto.procureUmBomAlvo(G);
                procurouAlvo  = true;
                Debug.Log(alvoProcurado + "  esse é o alvo");
                AttackHelper(alvoProcurado, G.transform);
            }

            if (!addView)
            {
                tempoDecorrido += ativa.TempoDeMoveMin;
                AttackColliders.AdicionaOColisor(G, ativa, caracteristica, tempoDecorrido);

                MessageAgregator <MsgRequest3dSound> .Publish(new MsgRequest3dSound()
                {
                    sfxId  = ativa.SomDoGolpe,
                    sender = G.transform
                });

                addView = true;
            }

            if (tempoDecorrido < ativa.TempoDeMoveMax)
            {
                if (((int)(tempoDecorrido * 10)) % 2 == 0 && alvoProcurado)
                {
                    AttackHelper(alvoProcurado, G.transform);
                }

                ativa.DirDeREpulsao = G.transform.forward;

                if (!controle)
                {
                    controle = G.GetComponent <CharacterController>();
                }
                controle.Move(ativa.VelocidadeDeGolpe * G.transform.forward * Time.deltaTime + Vector3.down * 9.8f);
            }
        }
Esempio n. 4
0
    public void ImpactoAtivo(GameObject G, IGolpeBase ativa, CaracteristicasDeImpactoComSalto caracteristica, float colocarColisor = 0)
    {
        tempoDecorrido += Time.deltaTime;

        if (!procurouAlvo)
        {
            alvoProcurado = CriaturesPerto.procureUmBomAlvo(G);
            procurouAlvo  = true;
            // Debug.Log(alvoProcurado + "  esse é o alvo");
            AtualizadorDeImpactos.ajudaAtaque(alvoProcurado, G.transform);
            if (alvoProcurado != null)
            {
                ativa.DirDeREpulsao = (Vector3.ProjectOnPlane(alvoProcurado.position - G.transform.position, Vector3.up)).normalized;
            }

            AnimadorCriature.AnimaAtaque(G, ativa.Nome.ToString());

            /* aproveitado da geração 1 de scripts*/
            ao        = G.AddComponent <impactoAoChao>();
            ao.aoChao = caracteristica.toque.ToString();
            /* ******************* */
        }

        if (!adview && tempoDecorrido > colocarColisor)
        {
            ColisorDeGolpe.AdicionaOColisor(G, ativa, caracteristica.deImpacto, tempoDecorrido + ativa.TempoDeMoveMin);

            adview = true;
        }

        if (caracteristica.final == ImpactoAereoFinal.MaisAltoQueOAlvo)
        {
            MaisAltoQueOAlvo(G, ativa);
        }
        else
        {
            AvanceEPareAbaixo(G, ativa);
        }


        if (tempoDecorrido > ativa.TempoDeMoveMax)
        {
            nav.enabled = estavaParada;
        }
    }
Esempio n. 5
0
    void MultiplicarInsetos(GameObject G)
    {
        if (!addView && tempoDecorrido > gP.TempoDeInstancia)
        {
            CreatureManager C    = G.GetComponent <CreatureManager>();
            GameObject      G2   = GameController.g.El.retorna(C.MeuCriatureBase.NomeID);
            Vector3         pos  = Vector3.zero;
            Transform       alvo = CriaturesPerto.procureUmBomAlvo(G, 450);

            if (alvo)
            {
                G.transform.rotation = Quaternion.LookRotation(
                    Vector3.ProjectOnPlane(alvo.position - G.transform.position, Vector3.up)
                    );
            }

            for (int i = 0; i < 4; i++)
            {
                switch (i)
                {
                case 0:
                    pos = G.transform.position + G.transform.forward + 2 * G.transform.right;

                    break;

                case 1:

                    pos = G.transform.position + G.transform.forward - 2 * G.transform.right;

                    break;

                case 2:
                    pos = G.transform.position - G.transform.forward + 3 * G.transform.right;

                    break;

                case 3:
                    pos = G.transform.position - G.transform.forward - 3 * G.transform.right;
                    break;
                }

                G2 = MonoBehaviour.Instantiate(G2, new melhoraPos().novaPos(pos), G.transform.rotation) as GameObject;
                if (i == 0)
                {
                    G2.layer = 10;
                    G2.tag   = "Untagged";
                    MbComportamentoDoMultiplicado c = G2.AddComponent <MbComportamentoDoMultiplicado>();
                    c.direcaoMovimento   = pos - G.transform.position;
                    c.velocidadeProjetil = C.MeuCriatureBase.Mov.velocidadeAndando;
                    c.dono         = G;
                    c.esseGolpe    = this;
                    c.tempoDestroy = Mathf.Max(0.95f * TempoDeDestroy - TempoDeMoveMin, 1);
                    CapsuleCollider caps = G2.AddComponent <CapsuleCollider>();
                    G2.AddComponent <Rigidbody>();
                    caps.isTrigger = true;
                    if (!controle)
                    {
                        controle = G.GetComponent <CharacterController>();
                    }
                    caps.radius = 2 * controle.radius;
                    caps.height = controle.height;
                    //					print(procureUmBomAlvo(450));
                    c.alvo = alvo;
                }
                else
                {
                    MbComportamentoDoMultiplicado mC = G2.GetComponent <MbComportamentoDoMultiplicado>();
                    mC.direcaoMovimento = pos - G.transform.position;
                    mC.esseGolpe        = this;
                }
                MonoBehaviour.Destroy(
                    MonoBehaviour.Instantiate(GameController.g.El.retorna(carac.noImpacto), pos, Quaternion.identity),
                    2);
            }
            addView = true;
        }
    }
Esempio n. 6
0
    public override void UpdateGolpe(GameObject G)
    {
        tempoDecorrido += Time.deltaTime;
        if (tempoDecorrido < TempoDeMoveMax)
        {
            if (!controle)
            {
                controle = G.GetComponent <CharacterController>();
            }

            controle.Move(Vector3.up * velocidadeSubindo * Time.deltaTime);
        }

        if (tempoDecorrido > TempoDeMoveMax && !procurouAlvo)
        {
            if (!procurouAlvo)
            {
                alvoProcurado = CriaturesPerto.procureUmBomAlvo(G, 100);
            }

            if (alvoProcurado)
            {
                if (Vector3.SqrMagnitude(
                        Vector3.ProjectOnPlane(G.transform.position - alvoProcurado.position, Vector3.up)) < 25)
                {
                    alvoProcurado = null;
                }
            }

            procurouAlvo = true;

            Debug.Log("Sobre voo, alvo procurado: " + alvoProcurado);
        }

        if (tempoDecorrido > TempoDeMoveMax && tempoDecorrido < TempoDeDestroy)
        {
            //if (!procurouAlvo)
            //   alvoProcurado = CriaturesPerto.procureUmBomAlvo(G, 100);

            if (!addView)
            {
                ColisorDeGolpe.AdicionaOColisor(G, this, carac, tempoDecorrido);
                addView = true;
            }

            Vector3 dir = G.transform.forward + 0.5f * Vector3.down;


            if (alvoProcurado)
            {
                if (Vector3.ProjectOnPlane(posInicial - alvoProcurado.position, Vector3.up).sqrMagnitude > 25)
                {
                    dir = alvoProcurado.position - G.transform.position + 0.5f * Vector3.down;
                }
            }

            dir.Normalize();

            controle.Move(dir * VelocidadeDeGolpe * Time.deltaTime);
        }
    }