Beispiel #1
0
        static int GetAverageArmor(FightActor[] actors, EffectSchoolEnum type)
        {
            int specificArmor;

            switch (type)
            {
            case EffectSchoolEnum.Neutral:
                specificArmor = (int)actors.Average(x => x.Stats[PlayerFields.NeutralDamageArmor].TotalSafe);
                break;

            case EffectSchoolEnum.Earth:
                specificArmor = (int)actors.Average(x => x.Stats[PlayerFields.EarthDamageArmor].TotalSafe);
                break;

            case EffectSchoolEnum.Air:
                specificArmor = (int)actors.Average(x => x.Stats[PlayerFields.AirDamageArmor].TotalSafe);
                break;

            case EffectSchoolEnum.Water:
                specificArmor = (int)actors.Average(x => x.Stats[PlayerFields.WaterDamageArmor].TotalSafe);
                break;

            case EffectSchoolEnum.Fire:
                specificArmor = (int)actors.Average(x => x.Stats[PlayerFields.FireDamageArmor].TotalSafe);
                break;

            default:
                return(0);
            }

            return(specificArmor + (int)actors.Average(x => x.Stats[PlayerFields.GlobalDamageReduction].Total));
        }
Beispiel #2
0
        public ElementaryChallenge(int id, IFight fight)
            : base(id, fight)
        {
            BonusMin = 30;
            BonusMax = 50;

            m_element = EffectSchoolEnum.Unknown;
        }
Beispiel #3
0
 public Damage(EffectDice effect, EffectSchoolEnum school, FightActor source, Spell spell, Cell targetCell, Zone zone = null)
     : this(effect)
 {
     School     = school;
     Source     = source;
     Spell      = spell;
     TargetCell = targetCell;
     Zone       = zone;
 }
Beispiel #4
0
        public override int CalculateDamageResistance(int damage, EffectSchoolEnum type, bool critical, bool withArmor, bool poison)
        {
            var percentResistance = CalculateTotalResistances(type, true, poison);
            var fixResistance     = CalculateTotalResistances(type, false, poison);
            var armorResistance   = withArmor && !poison?CalculateArmorReduction(type) : 0;

            var result = (int)((1 - percentResistance / 100d) * (damage - armorResistance - fixResistance)) -
                         (critical ? Stats[PlayerFields.CriticalDamageReduction].Total : 0);

            return(result);
        }
        public override int CalculateDamage(int damage, EffectSchoolEnum type)
        {
            int result;

            if (this.Character.GodMode)
            {
                result = 32767;
            }
            else
            {
                result = base.CalculateDamage((this.m_isUsingWeapon ? (this.m_criticalWeaponBonus + this.Stats[PlayerFields.WeaponDamageBonus]) : 0) + damage, type);
            }
            return(result);
        }
Beispiel #6
0
        static int GetAverageFixResistance(FightActor[] actors, EffectSchoolEnum type, bool pvp)
        {
            switch (type)
            {
            case EffectSchoolEnum.Neutral:
                return
                    ((int)
                     (actors.Average(x => x.Stats[PlayerFields.NeutralElementReduction].Total) +
                      (pvp ? actors.Average(x => x.Stats[PlayerFields.PvpNeutralElementReduction].Total) : 0) +
                      actors.Average(x => x.Stats[PlayerFields.PhysicalDamageReduction].Total)));

            case EffectSchoolEnum.Earth:
                return
                    ((int)
                     (actors.Average(x => x.Stats[PlayerFields.EarthElementReduction].Total) +
                      (pvp ? actors.Average(x => x.Stats[PlayerFields.PvpEarthElementReduction].Total) : 0) +
                      actors.Average(x => x.Stats[PlayerFields.PhysicalDamageReduction].Total)));

            case EffectSchoolEnum.Air:
                return
                    ((int)
                     (actors.Average(x => x.Stats[PlayerFields.AirElementReduction].Total) +
                      (pvp ? actors.Average(x => x.Stats[PlayerFields.PvpAirElementReduction].Total) : 0) +
                      actors.Average(x => x.Stats[PlayerFields.MagicDamageReduction].Total)));

            case EffectSchoolEnum.Water:
                return
                    ((int)
                     (actors.Average(x => x.Stats[PlayerFields.WaterElementReduction].Total) +
                      (pvp ? actors.Average(x => x.Stats[PlayerFields.PvpWaterElementReduction].Total) : 0) +
                      actors.Average(x => x.Stats[PlayerFields.MagicDamageReduction].Total)));

            case EffectSchoolEnum.Fire:
                return
                    ((int)
                     (actors.Average(x => x.Stats[PlayerFields.FireElementReduction].Total) +
                      (pvp ? actors.Average(x => x.Stats[PlayerFields.PvpFireElementReduction].Total) : 0) +
                      actors.Average(x => x.Stats[PlayerFields.MagicDamageReduction].Total)));

            default:
                return(0);
            }
        }
