예제 #1
0
        public static DamageList GetDamageList(List <SL_Damage> list)
        {
            var newlist = new DamageList();

            foreach (var entry in list)
            {
                newlist.Add(entry.GetDamageType());
            }

            return(newlist);
        }
예제 #2
0
        // Token: 0x0600000F RID: 15 RVA: 0x000024CC File Offset: 0x000006CC
        public static void PreAmplifyDamage(Weapon weapon, ref DamageList _list)
        {
            bool flag = weapon == null;

            if (!flag)
            {
                bool flag2 = BehaviourManager.IsHolyWeaponMode(weapon);
                if (flag2)
                {
                    float holyWeaponConvertionRate = CustomBehaviourFormulas.GetHolyWeaponConvertionRate(weapon);
                    float totalDamage = _list.TotalDamage;
                    _list *= 1f - holyWeaponConvertionRate;
                    _list.Add(new DamageType(CustomBehaviourFormulas.GetHolyDamageType(), totalDamage * holyWeaponConvertionRate));
                }
                bool flag3 = BehaviourManager.IsBastardMode(weapon);
                if (flag3)
                {
                    _list *= 1f + CustomBehaviourFormulas.GetBastardDamageBonus(weapon);
                }
            }
        }
        public static void Postfix(CharacterStats __instance, ref DamageList _damages)
        {
            Character character = At.GetValue(typeof(CharacterStats), __instance, "m_character") as Character;
            bool      flag      = character != null;

            if (flag)
            {
                bool flag2 = SkillRequirements.CanAddBonusRageDamage(character);
                if (flag2)
                {
                    _damages *= 1f + JuggernautFormulas.GetRuthlessDamageBonus(character);
                }
                bool flag3 = SkillRequirements.CanConvertToRawDamage(character);
                if (flag3)
                {
                    float totalDamage            = _damages.TotalDamage;
                    float ruthlessRawDamageRatio = JuggernautFormulas.GetRuthlessRawDamageRatio(character);
                    _damages *= 1f - ruthlessRawDamageRatio;
                    _damages.Add(new DamageType(DamageType.Types.Raw, totalDamage * ruthlessRawDamageRatio));
                }
            }
        }
예제 #4
0
        private void OnUpdate()
        {
            var heroes = EntityManager <Hero> .Entities.Where(x => x.IsValid && !x.IsIllusion).ToList();

            DamageList.Clear();

            foreach (var target in heroes.Where(x => x.IsAlive && x.IsEnemy(Owner)).ToList())
            {
                List <BaseAbility> abilities = new List <BaseAbility>();

                var hitArcaneBolt = 0.0f;

                if (target.IsVisible)
                {
                    // AncientSeal
                    var ancientSeal = Abilities.AncientSeal;
                    if (ancientSeal.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(ancientSeal.ToString()))
                    {
                        abilities.Add(ancientSeal);
                    }

                    // Veil
                    var veil = Abilities.Veil;
                    if (veil != null && veil.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(veil.ToString()))
                    {
                        abilities.Add(veil);
                    }

                    // Ethereal
                    var ethereal = Abilities.Ethereal;
                    if (ethereal != null && ethereal.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(ethereal.ToString()))
                    {
                        abilities.Add(ethereal);
                    }

                    // Shivas
                    var shivas = Abilities.Shivas;
                    if (shivas != null && shivas.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(shivas.ToString()))
                    {
                        abilities.Add(shivas);
                    }

                    // ConcussiveShot
                    var concussiveShot = Abilities.ConcussiveShot;
                    if (concussiveShot.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(concussiveShot.ToString()) && target == concussiveShot.TargetHit)
                    {
                        abilities.Add(concussiveShot);
                    }

                    // ArcaneBolt
                    var arcaneBolt = Abilities.ArcaneBolt;
                    if (arcaneBolt.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(arcaneBolt.ToString()))
                    {
                        abilities.Add(arcaneBolt);

                        if (MultiSleeper.Sleeping($"arcanebolt_{ target.Name }"))
                        {
                            hitArcaneBolt += arcaneBolt.GetDamage(target);
                        }
                    }

                    // Dagon
                    var dagon = Abilities.Dagon;
                    if (dagon != null && dagon.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled("item_dagon_5"))
                    {
                        abilities.Add(dagon);
                    }
                }

                var damageCalculation = new Combo(abilities.ToArray());
                var damageReduction   = -DamageReduction(target, heroes);
                var damageBlock       = DamageBlock(target, heroes);

                var livingArmor = LivingArmor(target, heroes, damageCalculation.Abilities);
                var damage      = DamageHelpers.GetSpellDamage((damageCalculation.GetDamage(target) + hitArcaneBolt) + damageBlock, 0, damageReduction) - livingArmor;
                var readyDamage = DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(target, true, false) + damageBlock, 0, damageReduction) - livingArmor;
                var totalDamage = DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(target, false, false) + damageBlock, 0, damageReduction) - livingArmor;

                if (target.IsInvulnerable() || target.HasAnyModifiers(BlockModifiers))
                {
                    damage      = 0.0f;
                    readyDamage = 0.0f;
                }

                DamageList.Add(new Damage(target, damage, readyDamage, totalDamage, target.Health));
            }
        }
예제 #5
0
        private void OnUpdate()
        {
            var heroes = EntityManager <Hero> .Entities.Where(x => !x.IsIllusion && x.IsValid).ToList();

            DamageList.Clear();

            foreach (var hero in heroes.Where(x => x.IsAlive && x.IsEnemy(Owner)).ToList())
            {
                List <BaseAbility> abilities = new List <BaseAbility>();

                var damage      = 0.0f;
                var readyDamage = 0.0f;
                var totalDamage = 0.0f;

                if (hero.IsVisible)
                {
                    // Veil
                    var Veil = Main.Veil;
                    if (Veil != null && Veil.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(Veil.ToString()))
                    {
                        abilities.Add(Veil);
                    }

                    // Ethereal
                    var Ethereal = Main.Ethereal;
                    if (Ethereal != null && Ethereal.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(Ethereal.ToString()))
                    {
                        abilities.Add(Ethereal);
                    }

                    // Shivas
                    var Shivas = Main.Shivas;
                    if (Shivas != null && Shivas.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(Shivas.ToString()))
                    {
                        abilities.Add(Shivas);
                    }

                    // StaticField
                    var StaticField = Main.StaticField;
                    if (StaticField.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(StaticField.ToString()))
                    {
                        abilities.Add(StaticField);
                    }

                    // LightningBolt
                    var LightningBolt = Main.LightningBolt;
                    if (LightningBolt.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(LightningBolt.ToString()))
                    {
                        abilities.Add(LightningBolt);
                    }

                    // Dagon
                    var Dagon = Main.Dagon;
                    if (Dagon != null && Dagon.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(Dagon.ToString()))
                    {
                        abilities.Add(Dagon);
                    }

                    // ArcLightning
                    var ArcLightning = Main.ArcLightning;
                    if (ArcLightning.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(ArcLightning.ToString()))
                    {
                        abilities.Add(ArcLightning);
                    }

                    // Nimbus
                    var Nimbus = Main.Nimbus;
                    if (Nimbus.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(Nimbus.ToString()))
                    {
                        abilities.Add(Nimbus);
                    }

                    // Thundergods Wrath
                    var ThundergodsWrath = Main.ThundergodsWrath;
                    if (ThundergodsWrath.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(ThundergodsWrath.ToString()))
                    {
                        abilities.Add(ThundergodsWrath);
                    }
                }

                var damageCalculation = new Combo(abilities.ToArray());
                var damageReduction   = -DamageReduction(hero, heroes);
                var damageBlock       = DamageBlock(hero, heroes);

                damage      += DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(hero) + damageBlock, 0, damageReduction);
                readyDamage += DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(hero, true, false) + damageBlock, 0, damageReduction);
                totalDamage += DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(hero, false, false) + damageBlock, 0, damageReduction);

                damage      -= LivingArmor(hero, heroes, damageCalculation.Abilities);
                readyDamage -= LivingArmor(hero, heroes, damageCalculation.Abilities);
                totalDamage -= LivingArmor(hero, heroes, damageCalculation.Abilities);

                if (hero.HasModifier("modifier_abaddon_borrowed_time") ||
                    hero.HasModifier("modifier_templar_assassin_refraction_absorb") ||
                    hero.HasAnyModifiers("modifier_winter_wyvern_winters_curse_aura", "modifier_winter_wyvern_winters_curse") ||
                    hero.IsInvulnerable())
                {
                    damage      = 0.0f;
                    readyDamage = 0.0f;
                }

                DamageList.Add(new Damage(hero, damage, readyDamage, totalDamage, hero.Health));
            }
        }
