Esempio n. 1
0
        public override int ApplyEffect(ref int DamageValue, EffectCast DamageInfos = null)
        {
            int pas = CastInfos.Value1;
            int val = CastInfos.Value2;
            int nbr = (int)Math.Floor((double)Target.UsedAP / (double)pas);

            DamageValue = val * nbr;
            //Poison Paralysant
            if (CastInfos.SpellId == 200)
            {
                int inte = CastInfos.Caster.Stats.GetTotal(EffectEnum.AddIntelligence);
                if (inte < 0)
                {
                    inte = 0;
                }
                int pdom = CastInfos.Caster.Stats.GetTotal(EffectEnum.AddDamagePercent);
                if (pdom < 0)
                {
                    pdom = 0;
                }
                // on applique le boost
                // Ancienne formule : dgt = (int)(((100+inte+pdom)/100) *
                // dgt);
                DamageValue = (int)(((100 + inte + pdom) / 100) * DamageValue * 1.5);
            }

            return(EffectDamage.ApplyDamages(this.CastInfos, this.Target, ref DamageValue));
        }
Esempio n. 2
0
        public static int ApplyPushBackDamages(EffectCast CastInfos, Fighter Target, int Length, int CurrentLength)
        {
            int DamageCoef;

            if (Target.States.HasState(FighterStateEnum.STATE_MAXIMIZE_EFFECTS))
            {
                DamageCoef = 7;
            }
            else if (Target.States.HasState(FighterStateEnum.STATE_MINIMIZE_EFFECTS))
            {
                DamageCoef = 4;
            }
            else
            {
                DamageCoef = EffectPush.RANDOM_PUSHDAMAGE.Next(4, 7);
            }

            double LevelCoef = CastInfos.Caster.Level / 50;

            if (LevelCoef < 0.1)
            {
                LevelCoef = 0.1;
            }
            int DamageValue = (int)Math.Floor(DamageCoef * LevelCoef) * (Length - CurrentLength + 1);

            var SubInfos = new EffectCast(EffectEnum.DamageBrut, CastInfos.SpellId, CastInfos.CellId, 0, 0, 0, 0, 0, CastInfos.Caster, null);

            return(EffectDamage.ApplyDamages(SubInfos, Target, ref DamageValue));
        }
Esempio n. 3
0
        public override int ApplyEffect(EffectCast CastInfos)
        {
            // Si > 0 alors c'est un buff
            if (CastInfos.Duration > 0)
            {
                // L'effet est un poison
                CastInfos.IsPoison = true;

                // Ajout du buff
                foreach (var Target in CastInfos.Targets)
                {
                    Target.Buffs.AddBuff(new BuffDamage(CastInfos, CastInfos.Caster));
                }
            }
            else // Dommage direct
            {
                foreach (var Target in CastInfos.Targets)
                {
                    var DamageValue = CastInfos.GenerateJet(Target);
                    if (EffectDamage.ApplyDamages(CastInfos, CastInfos.Caster, ref DamageValue) == -3)
                    {
                        return(-3);
                    }
                }
            }

            return(-1);
        }
Esempio n. 4
0
        public override int ApplyEffect(ref int DamageValue, EffectCast DamageInfos = null)
        {
            if (Target.ObjectType != FightObjectType.OBJECT_STATIC)
            {
                var TargetTeleport = new EffectCast(EffectEnum.Teleport, this.CastInfos.SpellId, this.CastInfos.Caster.CellId, 0, 0, 0, 0, 0, this.Target, null);
                var CasterTeleport = new EffectCast(EffectEnum.Teleport, this.CastInfos.SpellId, this.Target.CellId, 0, 0, 0, 0, 0, this.CastInfos.Caster, null);

                this.Caster.SetCell(null);
                this.Target.SetCell(null);

                if (BuffSacrifice.Teleport.ApplyEffect(TargetTeleport) == -3)
                {
                    return(-3);
                }

                if (BuffSacrifice.Teleport.ApplyEffect(CasterTeleport) == -3)
                {
                    return(-3);
                }
            }

            if (EffectDamage.ApplyDamages(DamageInfos, this.CastInfos.Caster, ref DamageValue) == -3)
            {
                return(-3);
            }

            DamageValue = 0;

            return(base.ApplyEffect(ref DamageValue, DamageInfos));
        }
