Classe de gestion des dommages terre
Inheritance: AbstractSpellEffect
        /// <summary>
        ///
        /// </summary>
        /// <param name="castInfos"></param>
        /// <returns></returns>
        public override FightActionResultEnum ApplyEffect(CastInfos castInfos)
        {
            if (castInfos.Target == null)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            var damageJet = castInfos.RandomJet;

            castInfos.EffectType = EffectEnum.DamageBrut;

            // cannot kill the target if hes an ally
            if (castInfos.Caster.Team == castInfos.Target.Team && damageJet > castInfos.Target.Life)
            {
                damageJet = castInfos.Target.Life - 1;
            }

            if (DamageEffect.ApplyDamages(castInfos, castInfos.Target, ref damageJet) == FightActionResultEnum.RESULT_END)
            {
                return(FightActionResultEnum.RESULT_END);
            }

            var healJet = damageJet / 2;

            return(HealEffect.ApplyHeal(castInfos, castInfos.Caster, ref healJet));
        }
Example #2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="castInfos"></param>
        /// <returns></returns>
        public override FightActionResultEnum ApplyEffect(CastInfos castInfos)
        {
            var damageJet = castInfos.RandomJet;

            castInfos.EffectType = Spell.EffectEnum.DamageNeutral;

            return(DamageEffect.ApplyDamages(castInfos, castInfos.Caster, ref damageJet));
        }
Example #3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="damageValue"></param>
        /// <param name="damageInfos"></param>
        /// <returns></returns>
        public override FightActionResultEnum ApplyEffect(ref int damageValue, CastInfos damageInfos = null)
        {
            var usedAp = Target.UsedAP;

            if (usedAp < 1)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            damageInfos = new CastInfos(EffectEnum.DamageNeutral, -1, -1, -1, -1, -1, -1, -1, CastInfos.Caster, CastInfos.Target);
            var damageJet = (usedAp / CastInfos.Value1) * CastInfos.Value2;

            return(DamageEffect.ApplyDamages(damageInfos, CastInfos.Target, ref damageJet));
        }