예제 #6
0
        private void OnUpdate()
        {
            var heroes = EntityManager <Hero> .Entities.Where(x => x.IsValid && !x.IsIllusion).ToList();

            DamageList.Clear();

            foreach (var target in heroes.Where(x => x.IsAlive && x.IsEnemy(Owner)).ToList())
            {
                List <BaseAbility> magicalAbilities = new List <BaseAbility>();
                List <BaseAbility> pureAbilities    = new List <BaseAbility>();

                var damage      = 0.0f;
                var readyDamage = 0.0f;
                var totalDamage = 0.0f;

                if (target.IsVisible)
                {
                    // Veil
                    var Veil = Main.Veil;
                    if (Veil != null && Veil.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(Veil.ToString()))
                    {
                        magicalAbilities.Add(Veil);
                    }

                    // Ethereal
                    var Ethereal = Main.Ethereal;
                    if (Ethereal != null && Ethereal.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(Ethereal.ToString()))
                    {
                        magicalAbilities.Add(Ethereal);
                    }

                    // Shivas
                    var Shivas = Main.Shivas;
                    if (Shivas != null && Shivas.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(Shivas.ToString()))
                    {
                        magicalAbilities.Add(Shivas);
                    }

                    // Dagon
                    var Dagon = Main.Dagon;
                    if (Dagon != null && Dagon.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled("item_dagon_5"))
                    {
                        magicalAbilities.Add(Dagon);
                    }

                    // Impetus
                    var Impetus = Main.Impetus;
                    if (Impetus.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(Impetus.ToString()))
                    {
                        pureAbilities.Add(Impetus);
                    }
                }

                Combo[] combo           = { new Combo(magicalAbilities.ToArray()), new Combo(pureAbilities.ToArray()) };
                float[] block           = { MagicalDamageBlock(target, heroes), DamageBlock(target, heroes) };
                var     damageReduction = -DamageReduction(target, heroes);

                for (var i = 0; i < 2; i++)
                {
                    var livingArmor = LivingArmor(target, heroes, combo[i].Abilities);
                    damage      += DamageHelpers.GetSpellDamage(Math.Max(0, combo[i].GetDamage(target) + block[i]), 0, damageReduction) - livingArmor;
                    readyDamage += DamageHelpers.GetSpellDamage(Math.Max(0, combo[i].GetDamage(target, true, false) + block[i]), 0, damageReduction) - livingArmor;
                    totalDamage += DamageHelpers.GetSpellDamage(Math.Max(0, combo[i].GetDamage(target, false, false) + block[i]), 0, damageReduction) - livingArmor;
                }

                if (target.HasAnyModifiers("modifier_abaddon_borrowed_time", "modifier_item_combo_breaker_buff") ||
                    target.HasModifier("modifier_templar_assassin_refraction_absorb") ||
                    target.HasAnyModifiers("modifier_winter_wyvern_winters_curse_aura", "modifier_winter_wyvern_winters_curse") ||
                    target.IsInvulnerable())
                {
                    damage      = 0.0f;
                    readyDamage = 0.0f;
                }

                DamageList.Add(new Damage(target, damage, readyDamage, totalDamage, target.Health));
            }
        }
예제 #7
0
        private void OnUpdate()
        {
            var heroes = EntityManager <Hero> .Entities.Where(x => x.IsValid && !x.IsIllusion).ToList();

            DamageList.Clear();

            foreach (var target in heroes.Where(x => x.IsAlive && x.IsEnemy(Owner)).ToList())
            {
                List <BaseAbility> abilities   = new List <BaseAbility>();
                List <BaseAbility> abilityHook = new List <BaseAbility>();

                if (target.IsVisible)
                {
                    // Veil
                    var veil = Main.Veil;
                    if (veil != null && veil.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(veil.ToString()))
                    {
                        abilities.Add(veil);
                    }

                    // Ethereal
                    var ethereal = Main.Ethereal;
                    if (ethereal != null && ethereal.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(ethereal.ToString()))
                    {
                        abilities.Add(ethereal);
                    }

                    // Shivas
                    var shivas = Main.Shivas;
                    if (shivas != null && shivas.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(shivas.ToString()))
                    {
                        abilities.Add(shivas);
                    }

                    // hook
                    var hook = Main.Hook;
                    if (hook.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(hook.ToString()))
                    {
                        abilityHook.Add(hook);
                    }

                    // Dagon
                    var dagon = Main.Dagon;
                    if (dagon != null &&
                        dagon.Ability.IsValid &&
                        Menu.AutoKillStealToggler.Value.IsEnabled("item_dagon_5") &&
                        Extensions.ShouldCastHook(hook.GetPredictionOutput(hook.GetPredictionInput(target))))
                    {
                        abilities.Add(dagon);
                    }
                }

                Combo[] combo           = { new Combo(abilities.ToArray()), new Combo(abilityHook.ToArray()) };
                float[] block           = { MagicalDamageBlock(target, heroes), DamageBlock(target, heroes) };
                var     damageReduction = -DamageReduction(target, heroes);

                var damage      = 0.0f;
                var readyDamage = 0.0f;
                var totalDamage = 0.0f;

                for (var i = 0; i < 2; i++)
                {
                    var livingArmor = LivingArmor(target, heroes, combo[i].Abilities);
                    damage      += DamageHelpers.GetSpellDamage(Math.Max(0, combo[i].GetDamage(target) + block[i]), 0, damageReduction) - livingArmor;
                    readyDamage += DamageHelpers.GetSpellDamage(Math.Max(0, combo[i].GetDamage(target, true, false) + block[i]), 0, damageReduction) - livingArmor;
                    totalDamage += DamageHelpers.GetSpellDamage(Math.Max(0, combo[i].GetDamage(target, false, false) + block[i]), 0, damageReduction) - livingArmor;
                }

                if (target.IsInvulnerable() || target.HasAnyModifiers(BlockModifiers))
                {
                    damage      = 0.0f;
                    readyDamage = 0.0f;
                }

                DamageList.Add(new Damage(target, damage, readyDamage, totalDamage, target.Health));
            }
        }
