コード例 #1
0
ファイル: FullCombo.cs プロジェクト: Ray0fHope/EnsageSharp
        public static bool KillSteal(Hero[] enemyHeroes, float ping, Hero me)
        {
            var possibleTarget =
                enemyHeroes.FirstOrDefault(
                    hero =>
                    Utils.SleepCheck(hero.Handle + "KillSteal")
                    && Dictionaries.InDamageDictionary.ContainsKey(hero.Handle)
                    && Dictionaries.InDamageDictionary[hero.Handle] >= hero.Health);
            if (possibleTarget != null && possibleTarget.CanDie() && MyAbilities.NukesCombo.Any())
            {
                if (Dictionaries.InDamageDictionary[possibleTarget.Handle] >= possibleTarget.Health)
                {
                    foreach (var ability in from ability in MyAbilities.NukesCombo.OrderBy(ComboOrder.GetAbilityOrder)
                                            where
                                                ability != null
                                                && (ability.CanBeCasted()
                                                    || (ability.CanBeCasted(SoulRing.ManaGained)
                                                        && SoulRing.Check(ability)))
                                                && (Utils.SleepCheck(ability.Handle.ToString())
                                                    || (!ability.IsInAbilityPhase && ability.FindCastPoint() > 0))
                                            select ability)
                    {
                        var name = NameManager.Name(ability);
                        var handleString = ability.Handle.ToString();
                        if (etherealHitTime
                            >= (Environment.TickCount + ability.GetHitDelay(possibleTarget, name) * 1000))
                        {
                            continue;
                        }

                        if (name == "omniknight_purification")
                        {
                            if (MainMenu.Menu.Item("nukesToggler").GetValue<AbilityToggler>().IsEnabled(name)
                                && Nukes.NukesMenuDictionary[name].Item(name + "herotoggler")
                                       .GetValue<HeroToggler>()
                                       .IsEnabled(NameManager.Name(possibleTarget))
                                && (etherealHitTime
                                    < (Environment.TickCount + ability.GetHitDelay(possibleTarget, name) * 1000))
                                && possibleTarget.Health
                                > Nukes.NukesMenuDictionary[name].Item(NameManager.Name(ability) + "minhealthslider")
                                      .GetValue<Slider>()
                                      .Value)
                            {
                                var target = FindPurificationTarget(possibleTarget);
                                if (target != null
                                    && target.PredictedPosition().Distance2D(possibleTarget.PredictedPosition())
                                    < ability.GetRadius(name)
                                    && target.PredictedPosition()
                                           .Distance2D(
                                               possibleTarget.PredictedPosition(
                                                   ability.FindCastPoint(NameManager.Name(ability))))
                                    < ability.GetRadius(name))
                                {
                                    if (Nuke.Cast(ability, target, name))
                                    {
                                        Utils.Sleep(
                                            ability.GetCastDelay(me, possibleTarget, abilityName: name) * 1000 + ping
                                            + 100, 
                                            handleString);
                                        Utils.Sleep(
                                            ability.GetCastDelay(me, possibleTarget, abilityName: name) * 1000, 
                                            "GlobalCasting");
                                        Utils.Sleep(ability.GetHitDelay(possibleTarget, name) * 1000, "calculate");
                                        Utils.Sleep(
                                            ability.GetCastDelay(
                                                me, 
                                                possibleTarget, 
                                                useCastPoint: false, 
                                                abilityName: name) * 1000, 

                                            // + (Math.Max(Me.Distance2D(possibleTarget) - ability.GetCastRange(name) - 50, 0)
                                            // / Me.MovementSpeed) * 1000,
                                            "casting");
                                        Utils.Sleep(
                                            ability.GetCastDelay(me, possibleTarget, abilityName: name) * 1000, 
                                            "cancelorder");

                                        // Utils.Sleep(ping, "killsteal");
                                        return true;
                                    }
                                }
                            }

                            return false;
                        }

                        if (possibleTarget.Health - dealtDamage <= 0
                            || possibleTarget.Health - dealtDamage
                            < Nukes.NukesMenuDictionary[name].Item(name + "minhealthslider").GetValue<Slider>().Value)
                        {
                            Utils.Sleep(500, possibleTarget.Handle + "KillSteal");
                            dealtDamage = 0;
                            return false;
                        }

                        if (!ability.CanHit(possibleTarget, MyHeroInfo.Position, name)
                            || (name == "zuus_thundergods_wrath"
                                && (1
                                    + enemyHeroes.Count(
                                        x =>
                                        !x.Equals(possibleTarget)
                                        && x.Health <= AbilityDamage.CalculateDamage(ability, me, x)))
                                < Nukes.NukesMenuDictionary[name].Item(name + "minenemykill").GetValue<Slider>().Value)
                            || !MainMenu.Menu.Item("nukesToggler").GetValue<AbilityToggler>().IsEnabled(name)
                            || !Nukes.NukesMenuDictionary[name].Item(name + "herotoggler")
                                    .GetValue<HeroToggler>()
                                    .IsEnabled(NameManager.Name(possibleTarget))
                            || !Nuke.Cast(ability, possibleTarget, name))
                        {
                            return false;
                        }

                        if (Utils.SleepCheck(handleString))
                        {
                            dealtDamage += AbilityDamage.CalculateDamage(ability, me, possibleTarget);
                            if (possibleTarget.Health - dealtDamage <= 0)
                            {
                                Utils.Sleep(
                                    ability.GetHitDelay(possibleTarget, name) * 1000 + 500, 
                                    possibleTarget.Handle + "KillSteal");
                            }
                        }

                        var delay = ability.GetCastDelay(me, possibleTarget, abilityName: name) * 1000;
                        if (name == "riki_blink_strike")
                        {
                            Utils.Sleep(MyHeroInfo.AttackRate() * 1000, handleString);
                        }

                        if (name == "necrolyte_reapers_scythe")
                        {
                            Utils.Sleep(delay + ping + 1500, "calculate");
                        }

                        if (name == "necrolyte_death_pulse")
                        {
                            Utils.Sleep(delay + ping + 200, "calculate");
                        }

                        if (name == "item_ethereal_blade")
                        {
                            // Utils.Sleep(
                            // Me.GetTurnTime(possibleTarget) * 1000
                            // + Prediction.CalculateReachTime(
                            // possibleTarget,
                            // 1200,
                            // possibleTarget.Position - MyHeroInfo.Position),
                            // "casting");
                            etherealHitTime =
                                (float)
                                (Environment.TickCount + me.GetTurnTime(possibleTarget) * 1000
                                 + Prediction.CalculateReachTime(
                                     possibleTarget, 
                                     1200, 
                                     possibleTarget.Position - MyHeroInfo.Position) + ping * 2);
                            Utils.Sleep(
                                me.GetTurnTime(possibleTarget) * 1000 + 100
                                + (MyHeroInfo.Position.Distance2D(possibleTarget) / 1200) * 1000 + ping, 
                                "calculate");
                        }

                        if (name == "tusk_snowball")
                        {
                            Utils.Sleep(
                                me.GetTurnTime(possibleTarget) * 1000
                                + (MyHeroInfo.Position.Distance2D(possibleTarget) / 675) * 1000, 
                                "GlobalCasting");
                        }

                        Utils.Sleep(delay, handleString);
                        Utils.Sleep(
                            ability.GetCastDelay(me, possibleTarget, useCastPoint: false, abilityName: name) * 1000, 
                            "GlobalCasting");
                        Utils.Sleep(ability.GetHitDelay(possibleTarget, name) * 1000, "calculate");
                        Utils.Sleep(
                            ability.GetCastDelay(me, possibleTarget, useCastPoint: false, abilityName: name) * 1000, 

                            // + (Math.Max(Me.Distance2D(possibleTarget) - ability.GetCastRange(name) - 50, 0)
                            // / Me.MovementSpeed) * 1000,
                            "casting");
                        Utils.Sleep(delay, "cancelorder");
                        return true;
                    }

                    return true;
                }
            }

            // else if (MyAbilities.NukesCombo.Any())
            // {
            // MyAbilities.NukesCombo = new List<Ability>();
            // }
            return false;
        }