Example #4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="castInfos"></param>
        /// <param name="target"></param>
        /// <param name="length"></param>
        /// <param name="currentLength"></param>
        /// <returns></returns>
        private static FightActionResultEnum ApplyPushBackDamages(CastInfos castInfos, AbstractFighter target, int length, int currentLength)
        {
            var    damageCoef = Util.Next(9, 17);
            double levelCoef  = castInfos.Caster.Level / 50;

            if (levelCoef < 0.1)
            {
                levelCoef = 0.1;
            }
            int damageValue = (int)Math.Floor(damageCoef * levelCoef) * (length - currentLength);
            var subInfos    = new CastInfos(EffectEnum.DamageBrut, castInfos.SpellId, castInfos.CellId, 0, 0, 0, 0, 0, castInfos.Caster, null);

            return(DamageEffect.ApplyDamages(subInfos, target, ref damageValue));
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="castInfos"></param>
        /// <returns></returns>
        public override FightActionResultEnum ApplyEffect(CastInfos castInfos)
        {
            if (castInfos.Target == null)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            if (castInfos.Target != castInfos.Caster)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            var damageInfos = new CastInfos(m_damageType, -1, -1, -1, -1, -1, -1, -1, castInfos.Caster, castInfos.Target);
            var damageJet   = (castInfos.Target.Life / 100) * castInfos.RandomJet;

            return(DamageEffect.ApplyDamages(damageInfos, damageInfos.Target, ref damageJet));
        }
Example #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="damageValue"></param>
        /// <param name="damageInfos"></param>
        /// <returns></returns>
        public override FightActionResultEnum ApplyEffect(ref int damageValue, CastInfos damageInfos = null)
        {
            //
            if (damageInfos.IsReflect || damageInfos.IsReturnedDamages || damageInfos.IsPoison)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            // mort
            if (Caster.IsFighterDead)
            {
                Target.BuffManager.RemoveBuff(this);

                return(FightActionResultEnum.RESULT_NOTHING);
            }

            var targetTeleport = new CastInfos(EffectEnum.Teleport, CastInfos.SpellId, CastInfos.Caster.Cell.Id, 0, 0, 0, 0, 0, Target, null);
            var casterTeleport = new CastInfos(EffectEnum.Teleport, CastInfos.SpellId, Target.Cell.Id, 0, 0, 0, 0, 0, CastInfos.Caster, null);

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

            if (TeleportEffect.ApplyTeleport(targetTeleport) == FightActionResultEnum.RESULT_END)
            {
                return(FightActionResultEnum.RESULT_END);
            }

            if (TeleportEffect.ApplyTeleport(casterTeleport) == FightActionResultEnum.RESULT_END)
            {
                return(FightActionResultEnum.RESULT_END);
            }

            // cancel damages
            damageValue = 0;

            var damageJet = damageInfos.RandomJet;

            damageInfos.IsReturnedDamages = true;

            return(DamageEffect.ApplyDamages(damageInfos, CastInfos.Caster, ref damageJet));
        }
Example #7
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="castInfos"></param>
        /// <returns></returns>
        public override FightActionResultEnum ApplyEffect(CastInfos castInfos)
        {
            if (castInfos.Target == null)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            var damageJet = castInfos.RandomJet;

            if (DamageEffect.ApplyDamages(castInfos, castInfos.Target, ref damageJet) == FightActionResultEnum.RESULT_END)
            {
                return(FightActionResultEnum.RESULT_END);
            }

            castInfos.EffectType = Spell.EffectEnum.DamageBrut;

            // On ne se soigne que de 50% des dégats
            var healJet = damageJet / 2;

            return(HealEffect.ApplyHeal(castInfos, castInfos.Caster, ref healJet));
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="castInfos"></param>
        /// <returns></returns>
        public override FightActionResultEnum ApplyEffect(CastInfos castInfos)
        {
            if (castInfos.Target == null)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            castInfos.EffectType = EffectEnum.DamageBrut;

            // official formulas
            var damageCoef  = (double)castInfos.RandomJet / 100;
            var maxLife     = castInfos.Caster.MaxLife;
            var percentLife = (double)castInfos.Caster.Life / castInfos.Caster.MaxLife;
            var rad         = (2 * Math.PI * (percentLife - 0.5));
            var cos         = Math.Cos(rad);
            var rate        = Math.Pow(cos + 1, 2) / 4;
            var maxDamages  = damageCoef * maxLife;
            var realDamages = (int)(rate * maxDamages);

            return(DamageEffect.ApplyDamages(castInfos, castInfos.Target, ref realDamages));
        }
Example #9
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="castInfos"></param>
        /// <returns></returns>
        public override FightActionResultEnum ApplyEffect(CastInfos castInfos)
        {
            if (castInfos.Target == null)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            // damage himself
            if (castInfos.Target == castInfos.Caster)
            {
                var damageInfos = new CastInfos(EffectEnum.DamageBrut, castInfos.SpellId, castInfos.CellId, castInfos.Value1, castInfos.Value2, castInfos.Value3, castInfos.Chance, 0, castInfos.Caster, castInfos.Target);
                var damageValue = (int)(((double)castInfos.Caster.Life / 100) * castInfos.RandomJet);

                return(DamageEffect.ApplyDamages(damageInfos, castInfos.Caster, ref damageValue));
            }

            var healInfos = new CastInfos(EffectEnum.DamageBrut, -1, -1, -1, -1, -1, -1, -1, castInfos.Caster, castInfos.Target);
            var healValue = (int)(((double)castInfos.Caster.Life / 100) * castInfos.RandomJet);

            return(HealEffect.ApplyHeal(healInfos, castInfos.Target, ref healValue));
        }
Example #10
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="damageValue"></param>
        /// <param name="damageInfos"></param>
        /// <returns></returns>
        public override FightActionResultEnum ApplyEffect(ref int damageValue, CastInfos damageInfos = null)
        {
            // cant reflect a spell himself
            if (damageInfos.Caster == Target)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            // reflect only spells
            if (damageInfos.SpellId < 1)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            // cannot reflect a spell that is higher in level
            if (damageInfos.SpellLevel > CastInfos.Value2)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            // cant reflect reflected damage or poison or a trap damage
            if (damageInfos.IsReflect || damageInfos.IsPoison || damageInfos.IsTrap)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            // cancel damage
            damageValue = 0;

            // damaged are being reflected
            damageInfos.IsReflect = true;

            // new jet for new target
            var damageJet = damageInfos.RandomJet;

            // apply damage back to the caster
            return(DamageEffect.ApplyDamages(damageInfos, damageInfos.Caster, ref damageJet));
        }
Example #11
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="castInfos"></param>
        /// <returns></returns>
        public override FightActionResultEnum ApplyEffect(CastInfos castInfos)
        {
            if (castInfos.Target == null)
            {
                return(FightActionResultEnum.RESULT_NOTHING);
            }

            // Si > 0 alors c'est un buff
            if (castInfos.Duration > 0)
            {
                // L'effet est un poison
                castInfos.IsPoison = true;

                castInfos.Target.BuffManager.AddBuff(new DamageBuff(castInfos, castInfos.Target));
            }
            else // Dommage direct
            {
                var damageValue = castInfos.RandomJet;

                return(DamageEffect.ApplyDamages(castInfos, castInfos.Target, ref damageValue));
            }

            return(FightActionResultEnum.RESULT_NOTHING);
        }
Example #12
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="CastInfos"></param>
        /// <param name="damageJet"></param>
        public static FightActionResultEnum ApplyDamages(CastInfos castInfos, AbstractFighter target, ref int damageJet)
        {
            var caster = castInfos.Caster;

            // caster stealth goes out of dealing direct damages
            if (!castInfos.IsPoison && !castInfos.IsTrap && !castInfos.IsReflect && caster.StateManager.HasState(FighterStateEnum.STATE_STEALTH))
            {
                caster.BuffManager.RemoveStealth();
            }

            // poison and reflected damages cannot triggers on hit effect
            if (!castInfos.IsPoison && !castInfos.IsReflect)
            {
                if (caster.BuffManager.OnAttackBeforeJet(castInfos, ref damageJet) == FightActionResultEnum.RESULT_END)
                {
                    return(FightActionResultEnum.RESULT_END); // check out end of fight
                }
                if (target.BuffManager.OnAttackedBeforeJet(castInfos, ref damageJet) == FightActionResultEnum.RESULT_END)
                {
                    return(FightActionResultEnum.RESULT_END); // check out end of fight
                }
            }

            // caster statistics increase damages
            caster.CalculDamages(castInfos.EffectType, ref damageJet);

            // target statistics reduce incomming damages
            target.CalculReduceDamages(castInfos.EffectType, ref damageJet);

            // target armor reduce damages
            if (damageJet > 0)
            {
                // target armor cannot reduce poison or reflect
                if (!castInfos.IsPoison && !castInfos.IsReflect)
                {
                    // Calcul de l'armure par rapport a l'effet
                    var armor = target.CalculArmor(castInfos.EffectType);

                    // if the target has some armor
                    if (armor != 0)
                    {
                        castInfos.Fight.Dispatch(WorldMessage.GAME_ACTION(GameActionTypeEnum.FIGHT_ARMOR, target.Id, target.Id + "," + armor));

                        damageJet -= armor;

                        if (damageJet < 0)
                        {
                            damageJet = 0;
                        }
                    }
                }
            }

            // poison and reflected damages cannot triggers on hit effect after jets and armor
            if (!castInfos.IsPoison && !castInfos.IsReflect)
            {
                if (caster.BuffManager.OnAttackAfterJet(castInfos, ref damageJet) == FightActionResultEnum.RESULT_END)
                {
                    return(FightActionResultEnum.RESULT_END); // check out end of fight
                }
                if (target.BuffManager.OnAttackedAfterJet(castInfos, ref damageJet) == FightActionResultEnum.RESULT_END)
                {
                    return(FightActionResultEnum.RESULT_END); // check out end of fight
                }
            }

            // check out damages after all calculations
            if (damageJet > 0)
            {
                // poison and reflected damages cannot be reflected
                if (!castInfos.IsPoison && !castInfos.IsReflect && castInfos.EffectType != EffectEnum.DamageBrut)
                {
                    var reflectDamage = target.ReflectDamage;

                    // check out if he has some reflection
                    if (reflectDamage > 0)
                    {
                        target.Fight.Dispatch(WorldMessage.GAME_ACTION(EffectEnum.AddReflectDamage, target.Id, target.Id + "," + reflectDamage));

                        // too much reflect
                        if (reflectDamage > damageJet)
                        {
                            reflectDamage = damageJet;
                        }

                        var subInfos = new CastInfos(castInfos.EffectType, 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 (DamageEffect.ApplyDamages(subInfos, caster, ref reflectDamage) == FightActionResultEnum.RESULT_END)
                        {
                            return(FightActionResultEnum.RESULT_END);
                        }

                        // Dommage renvoyé
                        damageJet -= reflectDamage;
                    }
                }
            }

            // cannot be negative
            if (damageJet < 0)
            {
                damageJet = 0;
            }

            // more damages than target life
            if (damageJet > target.Life)
            {
                damageJet = target.Life;
            }

            // recude life
            target.Life -= damageJet;

            // display damages
            castInfos.Fight.Dispatch(WorldMessage.GAME_ACTION(GameActionTypeEnum.FIGHT_DAMAGE, caster.Id, target.Id + ",-" + damageJet));

            // check out the death
            return(castInfos.Fight.TryKillFighter(target, caster));
        }
Example #13
0
        public override FightActionResultEnum ApplyEffect(ref int damageValue, CastInfos damageInfos = null)
        {
            var damageJet = CastInfos.RandomJet;

            return(DamageEffect.ApplyDamages(CastInfos, Target, ref damageJet));
        }