예제 #8
0
        static bool Prefix(ItemDetailsDisplay __instance)
        {
            int _index = 0;

            if ((bool)(UnityEngine.Object)__instance.m_lastItem && __instance.m_lastItem.IsEnchanted && __instance.m_lastItem is Equipment lastItem)
            {
                for (int i = 0; i < lastItem.ActiveEnchantments.Count; ++i)
                {
                    Enchantment activeEnchantment = lastItem.ActiveEnchantments[i];
                    if (lastItem is Weapon weapon && (activeEnchantment.PresetID == 3 || activeEnchantment.PresetID == 4))
                    {
                        int num1;
                        switch (weapon.Type)
                        {
                        case Weapon.WeaponType.Dagger_OH:
                            num1 = VampiricTransmutationTable.DAGGER_THIRST_THRESHOLD;
                            break;

                        case Weapon.WeaponType.Bow:
                            num1 = VampiricTransmutationTable.BOW_THIRST_THRESHOLD;
                            break;

                        default:
                            num1 = VampiricTransmutationTable.DEFAULT_THIRST_THRESHOLD;
                            break;
                        }
                        float num2 = (float)weapon.DamageDealtTracking / (float)num1;
                        if ((double)num2 >= 0.0 && (double)num2 < 0.330000013113022)
                        {
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("Vampiric_01"), "");
                            ++_index;
                        }
                        else if ((double)num2 >= 0.330000013113022 && (double)num2 < 0.660000026226044)
                        {
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("Vampiric_02"), "");
                            ++_index;
                        }
                        else if ((double)num2 >= 0.660000026226044 && (double)num2 < 1.0)
                        {
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("Vampiric_03"), "");
                            ++_index;
                        }
                        else if ((double)num2 >= 1.0)
                        {
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("Vampiric_04"), "");
                            ++_index;
                        }
                        if (MenuManager.Instance.DisplayDebugInfo)
                        {
                            __instance.GetEnchantmentRow(_index).SetInfo("DEBUG Damage", (float)weapon.DamageDealtTracking);
                            ++_index;
                        }
                    }
                    DamageList _damages1 = new DamageList();
                    for (int index = 0; index < activeEnchantment.Effects.Length; ++index)
                    {
                        if (activeEnchantment.Effects[index] is AddStatusEffectBuildUp effect)
                        {
                            string loc = LocalizationManager.Instance.GetLoc("EnchantmentDescription_InflictStatus", string.Empty);
                            __instance.GetEnchantmentRow(_index).SetInfo(loc, effect.Status.StatusName);
                            ++_index;
                        }
                        else if (activeEnchantment.Effects[index] is AffectStatusEffectBuildUpResistance effect1)
                        {
                            string loc = LocalizationManager.Instance.GetLoc("EnchantmentDescription_StatusResist", effect1.StatusEffect.StatusName);
                            __instance.GetEnchantmentRow(_index).SetInfo(loc, effect1.Value.ToString() + "%");
                            ++_index;
                        }
                        else if (activeEnchantment.Effects[index] is ShootEnchantmentBlast effect2 && lastItem is Weapon weapon1)
                        {
                            DamageType.Types overrideDtype = effect2.BaseBlast.GetComponentInChildren <WeaponDamage>().OverrideDType;
                            float            _damage       = weapon1.GetDisplayedDamage().TotalDamage *effect2.DamageMultiplier;
                            _damages1.Add(new DamageType(overrideDtype, _damage));
                        }
                    }
                    if (_damages1.Count > 0)
                    {
                        __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("EnchantmentDescription_Blast"), _damages1);
                        ++_index;
                    }
                    DamageList _damages2 = new DamageList();
                    if (lastItem is Weapon weapon2)
                    {
                        _damages2 = weapon2.GetEnchantmentDamageBonuses();
                    }
                    if (_damages2.Count > 0)
                    {
                        __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_Damage"), _damages2);
                        ++_index;
                    }
                    if (activeEnchantment.DamageModifier.Count != 0)
                    {
                        __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_DamageModifier"), activeEnchantment.DamageModifier, _displayPercent: true);
                        ++_index;
                    }
                    if (activeEnchantment.ElementalResistances.Count != 0)
                    {
                        __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_DamageResistance"), activeEnchantment.ElementalResistances);
                        ++_index;
                    }
                    if ((double)activeEnchantment.GlobalStatusResistance != 0.0)
                    {
                        __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_StatusResist"), activeEnchantment.GlobalStatusResistance);
                        ++_index;
                    }
                    if ((double)activeEnchantment.ManaAbsorbRatio != 0.0)
                    {
                        string loc = LocalizationManager.Instance.GetLoc("EnchantmentDescription_Absorb", activeEnchantment.ManaAbsorbRatio.ToString(), LocalizationManager.Instance.GetLoc("CharacterStat_Mana"));
                        __instance.GetEnchantmentRow(_index).SetInfo(loc, "");
                        ++_index;
                    }
                    if ((double)activeEnchantment.HealthAbsorbRatio != 0.0)
                    {
                        string loc = LocalizationManager.Instance.GetLoc("EnchantmentDescription_Absorb", activeEnchantment.HealthAbsorbRatio.ToString(), LocalizationManager.Instance.GetLoc("CharacterStat_Health"));
                        __instance.GetEnchantmentRow(_index).SetInfo(loc, "");
                        ++_index;
                    }
                    if ((double)activeEnchantment.StaminaAbsorbRatio != 0.0)
                    {
                        string loc = LocalizationManager.Instance.GetLoc("EnchantmentDescription_Absorb", activeEnchantment.StaminaAbsorbRatio.ToString(), LocalizationManager.Instance.GetLoc("CharacterStat_Stamina"));
                        __instance.GetEnchantmentRow(_index).SetInfo(loc, "");
                        ++_index;
                    }
                    for (int index = 0; index < activeEnchantment.StatModifications.Count; ++index)
                    {
                        float num = activeEnchantment.StatModifications[index].Value;
                        if (activeEnchantment.StatModifications[index].Name == Enchantment.Stat.CooldownReduction)
                        {
                            num = -num;
                        }
                        string _dataValue = ((double)num > 0.0 ? "+" : "") + num.ToString();
                        if (activeEnchantment.StatModifications[index].Type == Enchantment.StatModification.BonusType.Modifier)
                        {
                            _dataValue += "%";
                        }
                        switch (activeEnchantment.StatModifications[index].Name)
                        {
                        case Enchantment.Stat.Weight:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_Weight"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.Durability:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_Durability"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.ManaCostReduction:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_ManaCost"), _dataValue.Replace("+", "-"));
                            ++_index;
                            break;

                        case Enchantment.Stat.StaminaCostReduction:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_StaminaCost"), _dataValue.Replace("+", "-"));
                            ++_index;
                            break;

                        case Enchantment.Stat.CooldownReduction:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_CooldownReduction"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.MovementSpeed:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_MovementPenalty"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.AttackSpeed:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_AttackSpeed"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.Impact:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_Impact"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.StabilityRegen:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_StabilityRegen"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.HealthRegen:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_HealthRegen"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.ManaRegen:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_ManaRegen"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.Protection:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_Defense_Protection"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.CorruptionResistance:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_CorruptionResistance"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.FoodDepletionRate:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_FoodEfficiency"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.DrinkDepletionRate:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_DrinkEfficiency"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.SleepDepletionRate:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_SleepEfficiency"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.PouchCapacity:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_PouchCapacity"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.ImpactResistance:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_Defense_ImpactResistance"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.HeatProtection:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_HeatProtection"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.ColdProtection:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_ColdProtection"), _dataValue);
                            ++_index;
                            break;

                        case Enchantment.Stat.Barrier:
                            __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_Barrier"), _dataValue);
                            ++_index;
                            break;
                        }
                    }
                    if (activeEnchantment.Indestructible)
                    {
                        __instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("EnchantmentDescription_Indestructible"), "");
                        ++_index;
                    }
                }
            }
            for (int index = _index; index < __instance.m_enchantmentDetailRows.Count; ++index)
            {
                if (__instance.m_enchantmentDetailRows[index].IsDisplayed)
                {
                    __instance.m_enchantmentDetailRows[index].Hide();
                }
            }
            return(false);
        }
