示例#1
0
        public static bool CanStartAttack(PetBase meuCriatureBase)
        {
            PetAtributes     A   = meuCriatureBase.PetFeat.meusAtributos;
            PetAttackManager ggg = meuCriatureBase.GerenteDeGolpes;
            PetAttackBase    gg  = ggg.meusGolpes[ggg.golpeEscolhido];

            if (
                //gg.UltimoUso + gg.TempoDeReuso < Time.time
                meuCriatureBase.StManager.VerifyStaminaAction() &&
                A.PE.Corrente >= gg.CustoPE)
            {
                A.PE.Corrente -= gg.CustoPE;
                //gg.UltimoUso = Time.time;
                meuCriatureBase.StManager.ConsumeStamina((uint)gg.CustoDeStamina);

                //AplicadorDeGolpe aplG = gameObject.AddComponent<AplicadorDeGolpe>();

                //aplG.esseGolpe = gg;

                //GameController.g.HudM.AtualizaDadosDaHudVida(false);

                //if (GameController.g.estaEmLuta)
                //    GameController.g.HudM.AtualizaDadosDaHudVida(true);

                // if(!GameController.g.estaEmLuta)
                //   //GameController.g.HudM.AtualizaHudHeroi(meuCriatureBase);

                return(true);
            }
            else
            {
                return(false);
            }
        }
示例#2
0
        public PetAttackBase[] GolpesAtivos(int nivel, PetAttackDb[] listaGolpes)
        {
            List <PetAttackDb> L = new List <PetAttackDb>();
            int i = 0;

            //int N = -1;
            while (i < listaGolpes.Length)
            {
                if (listaGolpes[i].NivelDoGolpe <= nivel && listaGolpes[i].NivelDoGolpe > -1)
                {
                    if (L.Count < 4)
                    {
                        L.Add(listaGolpes[i]);
                    }
                    else
                    {
                        L[0] = L[1];
                        L[1] = L[2];
                        L[2] = L[3];
                        L[3] = listaGolpes[i];
                    }
                }
                i++;
            }

            PetAttackBase[] Y = new PetAttackBase[L.Count];
            for (i = 0; i < L.Count; i++)
            {
                Y[i] = AttackFactory.GetAttack(L[i].Nome);
            }
            return(Y);
        }
示例#3
0
 public void StartDamageState(PetAttackBase golpe)
 {
     esseGolpe    = golpe;
     posInicial   = controle.transform.position;
     alturaDoDano = controle.transform.position.y;
     tempoDeDano  = 0;
 }
示例#4
0
        static void CalculoA(float multiplicador, PetAttackBase golpe, PetAttackDb golpePersonagem, int potenciaDoAtacante, PetManager doAtacado)
        {
            int dano = Mathf.Abs(
                Mathf.RoundToInt(
                    multiplicador * (golpe.PotenciaCorrente
                                     + golpePersonagem.ModPersonagem
                                     + potenciaDoAtacante)
                    ));

            potenciaDoAtacante = dano;

            PetAtributes aDoAtacado = doAtacado.MeuCriatureBase.PetFeat.meusAtributos;

            int defesa = Mathf.RoundToInt(aDoAtacado.Defesa.Corrente * Random.Range(0.85f, 1));

            if (defesa < 0.75f * dano)
            {
                dano = (dano - defesa >= 1) ? dano - defesa : 1;
            }
            else
            {
                dano = (int)(0.25f * dano) >= 1 ? Mathf.Max((int)(0.25f * dano * Random.Range(0.9f, 1.15f)), 1) : 1;
            }



            AplicaCalculoComVIsaoDeDano(doAtacado, golpe, aDoAtacado, multiplicador, dano, defesa, potenciaDoAtacante);
        }