Beispiel #7
0
        void OnBeforeDamageInflicted(FightActor fighter, Damage damage)
        {
            if (!(damage.Source is CharacterFighter))
            {
                return;
            }

            if (damage.ReflectedDamages)
            {
                return;
            }

            if (m_element == EffectSchoolEnum.Unknown)
            {
                m_element = damage.School;
            }
            else if (m_element != damage.School)
            {
                UpdateStatus(ChallengeStatusEnum.FAILED, damage.Source);
            }
        }
Beispiel #8
0
        static int GetAveragePercentResistance(FightActor[] actors, EffectSchoolEnum type, bool pvp)
        {
            switch (type)
            {
            case EffectSchoolEnum.Neutral:
                return
                    ((int)
                     (actors.Average(x => x.Stats[PlayerFields.NeutralResistPercent].Total) +
                      (pvp ? actors.Average(x => x.Stats[PlayerFields.PvpNeutralResistPercent].Total) : 0)));

            case EffectSchoolEnum.Earth:
                return
                    ((int)
                     (actors.Average(x => x.Stats[PlayerFields.EarthResistPercent].Total) +
                      (pvp ? actors.Average(x => x.Stats[PlayerFields.PvpEarthResistPercent].Total) : 0)));

            case EffectSchoolEnum.Air:
                return
                    ((int)
                     (actors.Average(x => x.Stats[PlayerFields.AirResistPercent].Total) +
                      (pvp ? actors.Average(x => x.Stats[PlayerFields.PvpAirResistPercent].Total) : 0)));

            case EffectSchoolEnum.Water:
                return
                    ((int)
                     (actors.Average(x => x.Stats[PlayerFields.WaterResistPercent].Total) +
                      (pvp ? actors.Average(x => x.Stats[PlayerFields.PvpWaterResistPercent].Total) : 0)));

            case EffectSchoolEnum.Fire:
                return
                    ((int)
                     (actors.Average(x => x.Stats[PlayerFields.FireResistPercent].Total) +
                      (pvp ? actors.Average(x => x.Stats[PlayerFields.PvpFireResistPercent].Total) : 0)));

            default:
                return(0);
            }
        }
 public Damage(EffectDice effect, EffectSchoolEnum school, FightActor source, Spell spell) : this(effect)
 {
     this.School = school;
     this.Source = source;
     this.Spell  = spell;
 }
Beispiel #10
0
        private int GetAveragePercentResistance(FightActor[] actors, EffectSchoolEnum type, bool pvp)
        {
            int result;

            switch (type)
            {
            case EffectSchoolEnum.Neutral:
            {
                int arg_77_0 =
                    (int)actors.Average((FightActor x) => x.Stats[PlayerFields.NeutralResistPercent].Total);
                int arg_77_1;
                if (!pvp)
                {
                    arg_77_1 = (int)0.0;
                }
                else
                {
                    arg_77_1 =
                        (int)actors.Average((FightActor x) => x.Stats[PlayerFields.PvpNeutralResistPercent].Total);
                }
                result = arg_77_0 + arg_77_1;
                break;
            }

            case EffectSchoolEnum.Earth:
            {
                int arg_D3_0 =
                    (int)actors.Average((FightActor x) => x.Stats[PlayerFields.EarthResistPercent].Total);
                int arg_D3_1;
                if (!pvp)
                {
                    arg_D3_1 = (int)0.0;
                }
                else
                {
                    arg_D3_1 =
                        (int)actors.Average((FightActor x) => x.Stats[PlayerFields.PvpEarthResistPercent].Total);
                }
                result = arg_D3_0 + arg_D3_1;
                break;
            }

            case EffectSchoolEnum.Water:
            {
                int arg_12F_0 =
                    (int)actors.Average((FightActor x) => x.Stats[PlayerFields.WaterResistPercent].Total);
                int arg_12F_1;
                if (!pvp)
                {
                    arg_12F_1 = (int)0.0;
                }
                else
                {
                    arg_12F_1 =
                        (int)actors.Average((FightActor x) => x.Stats[PlayerFields.PvpWaterResistPercent].Total);
                }
                result = arg_12F_0 + arg_12F_1;
                break;
            }

            case EffectSchoolEnum.Air:
            {
                int arg_18B_0 = (int)actors.Average((FightActor x) => x.Stats[PlayerFields.AirResistPercent].Total);
                int arg_18B_1;
                if (!pvp)
                {
                    arg_18B_1 = (int)0.0;
                }
                else
                {
                    arg_18B_1 =
                        (int)actors.Average((FightActor x) => x.Stats[PlayerFields.PvpAirResistPercent].Total);
                }
                result = arg_18B_0 + arg_18B_1;
                break;
            }

            case EffectSchoolEnum.Fire:
            {
                int arg_1E4_0 =
                    (int)actors.Average((FightActor x) => x.Stats[PlayerFields.FireResistPercent].Total);
                int arg_1E4_1;
                if (!pvp)
                {
                    arg_1E4_1 = (int)0.0;
                }
                else
                {
                    arg_1E4_1 =
                        (int)actors.Average((FightActor x) => x.Stats[PlayerFields.PvpFireResistPercent].Total);
                }
                result = arg_1E4_0 + arg_1E4_1;
                break;
            }

            default:
                result = 0;
                break;
            }
            return(result);
        }