예제 #9
0
        /// <summary>
        /// Handle any kind of Monster interaction
        /// </summary>
        private void monsterLife()
        {
            if (Monster == null)
            {
                return;
            }
            if ((DateTime.Now - LastEffect).TotalSeconds >= 5)
            {
                LastEffect = DateTime.Now;
                if (IsTarget)
                {
                    MapInstance.Broadcast(StaticPacketHelper.GenerateEff(UserType.Monster, MapMonsterId, 824));
                }
                if (IsBonus)
                {
                    MapInstance.Broadcast(StaticPacketHelper.GenerateEff(UserType.Monster, MapMonsterId, 826));
                }
            }

            if (IsBoss && IsAlive)
            {
                MapInstance.Broadcast(GenerateBoss());
            }

            // handle hit queue
            while (HitQueue.TryDequeue(out HitRequest hitRequest))
            {
                if (IsAlive && hitRequest.Session.Character.Hp > 0 && (ServerManager.Instance.ChannelId != 51 || MonsterVNum - (byte)hitRequest.Session.Character.Faction != 678))
                {
                    int  hitmode        = 0;
                    bool isCaptureSkill = hitRequest.Skill.BCards.Any(s => s.Type.Equals((byte)CardType.Capture));

                    // calculate damage
                    bool         onyxWings    = false;
                    BattleEntity battleEntity = new BattleEntity(hitRequest.Session.Character, hitRequest.Skill);
                    int          damage       = DamageHelper.Instance.CalculateDamage(battleEntity, new BattleEntity(this), hitRequest.Skill, ref hitmode, ref onyxWings);
                    if (onyxWings)
                    {
                        short      onyxX  = (short)(hitRequest.Session.Character.PositionX + 2);
                        short      onyxY  = (short)(hitRequest.Session.Character.PositionY + 2);
                        int        onyxId = MapInstance.GetNextMonsterId();
                        MapMonster onyx   = new MapMonster()
                        {
                            MonsterVNum = 2371, MapX = onyxX, MapY = onyxY, MapMonsterId = onyxId, IsHostile = false, IsMoving = false, ShouldRespawn = false
                        };
                        MapInstance.Broadcast(UserInterfaceHelper.Instance.GenerateGuri(31, 1, hitRequest.Session.Character.CharacterId, onyxX, onyxY));
                        onyx.Initialize(MapInstance);
                        MapInstance.AddMonster(onyx);
                        MapInstance.Broadcast(onyx.GenerateIn());
                        CurrentHp -= damage / 2;
                        Observable.Timer(TimeSpan.FromMilliseconds(350)).Subscribe(o =>
                        {
                            MapInstance.Broadcast(StaticPacketHelper.SkillUsed(UserType.Monster, onyxId, 3, MapMonsterId, -1, 0, -1, hitRequest.Skill.Effect, -1, -1, true, 92, damage / 2, 0, 0));
                            MapInstance.RemoveMonster(onyx);
                            MapInstance.Broadcast(StaticPacketHelper.Out(UserType.Monster, onyx.MapMonsterId));
                        });
                    }
                    if (hitmode != 1)
                    {
                        hitRequest.Skill.BCards.Where(s => s.Type.Equals((byte)CardType.Buff)).ToList().ForEach(s => s.ApplyBCards(this, hitRequest.Session));
                        hitRequest.Skill.BCards.Where(s => s.Type.Equals((byte)CardType.Capture)).ToList().ForEach(s => s.ApplyBCards(this, hitRequest.Session));
                        if (battleEntity?.ShellWeaponEffects != null)
                        {
                            foreach (ShellEffectDTO shell in battleEntity.ShellWeaponEffects)
                            {
                                switch (shell.Effect)
                                {
                                case (byte)ShellWeaponEffectType.Blackout:
                                {
                                    Buff buff = new Buff(7, battleEntity.Level);
                                    if (ServerManager.Instance.RandomNumber() < shell.Value)
                                    {
                                        AddBuff(buff);
                                    }
                                    break;
                                }

                                case (byte)ShellWeaponEffectType.DeadlyBlackout:
                                {
                                    Buff buff = new Buff(66, battleEntity.Level);
                                    if (ServerManager.Instance.RandomNumber() < shell.Value)
                                    {
                                        AddBuff(buff);
                                    }
                                    break;
                                }

                                case (byte)ShellWeaponEffectType.MinorBleeding:
                                {
                                    Buff buff = new Buff(1, battleEntity.Level);
                                    if (ServerManager.Instance.RandomNumber() < shell.Value)
                                    {
                                        AddBuff(buff);
                                    }
                                    break;
                                }

                                case (byte)ShellWeaponEffectType.Bleeding:
                                {
                                    Buff buff = new Buff(21, battleEntity.Level);
                                    if (ServerManager.Instance.RandomNumber() < shell.Value)
                                    {
                                        AddBuff(buff);
                                    }
                                    break;
                                }

                                case (byte)ShellWeaponEffectType.HeavyBleeding:
                                {
                                    Buff buff = new Buff(42, battleEntity.Level);
                                    if (ServerManager.Instance.RandomNumber() < shell.Value)
                                    {
                                        AddBuff(buff);
                                    }
                                    break;
                                }

                                case (byte)ShellWeaponEffectType.Freeze:
                                {
                                    Buff buff = new Buff(27, battleEntity.Level);
                                    if (ServerManager.Instance.RandomNumber() < shell.Value)
                                    {
                                        AddBuff(buff);
                                    }
                                    break;
                                }
                                }
                            }
                        }
                    }
                    if (DamageList.ContainsKey(hitRequest.Session.Character.CharacterId))
                    {
                        DamageList[hitRequest.Session.Character.CharacterId] += damage;
                    }
                    else
                    {
                        DamageList.Add(hitRequest.Session.Character.CharacterId, damage);
                    }
                    if (isCaptureSkill)
                    {
                        damage = 0;
                    }
                    if (CurrentHp <= damage)
                    {
                        SetDeathStatement();
                    }
                    else
                    {
                        CurrentHp -= damage;
                    }

                    // only set the hit delay if we become the monsters target with this hit
                    if (Target == -1)
                    {
                        LastSkill = DateTime.Now;
                    }

                    int nearestDistance = 100;
                    foreach (KeyValuePair <long, long> kvp in DamageList)
                    {
                        ClientSession session = MapInstance.GetSessionByCharacterId(kvp.Key);
                        if (session != null)
                        {
                            int distance = Map.GetDistance(new MapCell
                            {
                                X = MapX,
                                Y = MapY
                            }, new MapCell
                            {
                                X = session.Character.PositionX,
                                Y = session.Character.PositionY
                            });
                            if (distance < nearestDistance)
                            {
                                nearestDistance = distance;
                                Target          = session.Character.CharacterId;
                            }
                        }
                    }

                    switch (hitRequest.TargetHitType)
                    {
                    case TargetHitType.SingleTargetHit:
                        if (!isCaptureSkill)
                        {
                            MapInstance?.Broadcast(StaticPacketHelper.SkillUsed(UserType.Player, hitRequest.Session.Character.CharacterId, 3, MapMonsterId, hitRequest.Skill.SkillVNum, hitRequest.Skill.Cooldown, hitRequest.Skill.AttackAnimation, hitRequest.SkillEffect, hitRequest.Session.Character.PositionX, hitRequest.Session.Character.PositionY, IsAlive, (int)((float)CurrentHp / (float)MaxHp * 100), damage, hitmode, (byte)(hitRequest.Skill.SkillType - 1)));
                        }
                        break;

                    case TargetHitType.SingleTargetHitCombo:
                        MapInstance?.Broadcast(StaticPacketHelper.SkillUsed(UserType.Player, hitRequest.Session.Character.CharacterId, 3, MapMonsterId, hitRequest.Skill.SkillVNum, hitRequest.Skill.Cooldown, hitRequest.SkillCombo.Animation, hitRequest.SkillCombo.Effect, hitRequest.Session.Character.PositionX, hitRequest.Session.Character.PositionY, IsAlive, (int)((float)CurrentHp / (float)MaxHp * 100), damage, hitmode, (byte)(hitRequest.Skill.SkillType - 1)));
                        break;

                    case TargetHitType.SingleAOETargetHit:
                        switch (hitmode)
                        {
                        case 1:
                            hitmode = 4;
                            break;

                        case 3:
                            hitmode = 6;
                            break;

                        default:
                            hitmode = 5;
                            break;
                        }
                        if (hitRequest.ShowTargetHitAnimation)
                        {
                            MapInstance?.Broadcast(StaticPacketHelper.SkillUsed(UserType.Player, hitRequest.Session.Character.CharacterId, 3, MapMonsterId, hitRequest.Skill.SkillVNum, hitRequest.Skill.Cooldown, hitRequest.Skill.AttackAnimation, hitRequest.SkillEffect, hitRequest.Session.Character.PositionX, hitRequest.Session.Character.PositionY, IsAlive, (int)((float)CurrentHp / (float)MaxHp * 100), damage, hitmode, (byte)(hitRequest.Skill.SkillType - 1)));
                        }
                        else
                        {
                            MapInstance?.Broadcast(StaticPacketHelper.SkillUsed(UserType.Player, hitRequest.Session.Character.CharacterId, 3, MapMonsterId, 0, 0, 0, 0, 0, 0, IsAlive, (int)((float)CurrentHp / (float)MaxHp * 100), damage, hitmode, (byte)(hitRequest.Skill.SkillType - 1)));
                        }
                        break;

                    case TargetHitType.AOETargetHit:
                        switch (hitmode)
                        {
                        case 1:
                            hitmode = 4;
                            break;

                        case 3:
                            hitmode = 6;
                            break;

                        default:
                            hitmode = 5;
                            break;
                        }
                        MapInstance?.Broadcast(StaticPacketHelper.SkillUsed(UserType.Player, hitRequest.Session.Character.CharacterId, 3, MapMonsterId, hitRequest.Skill.SkillVNum, hitRequest.Skill.Cooldown, hitRequest.Skill.AttackAnimation, hitRequest.SkillEffect, hitRequest.Session.Character.PositionX, hitRequest.Session.Character.PositionY, IsAlive, (int)((float)CurrentHp / (float)MaxHp * 100), damage, hitmode, (byte)(hitRequest.Skill.SkillType - 1)));
                        break;

                    case TargetHitType.ZoneHit:
                        MapInstance?.Broadcast(StaticPacketHelper.SkillUsed(UserType.Player, hitRequest.Session.Character.CharacterId, 3, MapMonsterId, hitRequest.Skill.SkillVNum, hitRequest.Skill.Cooldown, hitRequest.Skill.AttackAnimation, hitRequest.SkillEffect, hitRequest.MapX, hitRequest.MapY, IsAlive, (int)((float)CurrentHp / (float)MaxHp * 100), damage, 5, (byte)(hitRequest.Skill.SkillType - 1)));
                        break;

                    case TargetHitType.SpecialZoneHit:
                        MapInstance?.Broadcast(StaticPacketHelper.SkillUsed(UserType.Player, hitRequest.Session.Character.CharacterId, 3, MapMonsterId, hitRequest.Skill.SkillVNum, hitRequest.Skill.Cooldown, hitRequest.Skill.AttackAnimation, hitRequest.SkillEffect, hitRequest.Session.Character.PositionX, hitRequest.Session.Character.PositionY, IsAlive, (int)((float)CurrentHp / (float)MaxHp * 100), damage, hitmode, (byte)(hitRequest.Skill.SkillType - 1)));
                        break;
                    }

                    if (CurrentHp <= 0 && !isCaptureSkill)
                    {
                        // generate the kill bonus
                        hitRequest.Session.Character.GenerateKillBonus(this);
                    }
                }
                else
                {
                    // monster already has been killed, send cancel
                    hitRequest.Session.SendPacket(StaticPacketHelper.Cancel(2, MapMonsterId));
                }
                if (IsBoss)
                {
                    MapInstance.Broadcast(GenerateBoss());
                }
            }

            // Respawn
            if (!IsAlive && ShouldRespawn != null && !ShouldRespawn.Value)
            {
                MapInstance.RemoveMonster(this);
            }
            if (!IsAlive && ShouldRespawn != null && ShouldRespawn.Value)
            {
                double timeDeath = (DateTime.Now - Death).TotalSeconds;
                if (timeDeath >= Monster.RespawnTime / 10d)
                {
                    respawn();
                }
            }

            // normal movement
            else if (Target == -1)
            {
                move();
            }

            // target following
            else if (MapInstance != null)
            {
                GetNearestOponent();
                HostilityTarget();

                ClientSession targetSession = MapInstance.GetSessionByCharacterId(Target);

                // remove target in some situations
                if (targetSession == null || targetSession.Character.Invisible || targetSession.Character.Hp <= 0 || CurrentHp <= 0)
                {
                    RemoveTarget();
                    return;
                }

                NpcMonsterSkill npcMonsterSkill = null;
                if (Skills != null && ServerManager.Instance.RandomNumber(0, 10) > 8)
                {
                    npcMonsterSkill = Skills.Where(s => (DateTime.Now - s.LastSkillUse).TotalMilliseconds >= 100 * s.Skill?.Cooldown)?.OrderBy(rnd => _random.Next())?.FirstOrDefault();
                }

                if (npcMonsterSkill?.Skill.TargetType == 1 && npcMonsterSkill?.Skill.HitType == 0)
                {
                    targetHit(targetSession, npcMonsterSkill);
                }

                // check if target is in range
                if (!targetSession.Character.InvisibleGm && !targetSession.Character.Invisible && targetSession.Character.Hp > 0)
                {
                    if (npcMonsterSkill != null && CurrentMp >= npcMonsterSkill.Skill.MpCost &&
                        Map.GetDistance(new MapCell
                    {
                        X = MapX,
                        Y = MapY
                    },
                                        new MapCell
                    {
                        X = targetSession.Character.PositionX,
                        Y = targetSession.Character.PositionY
                    }) < npcMonsterSkill.Skill.Range)
                    {
                        targetHit(targetSession, npcMonsterSkill);
                    }
                    else if (Map.GetDistance(new MapCell
                    {
                        X = MapX,
                        Y = MapY
                    },
                                             new MapCell
                    {
                        X = targetSession.Character.PositionX,
                        Y = targetSession.Character.PositionY
                    }) <= Monster.BasicRange)
                    {
                        targetHit(targetSession, npcMonsterSkill);
                    }
                    else
                    {
                        followTarget(targetSession);
                    }
                }
                else
                {
                    followTarget(targetSession);
                }
            }
        }