Esempio n. 5
0
        public override int ApplyEffect(ref int DamageValue, EffectCast DamageInfos = null)
        {
            //var Damage = this.CastInfos.RandomJet;

            // return EffectDamage.ApplyDamages(this.CastInfos, this.Target, ref Damage);

            int effectBase   = CastInfos.GenerateJet(Target);
            var DamageValuea = (Target.CurrentLife / 100) * effectBase;

            //DamageValuea = (-DamageValuea);
            return(EffectDamage.ApplyDamages(this.CastInfos, this.Target, ref DamageValuea));
        }
Esempio n. 6
0
        public override int ApplyEffect(EffectCast CastInfos)
        {
            // Si > 0 alors c'est un buff
            if (CastInfos.Duration > 0)
            {
                // L'effet est un poison
                CastInfos.IsPoison = true;

                // Ajout du buff
                foreach (var Target in CastInfos.Targets)
                {
                    Target.Buffs.AddBuff(new BuffDamageDropLife(CastInfos, Target));
                }
            }
            else // Dommage direct
            {
                int effectBase  = CastInfos.GenerateJet(CastInfos.Caster);
                var DamageValue = (CastInfos.Caster.CurrentLife / 100) * effectBase;
                if (EffectDamage.ApplyDamages(CastInfos, CastInfos.Caster, ref DamageValue) == -3)
                {
                    foreach (var Target in CastInfos.Targets)
                    {
                        if (EffectHeal.ApplyHeal(CastInfos, Target, DamageValue) == -3)
                        {
                            return(-3);
                        }
                    }
                    return(-3);
                }
                else
                {
                    foreach (var Target in CastInfos.Targets)
                    {
                        if (EffectHeal.ApplyHeal(CastInfos, Target, DamageValue) == -3)
                        {
                            return(-3);
                        }
                    }
                }
                //DamageValue = (-DamageValue);
            }

            return(-1);
        }
Esempio n. 7
0
        public override int ApplyEffect(EffectCast CastInfos)
        {
            foreach (var Target in CastInfos.Targets)
            {
                var DamageJet = CastInfos.GenerateJet(Target);

                if (EffectDamage.ApplyDamages(CastInfos, Target, ref DamageJet) == -3)
                {
                    return(-3);
                }

                var HealJet = DamageJet / 2;

                if (EffectHeal.ApplyHeal(CastInfos, CastInfos.Caster, HealJet) == -3)
                {
                    return(-3);
                }
            }

            return(-1);
        }
Esempio n. 8
0
        public override int ApplyEffect(ref int DamageJet, EffectCast DamageInfos = null)
        {
            //var Damage = this.CastInfos.RandomJet;

            // return EffectDamage.ApplyDamages(this.CastInfos, this.Target, ref Damage);


            int effectBase   = DamageJet;
            var DamageValuea = (Target.CurrentLife / 100) * effectBase;
            var DamageValue  = (CastInfos.Caster.CurrentLife / 100) * effectBase;

            if (EffectDamage.ApplyDamages(CastInfos, CastInfos.Caster, ref DamageValue) == -3)
            {
                EffectHeal.ApplyHeal(CastInfos, Target, DamageValue);
                return(-3);
            }
            else
            {
                return(EffectHeal.ApplyHeal(CastInfos, Target, DamageValue));
            }

            //DamageValuea = (-DamageValuea);
        }
Esempio n. 9
0
        public override int ApplyEffect(ref int DamageValue, EffectCast DamageInfos = null)
        {
            var Damage = this.CastInfos.GenerateJet(Target);

            return(EffectDamage.ApplyDamages(this.CastInfos, this.Target, ref Damage));
        }