Beispiel #11
0
        private int GetAverageFixResistance(FightActor[] actors, EffectSchoolEnum type, bool pvp)
        {
            int result;

            switch (type)
            {
            case EffectSchoolEnum.Neutral:
            {
                double arg_77_0 =
                    actors.Average((FightActor x) => x.Stats[PlayerFields.NeutralElementReduction].Total);
                double arg_77_1;
                if (!pvp)
                {
                    arg_77_1 = 0.0;
                }
                else
                {
                    arg_77_1 =
                        actors.Average((FightActor x) => x.Stats[PlayerFields.PvpNeutralElementReduction].Total);
                }
                result =
                    (int)
                    (arg_77_0 + arg_77_1 +
                     actors.Average((FightActor x) => x.Stats[PlayerFields.PhysicalDamageReduction].Total));
                break;
            }

            case EffectSchoolEnum.Earth:
            {
                double arg_F7_0 = actors.Average((FightActor x) => x.Stats[PlayerFields.EarthElementReduction].Total);
                double arg_F7_1;
                if (!pvp)
                {
                    arg_F7_1 = 0.0;
                }
                else
                {
                    arg_F7_1 = actors.Average((FightActor x) => x.Stats[PlayerFields.PvpEarthElementReduction].Total);
                }
                result =
                    (int)
                    (arg_F7_0 + arg_F7_1 +
                     actors.Average((FightActor x) => x.Stats[PlayerFields.PhysicalDamageReduction].Total));
                break;
            }

            case EffectSchoolEnum.Water:
            {
                double arg_177_0 =
                    actors.Average((FightActor x) => x.Stats[PlayerFields.WaterElementReduction].Total);
                double arg_177_1;
                if (!pvp)
                {
                    arg_177_1 = 0.0;
                }
                else
                {
                    arg_177_1 =
                        actors.Average((FightActor x) => x.Stats[PlayerFields.PvpWaterElementReduction].Total);
                }
                result =
                    (int)
                    (arg_177_0 + arg_177_1 +
                     actors.Average((FightActor x) => x.Stats[PlayerFields.MagicDamageReduction].Total));
                break;
            }

            case EffectSchoolEnum.Air:
            {
                double arg_1F7_0 = actors.Average((FightActor x) => x.Stats[PlayerFields.AirElementReduction].Total);
                double arg_1F7_1;
                if (!pvp)
                {
                    arg_1F7_1 = 0.0;
                }
                else
                {
                    arg_1F7_1 = actors.Average((FightActor x) => x.Stats[PlayerFields.PvpAirElementReduction].Total);
                }
                result =
                    (int)
                    (arg_1F7_0 + arg_1F7_1 +
                     actors.Average((FightActor x) => x.Stats[PlayerFields.MagicDamageReduction].Total));
                break;
            }

            case EffectSchoolEnum.Fire:
            {
                double arg_274_0 = actors.Average((FightActor x) => x.Stats[PlayerFields.FireElementReduction].Total);
                double arg_274_1;
                if (!pvp)
                {
                    arg_274_1 = 0.0;
                }
                else
                {
                    arg_274_1 = actors.Average((FightActor x) => x.Stats[PlayerFields.PvpFireElementReduction].Total);
                }
                result =
                    (int)
                    (arg_274_0 + arg_274_1 +
                     actors.Average((FightActor x) => x.Stats[PlayerFields.MagicDamageReduction].Total));
                break;
            }

            default:
                result = 0;
                break;
            }
            return(result);
        }
Beispiel #12
0
 void OnLifePointsChanged(FightActor fighter, int delta, int shieldDamages, int permanentDamages, FightActor from, EffectSchoolEnum school)
 {
     if (delta > 0)
     {
         UpdateStatus(ChallengeStatusEnum.FAILED, fighter);
     }
 }