예제 #10
0
        private void OnUpdate()
        {
            var heroes = EntityManager <Hero> .Entities.Where(x => x.IsValid && !x.IsIllusion).ToList();

            DamageList.Clear();

            foreach (var target in heroes.Where(x => x.IsAlive && x.IsEnemy(Owner)).ToList())
            {
                List <BaseAbility> abilities = new List <BaseAbility>();

                if (target.IsVisible)
                {
                    // Veil
                    var veil = Main.Veil;
                    if (veil != null && veil.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(veil.ToString()))
                    {
                        abilities.Add(veil);
                    }

                    // Ethereal
                    var ethereal = Main.Ethereal;
                    if (ethereal != null && ethereal.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(ethereal.ToString()))
                    {
                        abilities.Add(ethereal);
                    }

                    // Shivas
                    var shivas = Main.Shivas;
                    if (shivas != null && shivas.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(shivas.ToString()))
                    {
                        abilities.Add(shivas);
                    }

                    // ConcussiveShot
                    var soulAssumption = Main.SoulAssumption;
                    if (soulAssumption.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(soulAssumption.ToString()) && soulAssumption.MaxCharges)
                    {
                        abilities.Add(soulAssumption);
                    }

                    // Dagon
                    var dagon = Main.Dagon;
                    if (dagon != null && dagon.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled("item_dagon_5"))
                    {
                        abilities.Add(dagon);
                    }
                }

                var damageCalculation = new Combo(abilities.ToArray());
                var damageReduction   = -DamageReduction(target, heroes);
                var damageBlock       = DamageBlock(target, heroes);

                var livingArmor = LivingArmor(target, heroes, damageCalculation.Abilities);
                var damage      = DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(target) + damageBlock, 0, damageReduction) - livingArmor;
                var readyDamage = DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(target, true, false) + damageBlock, 0, damageReduction) - livingArmor;
                var totalDamage = DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(target, false, false) + damageBlock, 0, damageReduction) - livingArmor;

                if (target.IsInvulnerable() ||
                    target.HasAnyModifiers("modifier_abaddon_borrowed_time", "modifier_item_combo_breaker_buff") ||
                    target.HasModifier("modifier_templar_assassin_refraction_absorb") ||
                    target.HasAnyModifiers("modifier_winter_wyvern_winters_curse_aura", "modifier_winter_wyvern_winters_curse"))
                {
                    damage      = 0.0f;
                    readyDamage = 0.0f;
                }

                DamageList.Add(new Damage(target, damage, readyDamage, totalDamage, target.Health));
            }
        }