示例#5
0
        void AvanceEPareAbaixo(GameObject G, PetAttackBase ativa)
        {
            float distanciaDeParada = 5.75f;
            float velocidadeAvante  = ativa.VelocidadeDeGolpe;

            Vector3 V = posInicial + 10 * ativa.DirDeREpulsao;
            Vector3 project;

            if (alvoProcurado)
            {
                V = alvoProcurado.position;
                // project = (Vector3.ProjectOnPlane(G.transform.position - V, Vector3.up));
                //  if (Vector3.Dot(project,G.transform.forward)>0)
                //    AtualizadorDeImpactos.ajudaAtaque(alvo, G.transform);
            }

            project = (Vector3.ProjectOnPlane(G.transform.position - V, Vector3.up));

            if (Vector3.Dot(project, G.transform.forward) > 0)
            {
                G.transform.rotation = Quaternion.LookRotation(-project);
            }
            else
            {
                G.transform.rotation = Quaternion.LookRotation(ativa.DirDeREpulsao);
            }


            if ((project.magnitude > distanciaDeParada
                 &&
                 G.transform.position.y - posInicial.y < 4
                 &&
                 !alcancouOApceDaAltura)
                &&
                tempoDecorrido < ativa.TempoDeMoveMax / 2)
            {
                dirDeslocamento = (velocidadeAvante * G.transform.forward + Vector3.up * 15);
            }
            else if (project.magnitude <= distanciaDeParada)
            {
                Vector3 foco = velocidadeAvante * G.transform.forward + Vector3.down * 9.8f;
                if (alvoProcurado && Vector3.Dot(-project, G.transform.forward) > 0)
                {
                    foco = velocidadeAvante * (alvoProcurado.position - G.transform.position).normalized + 18.8f * Vector3.down;
                }

                dirDeslocamento       = Vector3.Lerp(dirDeslocamento, foco, 20 * Time.deltaTime);
                alcancouOApceDaAltura = true;
            }
            else if (G.transform.position.y - posInicial.y > 4)
            {
                alcancouOApceDaAltura = true;
            }
            else
            {
                dirDeslocamento = Vector3.Lerp(dirDeslocamento, velocidadeAvante * G.transform.forward + Vector3.down * 18.8f, 20 * Time.deltaTime);
            }

            controle.Move(dirDeslocamento * Time.deltaTime);
        }
示例#6
0
        static void CalculoB(float multiplicador, PetAttackBase golpe, PetAttackDb golpePersonagem, int potenciaDoAtacante, PetManager doAtacado)
        {
            PetAtributes aDoAtacado = doAtacado.MeuCriatureBase.PetFeat.meusAtributos;

            int defesa = Mathf.RoundToInt(aDoAtacado.Defesa.Corrente * Random.Range(0.85f, 1));
            int dano   = (int)(multiplicador * (golpe.PotenciaCorrente + golpePersonagem.ModPersonagem + potenciaDoAtacante / defesa));

            AplicaCalculoComVIsaoDeDano(doAtacado, golpe, aDoAtacado, multiplicador, dano, defesa, potenciaDoAtacante);
        }
示例#7
0
        public static void AplicaDano(PetManager doAtacado, GameObject atacante, PetAttackBase golpe)
        {
            //Animator animatorDoAtacado = doAtacado.GetComponent<Animator>();
            //EmEstadoDeDano(animatorDoAtacado, doAtacado);

            CalculaDano(doAtacado, atacante, golpe);

            InsereEstouEmDano(doAtacado.gameObject, golpe, atacante);

            VerificaVida(atacante, doAtacado);
        }
示例#8
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);
            }
        }
示例#9
0
        public void StartAttack(PetAttackBase esseGolpe, float tempoDeInstancia, GameObject focado)
        {
            this.focado    = focado;
            this.esseGolpe = esseGolpe;
            tempoDecorrido = 0.0f;
            esseGolpe.IniciaGolpe(gameObject);
            tempoDecorrido -= tempoDeInstancia;


            //GolpePersonagem.RetornaGolpePersonagem(gameObject, esseGolpe.Nome).TempoDeInstancia;
            //gerente = GetComponent<CreatureManager>();
            //ParaliseNoTempo();
        }
示例#10
0
        public static void AdicionaOColisor(GameObject G,
                                            PetAttackBase golpeAtivo,
                                            ImpactFeatures caracteristica,
                                            float tempoDecorrido)
        {
            GameObject view = Resources.Load <GameObject>("DamageColliders/" + caracteristica.nomeTrail.ToString());
            //GameObject view = GameController.g.El.retornaColisor(caracteristica.nomeTrail);
            //		print(nomeColisor);
            colisor C = GetCollider(G, golpeAtivo.Nome);// = new colisor();

            GameObject view2 = (GameObject)MonoBehaviour.Instantiate(view, C.deslColisor, Quaternion.identity);

            view2.transform.localRotation = view.transform.rotation;


            if (caracteristica.parentearNoOsso)
            {
                view2.transform.parent = G.transform.Find(C.osso).transform;
            }
            else
            {
                view2.transform.parent = G.transform;
            }

            view2.transform.localPosition             = C.deslTrail;
            view2.transform.localRotation             = view.transform.rotation;
            view2.GetComponent <BoxCollider>().center = C.deslColisor;
            view2.name = "colisor" + golpeAtivo.Nome.ToString();
            view2.transform.localScale *= (golpeAtivo.ColisorScale * C.ColisorScale);


            /*
             *      PARA DESTUIR O COLISOR .
             *      QUANDO O GOLPE ERA INTERROMPIDO
             *      O COLISOR PERMANECIA NO PERSONAGEM
             */
            MonoBehaviour.Destroy(view2, golpeAtivo.TempoDeDestroy - tempoDecorrido);


            /*************************************************************/


            DamageCollider proj = view2.AddComponent <DamageCollider>();

            proj.velocidadeProjetil = 0f;
            proj.noImpacto          = caracteristica.noImpacto;
            proj.dono      = G;
            proj.esseGolpe = golpeAtivo;
            //			proj.forcaDoDano = 25f;
            //addView = true;
        }