Esempio n. 10
0
        /// <summary>
        /// Applique les dommages.
        /// </summary>
        /// <param name="CastInfos"></param>
        /// <param name="DamageJet"></param>
        public static int ApplyDamages(EffectCast CastInfos, Fighter Target, ref int DamageJet)
        {
            //Esprit Felin
            if (CastInfos.SpellId == 108 && CastInfos.Chance > 0)
            {
                Target = CastInfos.Caster;
            }
            if (Target.States.HasState(FighterStateEnum.STATE_REFLECT_SPELL) && !CastInfos.IsPoison && ((BuffReflectSpell)Target.States.GetBuffByState(FighterStateEnum.STATE_REFLECT_SPELL)).ReflectLevel >= CastInfos.SpellLevel.Level)
            {
                Target.Fight.SendToFight(new FightGameActionMessage(106, Target.ActorId + "", Target.ActorId + ",1"));
                Target = CastInfos.Caster;
            }
            var Caster = CastInfos.Caster;

            // Perd l'invisibilité s'il inflige des dommages direct
            if (!CastInfos.IsPoison && !CastInfos.IsTrap && !CastInfos.IsReflect)
            {
                Caster.States.RemoveState(FighterStateEnum.STATE_INVISIBLE);
            }

            // Application des buffs avant calcul totaux des dommages, et verification qu'ils n'entrainent pas la fin du combat
            if (!CastInfos.IsPoison && !CastInfos.IsReflect)
            {
                if (Caster.Buffs.OnAttackPostJet(CastInfos, ref DamageJet) == -3)
                {
                    return(-3); // Fin du combat
                }
                if (Target.Buffs.OnAttackedPostJet(CastInfos, ref DamageJet) == -3)
                {
                    return(-3); // Fin du combat
                }
            }

            // Calcul jet
            Caster.CalculDamages(CastInfos.EffectType, ref DamageJet);

            // Calcul resistances
            Target.CalculReduceDamages(CastInfos.EffectType, ref DamageJet);

            // Reduction des dommages grace a l'armure
            if (DamageJet > 0)
            {
                // Si ce n'est pas des dommages direct on ne reduit pas
                if (!CastInfos.IsPoison && !CastInfos.IsReflect)
                {
                    // Calcul de l'armure par rapport a l'effet
                    var Armor = Target.CalculArmor(CastInfos.EffectType);
                    // Si il reduit un minimum
                    if (Armor != 0)
                    {
                        // XX Reduit les dommages de X
                        Target.Fight.SendToFight(new GameActionMessage((int)GameActionTypeEnum.FIGHT_ARMOR, Target.ActorId, Target.ActorId + "," + Armor));

                        // On reduit
                        DamageJet -= Armor;

                        // Si on suprimme totalement les dommages
                        if (DamageJet < 0)
                        {
                            DamageJet = 0;
                        }
                    }
                }
            }

            // Application des buffs apres le calcul totaux et l'armure
            if (!CastInfos.IsPoison && !CastInfos.IsReflect)
            {
                if (Caster.Buffs.OnAttackAfterJet(CastInfos, ref DamageJet) == -3)
                {
                    return(-3); // Fin du combat
                }
                if (Target.Buffs.OnAttackedAfterJet(CastInfos, ref DamageJet) == -3)
                {
                    return(-3); // Fin du combat
                }
            }

            // S'il subit des dommages
            if (DamageJet > 0)
            {
                // Si c'est pas un poison ou un renvoi on applique le renvoie
                if (!CastInfos.IsPoison && !CastInfos.IsReflect)
                {
                    var ReflectDamage = Target.ReflectDamage;

                    // Si du renvoi
                    if (ReflectDamage > 0)
                    {
                        Target.Fight.SendToFight(new GameActionMessage((int)EffectEnum.AddRenvoiDamage, Target.ActorId, Target.ActorId + "," + ReflectDamage));

                        // Trop de renvois
                        if (ReflectDamage > DamageJet)
                        {
                            ReflectDamage = DamageJet;
                        }

                        var SubInfos = new EffectCast(EffectEnum.DamageBrut, 0, 0, 0, 0, 0, 0, 0, Target, null);
                        SubInfos.IsReflect = true;

                        // Si le renvoi de dommage entraine la fin de combat on stop
                        if (EffectDamage.ApplyDamages(SubInfos, Caster, ref ReflectDamage) == -3)
                        {
                            return(-3);
                        }

                        // Dommage renvoyé
                        DamageJet -= ReflectDamage;
                    }
                }
            }

            // Peu pas etre en dessous de 0
            if (DamageJet < 0)
            {
                DamageJet = 0;
            }

            // Dommages superieur a la vie de la cible
            if (DamageJet > Target.Life)
            {
                DamageJet = Target.Life;
            }

            // Deduit la vie
            Target.Life -= DamageJet;

            // Enois du Packet combat subit des dommages
            Target.Fight.SendToFight(new GameActionMessage((int)GameActionTypeEnum.FIGHT_DAMAGE, Caster.ActorId, Target.ActorId + "," + (-DamageJet).ToString()));

            // Tentative de mort et fin de combat
            return(Target.TryDie(Caster.ActorId));
        }