예제 #11
0
        private void OnUpdate()
        {
            var heroes = EntityManager <Hero> .Entities.Where(x => x.IsValid && !x.IsIllusion).ToList();

            DamageList.Clear();

            foreach (var target in heroes.Where(x => x.IsAlive && x.IsEnemy(Owner)).ToList())
            {
                List <BaseAbility> abilities = new List <BaseAbility>();

                var damageOdds      = 0.0f;
                var readyDamageOdds = 0.0f;
                var totalDamageOdds = 0.0f;

                if (target.IsVisible)
                {
                    // Veil
                    var veil = Main.Veil;
                    if (veil != null && veil.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(veil.ToString()))
                    {
                        abilities.Add(veil);
                    }

                    // Ethereal
                    var ethereal = Main.Ethereal;
                    if (ethereal != null && ethereal.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(ethereal.ToString()))
                    {
                        abilities.Add(ethereal);
                    }

                    // Shivas
                    var shivas = Main.Shivas;
                    if (shivas != null && shivas.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(shivas.ToString()))
                    {
                        abilities.Add(shivas);
                    }

                    // Dagon
                    var dagon = Main.Dagon;
                    if (dagon != null && dagon.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled("item_dagon_5"))
                    {
                        abilities.Add(dagon);
                    }

                    // Overwhelming Odds
                    var overwhelmingOdds = Main.OverwhelmingOdds;
                    if (overwhelmingOdds.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(overwhelmingOdds.ToString()))
                    {
                        var input = new PredictionInput
                        {
                            Owner                   = Owner,
                            AreaOfEffect            = overwhelmingOdds.HasAreaOfEffect,
                            AreaOfEffectTargets     = UpdateMode.OverwhelmingOddsUnits,
                            CollisionTypes          = overwhelmingOdds.CollisionTypes,
                            Delay                   = overwhelmingOdds.CastPoint + overwhelmingOdds.ActivationDelay,
                            Speed                   = overwhelmingOdds.Speed,
                            Range                   = float.MaxValue,
                            Radius                  = overwhelmingOdds.Radius,
                            PredictionSkillshotType = overwhelmingOdds.PredictionSkillshotType
                        };

                        var castPosition = overwhelmingOdds.GetPredictionOutput(input.WithTarget(target)).CastPosition;
                        var damageUnits  = overwhelmingOdds.GetDamage(castPosition, target);

                        if (overwhelmingOdds.IsReady && !Owner.IsStunned() && !Owner.IsMuted() && !Owner.IsSilenced())
                        {
                            if (Owner.Distance2D(castPosition) <= overwhelmingOdds.CastRange)
                            {
                                damageOdds += damageUnits;
                            }

                            readyDamageOdds += damageUnits;
                        }

                        totalDamageOdds += damageUnits;
                    }
                }

                var damageCalculation = new Combo(abilities.ToArray());
                var damageReduction   = -DamageReduction(target, heroes);
                var damageBlock       = MagicalDamageBlock(target, heroes);

                var livingArmor = LivingArmor(target, heroes, damageCalculation.Abilities);
                var damage      = DamageHelpers.GetSpellDamage((damageCalculation.GetDamage(target) + damageOdds) + damageBlock, 0, damageReduction) - livingArmor;
                var readyDamage = DamageHelpers.GetSpellDamage((damageCalculation.GetDamage(target, true, false) + readyDamageOdds) + damageBlock, 0, damageReduction) - livingArmor;
                var totalDamage = DamageHelpers.GetSpellDamage((damageCalculation.GetDamage(target, false, false) + totalDamageOdds) + damageBlock, 0, damageReduction) - livingArmor;

                if (target.IsInvulnerable() || target.HasAnyModifiers(BlockModifiers))
                {
                    damage      = 0.0f;
                    readyDamage = 0.0f;
                }

                DamageList.Add(new Damage(target, damage, readyDamage, totalDamage, target.Health));
            }
        }