示例#11
0
        //public static void EmEstadoDeDano(Animator animatorDoAtacado, PetManager doAtacado)
        //{
        //    Debug.LogError("não sei o que fazer com isso");
        //    //doAtacado.MudaParaEstouEmDano();
        //    //Transform T = doAtacado.transform;

        //    //  doAtacado.MudaEmDano();

        //    animatorDoAtacado.Play("dano2");
        //    animatorDoAtacado.SetBool("dano1", true);
        //    animatorDoAtacado.Play("dano1");
        //}

        public static void InsereEstouEmDano(GameObject doAtacado, PetAttackBase golpe, GameObject atacante)
        {
            MessageAgregator <MsgEnterInDamageState> .Publish(new MsgEnterInDamageState()
            {
                oAtacado = doAtacado.gameObject,
                golpe    = golpe,
                atacante = atacante
            });

            //EstouEmDano eED = doAtacado.gameObject.AddComponent<EstouEmDano>();
            //eED.esseGolpe = golpe;
            //eED.animator = animatorDoAtacado;
            //eED.gerente = doAtacado;
        }
示例#12
0
        static void AplicaCalculoComVIsaoDeDano(PetManager doAtacado,
                                                PetAttackBase golpe,
                                                PetAtributes aDoAtacado,
                                                float multiplicador,
                                                int dano,
                                                int defesa,
                                                int potenciaDoAtacante)
        {
            AplicaCalculoDoDano(aDoAtacado, dano);

            Debug.Log("O dano do Golpe e " + dano + " O nome do golpe e " + golpe.Nome + " o multiplicador e" + multiplicador
                      + " A defesa do inimigo é " + defesa
                      + " A potencia original é " + potenciaDoAtacante
                      + " A potencia do Golpe é " + golpe.PotenciaCorrente);

            AplicaVisaoDeDano(doAtacado, dano, multiplicador);
        }
示例#13
0
        public static void VerificaDano(GameObject atacado, GameObject atacante, PetAttackBase golpe)
        {
            if (atacado.tag == "eventoComGolpe" /*&& !GameController.g.estaEmLuta*/)
            {
                Debug.LogWarning("Evento com golpe removido, necessário refazer, condicional de esta em luta removido");
                //atacado.GetComponent<EventoComGolpe>().DisparaEvento(golpe.Nome);
            }

            PetManager GdC = atacado.GetComponent <PetManager>();

            if (GdC /*&& !GameController.g.UsandoItemOuTrocandoCriature*/)
            {
                Debug.Log("Um condicional para impedir dano em uso de item foi retirado");
                if (GdC.MeuCriatureBase.PetFeat.meusAtributos.PV.Corrente > 0)
                {
                    AplicaDano(GdC, atacante, golpe);
                }
            }
        }
示例#14
0
        public static void AplicaProjetil(GameObject G, PetAttackBase ativa, ProjetilFeatures carac)
        {
            PetAttackDb golpeP = PetAttackDb.RetornaGolpePersonagem(G, ativa.Nome);

            if (golpeP.TempoDeInstancia > 0)
            {
                carac.posInicial = EmissionPosition.Get(G, ativa.Nome);
            }

            GameObject KY = InstanceSupport.InstancieEDestrua(ativa.Nome, carac.posInicial, ativa.DirDeREpulsao, ativa.TempoDeDestroy);

            DamageColliderBase proj = DamageColliderFactory.Get(KY, carac.tipo);

            #region suprimido
            //switch (carac.tipo)
            //{
            //    case TipoDoProjetil.rigido:
            //        proj = KY.AddComponent<ColisorDeDanoRigido>();
            //    break;
            //    case TipoDoProjetil.basico:
            //        proj = KY.AddComponent<ColisorDeDano>();
            //    break;
            //    case TipoDoProjetil.statusExpansivel:
            //        proj = KY.AddComponent<ColisorDeStatusExpansivel>();
            //    break;
            //    case TipoDoProjetil.direcional:
            //        ColisorDeDanoDirecional projD = KY.AddComponent<ColisorDeDanoDirecional>();
            //        projD.alvo = (G.name == "CriatureAtivo")
            //            ? ((GameController.g.InimigoAtivo != null) ? GameController.g.InimigoAtivo.gameObject : null)
            //            : GameController.g.Manager.CriatureAtivo.gameObject;
            //        proj = projD;
            //    break;
            //}
            #endregion

            proj.velocidadeProjetil = ativa.VelocidadeDeGolpe;
            proj.noImpacto          = carac.noImpacto;
            proj.dono      = G;
            proj.esseGolpe = ativa;
        }