예제 #12
0
        private void OnUpdate()
        {
            var heroes = EntityManager <Hero> .Entities.Where(x => x.IsValid && !x.IsIllusion).ToList();

            DamageList.Clear();

            foreach (var target in heroes.Where(x => x.IsAlive && x.IsEnemy(Owner)).ToList())
            {
                List <BaseAbility> abilities = new List <BaseAbility>();

                var damage      = 0.0f;
                var readyDamage = 0.0f;
                var totalDamage = 0.0f;

                if (target.IsVisible)
                {
                    // Veil
                    var Veil = Main.Veil;
                    if (Veil != null && Veil.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(Veil.ToString()))
                    {
                        abilities.Add(Veil);
                    }

                    // Ethereal
                    var Ethereal = Main.Ethereal;
                    if (Ethereal != null && Ethereal.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(Ethereal.ToString()))
                    {
                        abilities.Add(Ethereal);
                    }

                    // Shivas
                    var Shivas = Main.Shivas;
                    if (Shivas != null && Shivas.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled(Shivas.ToString()))
                    {
                        abilities.Add(Shivas);
                    }

                    // Impale
                    var Impale = Main.Impale;
                    if (Impale.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(Impale.ToString()))
                    {
                        abilities.Add(Impale);
                    }

                    // ManaBurn
                    var ManaBurn = Main.ManaBurn;
                    if (ManaBurn.Ability.Level > 0 && Menu.AutoKillStealToggler.Value.IsEnabled(ManaBurn.ToString()) && target.Mana > 80)
                    {
                        abilities.Add(ManaBurn);
                    }

                    // Dagon
                    var Dagon = Main.Dagon;
                    if (Dagon != null && Dagon.Ability.IsValid && Menu.AutoKillStealToggler.Value.IsEnabled("item_dagon_5"))
                    {
                        abilities.Add(Dagon);
                    }

                    // Vendetta
                    var Vendetta = Main.Vendetta;
                    if (Vendetta.Ability.Level > 0)
                    {
                        if (Owner.HasModifier(Vendetta.ModifierName))
                        {
                            damage += Vendetta.GetDamage(target);
                        }
                        else if (Vendetta.CanBeCasted)
                        {
                            readyDamage += Vendetta.GetDamage(target);
                        }

                        totalDamage += Vendetta.GetDamage(target);
                    }
                }

                var damageCalculation = new Combo(abilities.ToArray());
                var damageReduction   = -DamageReduction(target, heroes);
                var damageBlock       = DamageBlock(target, heroes);

                damage      += DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(target) + damageBlock, 0, damageReduction);
                readyDamage += DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(target, true, false) + damageBlock, 0, damageReduction);
                totalDamage += DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(target, false, false) + damageBlock, 0, damageReduction);

                damage      -= LivingArmor(target, heroes, damageCalculation.Abilities, damage);
                readyDamage -= LivingArmor(target, heroes, damageCalculation.Abilities, readyDamage);
                totalDamage -= LivingArmor(target, heroes, damageCalculation.Abilities, totalDamage);

                if (target.HasAnyModifiers("modifier_abaddon_borrowed_time", "modifier_item_combo_breaker_buff") ||
                    target.HasModifier("modifier_templar_assassin_refraction_absorb") ||
                    target.HasAnyModifiers("modifier_winter_wyvern_winters_curse_aura", "modifier_winter_wyvern_winters_curse") ||
                    target.IsInvulnerable())
                {
                    damage      = 0.0f;
                    readyDamage = 0.0f;
                }

                DamageList.Add(new Damage(target, damage, readyDamage, totalDamage, target.Health));
            }
        }
예제 #13
0
        public DamageList GetWeaponDamage(EnemyModel enemy, Dictionary <string, float[]> naturalHexes, bool useWeaponHex, bool useAxeSpecial = false)
        {
            float weaponMulti = 1.0f;

            if (useAxeSpecial && (MainWeapon.Type == Weapon.WeaponType.Axe_1H || MainWeapon.Type == Weapon.WeaponType.Axe_2H))
            {
                weaponMulti = 1.3f;
            }

            float[] damages = new float[9];
            for (int i = 0; i < 9; i++)
            {
                var type = (DamageType.Types)i;

                float dmgBonus = GetDamageMultiplier(type);

                if (MainWeapon.BaseDamage.TryGet(type, out DamageType dType))
                {
                    damages[i] += dType.Damage * weaponMulti * dmgBonus;
                }

                if (MainWeapon.EnchantmentDamage.TryGet(type, out DamageType eType))
                {
                    damages[i] += eType.Damage * dmgBonus;
                }

                if (MainWeapon.EnchantmentBlastDamage.TryGet(type, out DamageType bType))
                {
                    damages[i] += bType.Damage * dmgBonus;
                }

                if (!string.IsNullOrEmpty(Imbue.Name))
                {
                    if (type != DamageType.Types.Count && Imbue.OverrideType == type)
                    {
                        var totalBase = MainWeapon.BaseDamage.TotalDamage + MainWeapon.EnchantmentDamage.TotalDamage;
                        damages[i] += totalBase * Imbue.DamageMultiplier * dmgBonus;
                    }

                    if (Imbue.BonusDamage.TryGet(type, out DamageType iType))
                    {
                        damages[i] += iType.Damage * dmgBonus;
                    }
                }
            }

            // calculate total hexes without doubling any

            var totalHex = new float[9];

            foreach (var entry in naturalHexes)
            {
                for (int i = 0; i < 9; i++)
                {
                    totalHex[i] += entry.Value[i];
                }
            }

            if (useWeaponHex)
            {
                foreach (var entry in MainWeapon.m_alreadyAppliedHexes.Where(it => !naturalHexes.ContainsKey(it.Key)))
                {
                    for (int i = 0; i < 9; i++)
                    {
                        totalHex[i] += entry.Value[i];
                    }
                }
            }

            // build output damage against enemy resistances

            DamageList dmgList = new DamageList();

            for (int i = 0; i < 9; i++)
            {
                var dmg = (damages[i] - enemy.DamageProtection[i]) * (1 - (enemy.DamageResistance[i] + totalHex[i]));
                if (dmg > 0)
                {
                    dmgList.Add(new DamageType((DamageType.Types)i, dmg));
                }
            }

            return(dmgList);
        }