示例#15
0
        static void CalculaDano(PetManager doAtacado, GameObject atacante, PetAttackBase golpe)
        {
            float multiplicador = 1;

            for (int i = 0; i < doAtacado.MeuCriatureBase.PetFeat.contraTipos.Length; i++)
            {
                if (golpe.Tipo.ToString() == doAtacado.MeuCriatureBase.PetFeat.contraTipos[i].Nome)
                {
                    multiplicador *= doAtacado.MeuCriatureBase.PetFeat.contraTipos[i].Mod;
                }
            }

            PetBase      cDoAtacante = atacante.GetComponent <PetManager>().MeuCriatureBase;
            PetAtributes A           = cDoAtacante.PetFeat.meusAtributos;

            int potenciaDoAtacante = (golpe.Caracteristica == AttackDiferentialId.colisao)
                ?
                                     Mathf.RoundToInt(A.Ataque.Minimo + (A.Ataque.Corrente - A.Ataque.Minimo) * Random.Range(0.85f, 1))
                :
                                     Mathf.RoundToInt(A.Poder.Minimo + (A.Poder.Corrente - A.Poder.Minimo) * Random.Range(0.85f, 1));

            int numStatus = StatusTemporarioBase.ContemStatus(StatusType.fraco, cDoAtacante);

            if (numStatus > -1)
            {
                potenciaDoAtacante = (int)Mathf.Max(1 / cDoAtacante.StatusTemporarios[numStatus].Quantificador * potenciaDoAtacante, (A.Ataque.Minimo + A.Poder.Minimo) / 2);
                golpe.ModCorrente  = -(int)cDoAtacante.StatusTemporarios[numStatus].Quantificador;
            }
            else
            {
                golpe.ModCorrente = 0;
            }

            PetAttackDb golpePersonagem = cDoAtacante.GerenteDeGolpes.ProcuraGolpeNaLista(cDoAtacante.NomeID, golpe.Nome);

            CalculoC(multiplicador, golpe, golpePersonagem, potenciaDoAtacante, doAtacado, cDoAtacante);

            golpe.VerificaAplicaStatus(cDoAtacante, doAtacado);
        }
示例#16
0
        static void CalculoC(
            float multiplicador,
            PetAttackBase golpe,
            PetAttackDb golpePersonagem,
            int potenciaDoAtacante,
            PetManager doAtacado,
            PetBase cDoAtacado)
        {
            PetAtributes aDoAtacado = doAtacado.MeuCriatureBase.PetFeat.meusAtributos;
            float        rd         = Random.Range(0.85f, 1);
            int          level      = cDoAtacado.PetFeat.mNivel.Nivel;
            float        STAB       = 1;

            if (cDoAtacado.PetFeat.TemOTipo(golpe.Tipo))
            {
                STAB = 1.5f;
            }
            Debug.Log("modificador de potencia para esse golpe é " + golpePersonagem.ModPersonagem);
            //int  dano = (int)((((((((2 * level / 5) + 2) * potenciaDoAtacante* 20*(golpe.PotenciaCorrente+golpePersonagem.ModPersonagem) )/ aDoAtacado.Defesa.Corrente)/ 50) +2) *STAB * multiplicador) *rd / 100);
            int dano = (int)(((2 * level) * potenciaDoAtacante * (golpe.PotenciaCorrente + golpePersonagem.ModPersonagem) / (45f * aDoAtacado.Defesa.Corrente + 250) + 2) * STAB * multiplicador * rd);

            AplicaCalculoComVIsaoDeDano(doAtacado, golpe, aDoAtacado, multiplicador, dano, aDoAtacado.Defesa.Corrente, potenciaDoAtacante);
        }