예제 #14
0
        public void OnUpdate()
        {
            var heroes = EntityManager <Hero> .Entities.Where(x => x.IsValid && !x.IsIllusion).ToList();

            DamageList.Clear();

            foreach (var target in heroes.Where(x => x.IsAlive && x.IsEnemy(Owner)).ToList())
            {
                List <BaseAbility> abilities = new List <BaseAbility>();

                var  damageByAura    = 0.0f;
                var  extendUltDamage = 0.0f;
                var  damageByAttack  = 0.0f;
                var  damageOfMisc    = 0f;
                bool canAttack       = true;
                if (target.IsVisible)
                {
                    // Veil
                    var veil = _abilities.Veil;
                    if (veil != null && veil.Ability.IsValid)
                    {
                        abilities.Add(veil);
                    }

                    // Ethereal
                    var ethereal = _abilities.Ethereal;
                    if (ethereal != null && ethereal.Ability.IsValid)
                    {
                        abilities.Add(ethereal);
                        canAttack = false;
                    }

                    // Shivas
                    var shivas = _abilities.Shivas;
                    if (shivas != null && shivas.Ability.IsValid)
                    {
                        abilities.Add(shivas);
                    }
                    //1
                    var pulseSkill = _abilities.Pulse;
                    if (pulseSkill.Ability.Level > 0)
                    {
                        abilities.Add(pulseSkill);
                    }
                    // Dagon
                    var dagon = _abilities.Dagon;
                    if (dagon != null && dagon.Ability.IsValid)
                    {
                        abilities.Add(dagon);
                    }

                    // ult
                    var ultSkill = _abilities.Scythe;
                    if (ultSkill.Ability.Level > 0)
                    {
                        abilities.Add(ultSkill);
                    }

                    var auraSkill = _abilities.HeartAura;
                    if (auraSkill.Ability.Level > 0)
                    {
                        damageByAura = auraSkill.GetDamage(target, 1);
                    }

                    if (canAttack)
                    {
                        damageByAttack = Owner.GetAttackDamage(target, true);
                    }

                    if (ultSkill.CanBeCasted && ultSkill.CanHit(target))
                    {
                        extendUltDamage = (damageByAttack + damageByAura) * ultSkill.DamagePerHealth;
                    }
                }

                var damageCalculation = new Combo(abilities.ToArray());
                var damageReduction   = -DamageReduction(target, heroes);
                var damageBlock       = DamageBlock(target, heroes);
                //没有计算来自装备的伤害加深
                damageOfMisc = damageByAttack + damageByAura + DamageHelpers.GetSpellDamage(extendUltDamage, Owner.GetSpellAmplification(), damageReduction);
                //Console.WriteLine($"{damageByAttack}/{damageByAura}/{extendUltDamage}/{DamageHelpers.GetSpellDamage(extendUltDamage, Owner.GetSpellAmplification(), damageReduction)}");
                var livingArmor = LivingArmor(target, heroes, damageCalculation.Abilities);
                //目前就能打死的
                var damage = DamageHelpers.GetSpellDamage((damageCalculation.GetDamage(target) + damageOfMisc) + damageBlock, 0, damageReduction) - livingArmor;
                //上去就能干死的
                var readyDamage = DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(target, true, false) + damageOfMisc + damageBlock, 0, damageReduction) - livingArmor;
                //所有状态完美的总体伤害
                var totalDamage = DamageHelpers.GetSpellDamage(damageCalculation.GetDamage(target, false, false) + damageBlock, 0, damageReduction) - livingArmor;

                if (target.IsInvulnerable() || target.HasAnyModifiers(BlockModifiers))
                {
                    damage      = 0.0f;
                    readyDamage = 0.0f;
                }
                //Console.WriteLine($"{damage}/{readyDamage}/{totalDamage}");
                DamageList.Add(new Damage(target, damage, readyDamage, totalDamage, target.Health, abilities.ToArray()));
            }
        }
예제 #15
0
        public bool TryAdd(ReadOnlySpan <char> logLine)
        {
            if (LevelLoad.TryParse(logLine, LogDate, out var ll))
            {
                Current = ll;
                LoadLevelList.Add(ll);
            }
            else if (TestDriveStart.TryParse(logLine, LogDate, out var std))
            {
                Current = std;
                StartTestDriveList.Add(std);
            }
            else if (TestDriveFinish.TryParse(logLine, LogDate, out var ftd))
            {
                Current = ftd;
                FinishTestDriveList.Add(ftd);
            }
            else if (GameStart.TryParse(logLine, LogDate, out var sg))
            {
                Current = sg;
                StartGameList.Add(sg);
            }
            else if (GameFinish.TryParse(logLine, LogDate, out var fg))
            {
                Current = fg;
                FinishGameList.Add(fg);
            }
            else if (GameRound.TryParse(logLine, LogDate, out var rg))
            {
                Current = rg;
                RoundGameList.Add(rg);
            }
            else if (ActiveBattleStart.TryParse(logLine, LogDate, out var sab))
            {
                Current = sab;
                StartActiveBattleList.Add(sab);
            }
            else if (PlayerLoad.TryParse(logLine, LogDate, out var pl))
            {
                Current = pl;
                PlayerLoadList.Add(pl);
            }
            else if (Damage.TryParse(logLine, LogDate, out var dmg))
            {
                Current = dmg;
                DamageList.Add(dmg);
            }
            else if (Killing.TryParse(logLine, LogDate, out var kill))
            {
                Current = kill;
                KillList.Add(kill);
            }
            else if (KillAssist.TryParse(logLine, LogDate, out var ka))
            {
                Current = ka;
                KillAssistList.Add(ka);
            }
            else if (Score.TryParse(logLine, LogDate, out var sc))
            {
                Current = sc;
                ScoreList.Add(sc);
            }
            else if (Decal.TryParse(logLine, LogDate, out var dec))
            {
                Current = dec;
                DecalList.Add(dec);
            }
            else
            {
                Current = null;
                return(false);
            }
            //update datetimes
            var currentDateTime = new DateTime(Current.TimeStamp);

            if (currentDateTime > Last)
            {
                Last = currentDateTime;
            }
            if (currentDateTime < First)
            {
                First = currentDateTime;
            }
            return(true);
        }