示例#17
0
        public void ImpactoAtivo(
            GameObject G,
            PetAttackBase ativa,
            AeroImpactFeatures caracteristica,
            float colocarColisor = 0,
            GameObject focado    = null)
        {
            tempoDecorrido += Time.deltaTime;

            if (!procurouAlvo)
            {
                if (focado)
                {
                    alvoProcurado = focado.transform;
                }
                else
                {
                    alvoProcurado = FindBestTarget.Procure(G, new string[1] {
                        "Criature"
                    });                                                                     //CriaturesPerto.procureUmBomAlvo(G);
                }
                procurouAlvo = true;
                // Debug.Log(alvoProcurado + "  esse é o alvo");
                StandardImpactUpdate.AttackHelper(alvoProcurado, G.transform);
                if (alvoProcurado != null)
                {
                    ativa.DirDeREpulsao = (Vector3.ProjectOnPlane(alvoProcurado.position - G.transform.position, Vector3.up)).normalized;
                }

                MessageAgregator <MsgRequestAtkAnimation> .Publish(new MsgRequestAtkAnimation()
                {
                    gameObject = G,
                    nomeAnima  = ativa.Nome.ToString()
                });

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

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

                /* aproveitado da geração 1 de scripts atualizado no 2021*/
                ao               = G.AddComponent <OnFloorImpactParticles>();
                ao.aoChao        = caracteristica.toque.ToString();
                ao.onGroundSound = caracteristica.onTouchGroundSound;
                /* ******************* */
            }

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

                adview = true;
            }

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


            //if (tempoDecorrido > ativa.TempoDeMoveMax)
            //    nav.enabled = estavaParada;
        }
示例#18
0
        private void MaisAltoQueOAlvo(GameObject G, PetAttackBase ativa)
        {
            Vector3 pontoAlvo = 3 * Vector3.up;

            if (alvoProcurado != null)
            {
                pontoAlvo += alvoProcurado.position + 3 * Vector3.up + (G.transform.position - alvoProcurado.position).normalized;
            }


            Vector3 direcaoDoSalto = alvoProcurado == null
                ? G.transform.forward + 0.6f * Vector3.up
                : Vector3.Dot(
                Vector3.ProjectOnPlane(alvoProcurado.position - G.transform.position, Vector3.up),
                ativa.DirDeREpulsao) > 0 ? pontoAlvo - G.transform.position : G.transform.forward;

            //Debug.Log(Vector3.ProjectOnPlane(pontoAlvo - G.transform.position, Vector3.up).magnitude);

            if ((Vector3.ProjectOnPlane(pontoAlvo - G.transform.position, Vector3.up).magnitude < 2f
                 &&
                 Vector3.ProjectOnPlane(posInicial - G.transform.position, Vector3.up).sqrMagnitude > 25f)
                ||
                Mathf.Abs(posInicial.y - G.transform.position.y) > 4
                )
            {
                alcancouOApceDaAltura = true;
                direcaoDoSalto        = Vector3.ProjectOnPlane(direcaoDoSalto, Vector3.up);
            }



            if (Vector3.ProjectOnPlane(posInicial - G.transform.position, Vector3.up).sqrMagnitude > 25f /* distancia ao quadrado*/ &&
                (alcancouOApceDaAltura || tempoDecorrido > 0.75f * ativa.TempoDeMoveMax))
            {
                Vector3 descendo = Vector3.down;
                if (alvoProcurado != null)
                {
                    if (Vector3.Dot(
                            Vector3.ProjectOnPlane(alvoProcurado.position - G.transform.position, Vector3.up),
                            ativa.DirDeREpulsao) < 0)
                    {
                        descendo = descendo + ativa.DirDeREpulsao;
                    }
                    else
                    {
                        float vel = 0.75f;
                        if (G.name == "CriatureAtivo")
                        {
                            vel = 0.1f;
                        }

                        descendo = descendo + vel * (alvoProcurado.position - G.transform.position);
                    }
                    descendo.Normalize();

                    G.transform.rotation = Quaternion.LookRotation(Vector3.ProjectOnPlane(descendo, Vector3.up));
                }
                //Debug.DrawRay(G.transform.position, descendo * ativa.VelocidadeDeGolpe, Color.green, 10);
                controle.Move(descendo * ativa.VelocidadeDeGolpe * Time.deltaTime);
            }
            else
            {
                //Debug.DrawRay(G.transform.position, direcaoDoSalto.normalized * ativa.VelocidadeDeGolpe, Color.yellow, 10);
                controle.Move(direcaoDoSalto.normalized * Time.deltaTime * ativa.VelocidadeDeGolpe);
            }
        }