Пример #1
0
        private static void Game_OnUpdate(EventArgs args)
        {
            if (!Game.IsInGame || Game.IsPaused || Game.IsChatOpen || Game.IsWatchingGame || !Utils.SleepCheck("updaterate"))
                return;

            if (me.IsChanneling() || me.IsInvisible() || !Menu.Item("toggle").GetValue<KeyBind>().Active) return;
            dagon = me.GetDagon();
            target = ObjectManager.GetEntitiesParallel<Hero>().FirstOrDefault(CheckTarget);

            if (dagon == null || target == null || !me.CanUseItems() || !dagon.CanBeCasted()) return;
            dagon.UseAbility(target);
            Utils.Sleep(100, "updaterate");
        }
Пример #2
0
 public static void Game_OnUpdate(EventArgs args)
 {
     if (!Game.IsInGame) return;
     _me = ObjectMgr.LocalHero;
     if (_me == null || _me.ClassID != ClassID.CDOTA_Unit_Hero_Morphling)
     {
         return;
     }
     if (!_activated) return;
     if ((_target == null || !_target.IsVisible) && !_me.IsChanneling())
         _me.Move(Game.MousePosition);
     if (_target == null || _me.Distance2D(_target) > 500)
         _target = _me.ClosestToMouseTarget(1000);
     //Skills & Items
     waveform = _me.Spellbook.Spell1;
     adapt = _me.Spellbook.Spell2;
     eblade = _me.FindItem("item_ethereal_blade");
     bkb = _me.FindItem("item_black_king_bar");
     if (_target != null && _target.IsAlive && !_target.IsInvul())
     {
         if (!Utils.SleepCheck("Morph_Wait")) return;
         var targetDistance = _me.Distance2D(_target);
         var attackRange = 1000;
         if (targetDistance <= attackRange && waveform != null && waveform.CanBeCasted() && Utils.SleepCheck("waveform"))
         {
             waveform.UseAbility(_target.Position);
             Utils.Sleep(150 + Game.Ping, "waveform");
         }
         else if (bkb !=null && _bkbToggle && Utils.SleepCheck("BKB"))
         {
             bkb.UseAbility();
             Utils.Sleep(150 + Game.Ping, "BKB");
         }
         else if (eblade != null && eblade.CanBeCasted() && Utils.SleepCheck("eblade"))
         {
             eblade.UseAbility(_target);
             Utils.Sleep(150 + Game.Ping, "eblade");
         }
         else if (adapt != null && adapt.CanBeCasted() && Utils.SleepCheck("adapt"))
         {
             adapt.UseAbility(_target);
             Utils.Sleep(150 + Game.Ping, "adapt");
         }
     }
 }
Пример #3
0
        public static void Tick(EventArgs args)
        {
            if (!Game.IsInGame || Game.IsPaused || Game.IsWatchingGame)
                return;
            me = ObjectMgr.LocalHero;
            target = ObjectMgr.GetEntities<Hero>().Where(x => x.Health <= 100 && x.Distance2D(me) <= 950 && !x.IsIllusion && x.IsAlive && x.Team != me.Team).ToList();
            if (me == null || target.FirstOrDefault() == null)
                return;
            urn_of_shadows = me.FindItem("item_urn_of_shadows");

            if (!me.IsChanneling() && target.FirstOrDefault() != null && urn_of_shadows != null && (!me.IsInvisible() || me.ClassID == ClassID.CDOTA_Unit_Hero_Riki))
            {
                if (me.CanCast() && urn_of_shadows.CanBeCasted() && Utils.SleepCheck("urn"))
                {
                    urn_of_shadows.UseAbility(target.FirstOrDefault());
                    Utils.Sleep(200, "urn");
                }
            }
        }
        public void Combo()
        {
            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key);

            if (Menu.Item("keyW").GetValue<KeyBind>().Active)
            {
                var HealingWard = ObjectManager.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_BaseNPC_Additive)
                    && x.IsAlive && x.IsControllable && x.Team == me.Team).ToList();
                if (HealingWard.Count >= 1)
                {
                    for (int i = 0; i < HealingWard.Count(); ++i)
                    {
                        if (me.Position.Distance2D(HealingWard[i].Position) > 5 && Utils.SleepCheck(HealingWard[i].Handle.ToString()))
                        {
                            HealingWard[i].Move(me.Predict(310));
                            Utils.Sleep(50, HealingWard[i].Handle.ToString());
                        }
                    }
                }
            }
            Q = me.Spellbook.SpellQ;
            W = me.Spellbook.SpellW;
            R = me.Spellbook.SpellR;

            mom = me.FindItem("item_mask_of_madness");
            urn = me.FindItem("item_urn_of_shadows");
            dagon = me.Inventory.Items.FirstOrDefault(x => x.Name.Contains("item_dagon"));
            ethereal = me.FindItem("item_ethereal_blade");
            halberd = me.FindItem("item_heavens_halberd");
            mjollnir = me.FindItem("item_mjollnir");
            orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");
            abyssal = me.FindItem("item_abyssal_blade");
            mail = me.FindItem("item_blade_mail");
            bkb = me.FindItem("item_black_king_bar");
            satanic = me.FindItem("item_satanic");
            medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");
            Shiva = me.FindItem("item_shivas_guard");
            manta = me.FindItem("item_manta");
            var v =
                ObjectManager.GetEntities<Hero>()
                    .Where(x => x.Team != me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion && !x.IsMagicImmune())
                    .ToList();
            e = Toolset.ClosestToMouse(me);

            if (e == null) return;
            if (Active && me.Distance2D(e) <= 1400 && me.HasModifier("modifier_juggernaut_blade_fury") && Utils.SleepCheck("move"))
            {
                me.Move(Prediction.InFront(e, 170));
                Utils.Sleep(150, "move");
            }
            if (Active && me.Distance2D(e) <= 1400)
            {
                if (Menu.Item("orbwalk").GetValue<bool>() && !me.HasModifier("modifier_juggernaut_blade_fury"))
                {
                    Orbwalking.Orbwalk(e, 0, 1600, true, true);
                }
                if ( // MOM
                    mom != null
                    && mom.CanBeCasted()
                    && me.CanCast()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mom.Name)
                    && Utils.SleepCheck("mom")
                    && me.Distance2D(e) <= 700
                    )
                {
                    mom.UseAbility();
                    Utils.Sleep(250, "mom");
                }
                if ( // Mjollnir
                    mjollnir != null
                    && mjollnir.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                    && Utils.SleepCheck("mjollnir")
                    && me.Distance2D(e) <= 900
                    )
                {
                    mjollnir.UseAbility(me);
                    Utils.Sleep(250, "mjollnir");
                } // Mjollnir Item end
                if ((manta != null
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(manta.Name))
                    && manta.CanBeCasted() && me.IsSilenced() && Utils.SleepCheck("manta"))
                {
                    manta.UseAbility();
                    Utils.Sleep(400, "manta");
                }
                if ((manta != null && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(manta.Name))
                    && manta.CanBeCasted() && (e.Position.Distance2D(me.Position) <= me.GetAttackRange() + me.HullRadius)
                    && Utils.SleepCheck("manta"))
                {
                    manta.UseAbility();
                    Utils.Sleep(150, "manta");
                }
                if ( // Medall
                    medall != null
                    && medall.CanBeCasted()
                    && Utils.SleepCheck("Medall")
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                    && me.Distance2D(e) <= 700
                    )
                {
                    medall.UseAbility(e);
                    Utils.Sleep(250, "Medall");
                } // Medall Item end
                if (orchid != null && orchid.CanBeCasted() && me.Distance2D(e) <= 900 &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name) && Utils.SleepCheck("orchid"))
                {
                    orchid.UseAbility(e);
                    Utils.Sleep(100, "orchid");
                }

                if (Shiva != null && Shiva.CanBeCasted() && me.Distance2D(e) <= 600
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name)
                    && !e.IsMagicImmune() && Utils.SleepCheck("Shiva"))
                {
                    Shiva.UseAbility();
                    Utils.Sleep(100, "Shiva");
                }

                if (ethereal != null && ethereal.CanBeCasted()
                    && me.Distance2D(e) <= 700 && me.Distance2D(e) <= 400
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name) &&
                    Utils.SleepCheck("ethereal"))
                {
                    ethereal.UseAbility(e);
                    Utils.Sleep(100, "ethereal");
                }

                if (dagon != null
                    && dagon.CanBeCasted()
                    && me.Distance2D(e) <= 500
                    && Utils.SleepCheck("dagon"))
                {
                    dagon.UseAbility(e);
                    Utils.Sleep(100, "dagon");
                }
                if ( // Abyssal Blade
                    abyssal != null
                    && abyssal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsStunned()
                    && !e.IsHexed()
                    && Utils.SleepCheck("abyssal")
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(abyssal.Name)
                    && me.Distance2D(e) <= 400
                    )
                {
                    abyssal.UseAbility(e);
                    Utils.Sleep(250, "abyssal");
                } // Abyssal Item end
                if (urn != null && urn.CanBeCasted() && urn.CurrentCharges > 0 && me.Distance2D(e) <= 400
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(urn.Name) && Utils.SleepCheck("urn"))
                {
                    urn.UseAbility(e);
                    Utils.Sleep(240, "urn");
                }
                if (R != null && R.CanBeCasted() && me.Distance2D(e) <= 600 && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name))
                {
                    var creep = ObjectManager.GetEntities<Creep>().Where(x => x.IsAlive && x.Team != me.Team && x.IsSpawned).ToList();

                    for (int i = 0; i < creep.Count(); i++)
                    {
                        if (creep.Count(x => x.Distance2D(me) <= Menu.Item("Heel").GetValue<Slider>().Value) <=
                                                             (Menu.Item("Healh").GetValue<Slider>().Value)
                        && Utils.SleepCheck("R")
                        )
                        {
                            R.UseAbility(e);
                            Utils.Sleep(200, "R");
                        }
                    }
                    if (creep == null)
                    {
                        if (
                            Utils.SleepCheck("R")
                                                )
                        {
                            R.UseAbility(e);
                            Utils.Sleep(200, "R");
                        }
                    }
                }
                if (
                      W != null && W.CanBeCasted() && me.Distance2D(e) <= e.AttackRange + e.HullRadius+24
                      && me.Health <= (me.MaximumHealth * 0.4)
                      && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                      && Utils.SleepCheck("W")
                      )
                {
                    W.UseAbility(me.Position);
                    Utils.Sleep(200, "W");
                }
                if ( // Hellbard
                    halberd != null
                    && halberd.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && (e.NetworkActivity == NetworkActivity.Attack
                        || e.NetworkActivity == NetworkActivity.Crit
                        || e.NetworkActivity == NetworkActivity.Attack2)
                    && Utils.SleepCheck("halberd")
                    && me.Distance2D(e) <= 700
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(halberd.Name)
                    )
                {
                    halberd.UseAbility(e);
                    Utils.Sleep(250, "halberd");
                }
                if ( // Satanic
                    satanic != null &&
                    me.Health <= (me.MaximumHealth * 0.3) &&
                    satanic.CanBeCasted() &&
                    me.Distance2D(e) <= me.AttackRange + 50
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                    && Utils.SleepCheck("satanic")
                    )
                {
                    satanic.UseAbility();
                    Utils.Sleep(240, "satanic");
                } // Satanic Item end
                if (mail != null && mail.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                           (Menu.Item("Heelm").GetValue<Slider>().Value)) &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mail.Name) && Utils.SleepCheck("mail"))
                {
                    mail.UseAbility();
                    Utils.Sleep(100, "mail");
                }
                if (bkb != null && bkb.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                         (Menu.Item("Heel").GetValue<Slider>().Value)) &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(bkb.Name) && Utils.SleepCheck("bkb"))
                {
                    bkb.UseAbility();
                    Utils.Sleep(100, "bkb");
                }
            }
        }
Пример #5
0
        public static void Game_OnUpdate(EventArgs args)
        {
            var me = ObjectMgr.LocalHero;

            var target = me.ClosestToMouseTarget(1200);

            if (target == null)
            {
                return;
            }
            if (activated && target.IsAlive && !target.IsInvul() && Game.MousePosition.Distance2D(target) <= 1000 || target.Distance2D(me) <= 600)
            {

                //spell
                var CheckStun = target.Modifiers.Any(y => y.Name == "modifier_centaur_hoof_stomp");
                var CheckSetka = target.Modifiers.Any(y => y.Name == "modifier_dark_troll_warlord_ensnare");
                var Neutrals = ObjectMgr.GetEntities<Creep>().Where(creep => (creep.ClassID == ClassID.CDOTA_BaseNPC_Creep_Lane || creep.ClassID == ClassID.CDOTA_BaseNPC_Creep_Siege || creep.ClassID == ClassID.CDOTA_BaseNPC_Creep_Neutral || creep.ClassID == ClassID.CDOTA_BaseNPC_Invoker_Forged_Spirit || creep.ClassID == ClassID.CDOTA_BaseNPC_Creep &&
                 creep.IsAlive && creep.IsVisible && creep.IsSpawned) && creep.Team == me.GetEnemyTeam()).ToList();
                var Neutral = ObjectMgr.GetEntities<Creep>().Where(creep => ( creep.ClassID == ClassID.CDOTA_BaseNPC_Creep_Neutral &&
                 creep.IsAlive ) && creep.Team == me.GetEnemyTeam()).ToList();

                var troll = ObjectMgr.GetEntities<Creep>().Where(unit => unit.Name == "npc_dota_neutral_dark_troll_warlord").ToList();
                if (troll == null)
                {
                    return;
                }
                    foreach (var v in troll)
                    {

                        if (target.Position.Distance2D(v.Position) < 550 && (!CheckSetka || !CheckStun || target.IsHexed() || target.IsStunned()) && v.Spellbook.SpellQ.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Spellbook.SpellQ.UseAbility(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                        if (target.Position.Distance2D(v.Position) < 1550 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var lizard = ObjectMgr.GetEntities<Creep>().Where(unit => unit.Name == "npc_dota_neutral_big_thunder_lizard").ToList();
                if (lizard == null)
                {
                    return;
                }

                    foreach (var v in lizard)
                    {

                        if (target.Position.Distance2D(v.Position) < 250 && v.Spellbook.SpellQ.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Spellbook.SpellQ.UseAbility();
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                        if (target.Position.Distance2D(v.Position) < 550 && v.Spellbook.SpellQ.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Spellbook.SpellW.UseAbility();
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                        if (target.Position.Distance2D(v.Position) < 1550 &&
                          Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var centaur = ObjectMgr.GetEntities<Creep>().Where(unit => unit.Name == "npc_dota_neutral_centaur_khan").ToList();
                if (centaur == null)
                {
                    return;
                }
                    foreach (var v in centaur)
                    {

                        if (target.Position.Distance2D(v.Position) < 200 && (!CheckSetka || !CheckStun || target.IsHexed() || target.IsStunned()) && v.Spellbook.SpellQ.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Spellbook.SpellQ.UseAbility();
                            Utils.Sleep(300, v.Handle.ToString());
                        }

                        if (target.Position.Distance2D(v.Position) < 1550 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var satyr = ObjectMgr.GetEntities<Creep>().Where(unit => unit.Name == "npc_dota_neutral_satyr_hellcaller").ToList();
                if (satyr == null)
                {
                    return;
                }

                    foreach (var v in satyr)
                    {

                        if (target.Position.Distance2D(v.Position) < 850 && v.Spellbook.SpellQ.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Spellbook.SpellQ.UseAbility(target.Position);
                            Utils.Sleep(300, v.Handle.ToString());
                        }

                        if (target.Position.Distance2D(v.Position) < 1550 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var ursa = ObjectMgr.GetEntities<Creep>().Where(unit => unit.Name == "npc_dota_neutral_polar_furbolg_ursa_warrior").ToList();
                if (ursa == null)
                {
                    return;
                }
                    foreach (var v in ursa)
                    {

                        if (target.Position.Distance2D(v.Position) < 240 && v.Spellbook.SpellQ.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Spellbook.SpellQ.UseAbility();
                            Utils.Sleep(300, v.Handle.ToString());
                        }

                        if (target.Position.Distance2D(v.Position) < 1550 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var Sigl = ObjectMgr.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_BaseNPC_Tusk_Sigil)
                        && x.IsAlive && x.IsControllable);
                if (Sigl == null)
                {
                    return;
                }
                    foreach (var v in Sigl)
                    {

                        if (target.Position.Distance2D(v.Position) < 1550 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Follow(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var InvForgeds = ObjectMgr.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_BaseNPC_Invoker_Forged_Spirit)
                        && x.IsAlive && x.IsControllable);
                if (InvForgeds == null)
                {
                    return;
                }

                    foreach (var v in InvForgeds)
                    {

                        if (target.Position.Distance2D(v.Position) < 1550 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var WarlockGolem = ObjectMgr.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_BaseNPC_Warlock_Golem)
                        && x.IsAlive && x.IsControllable);
                if (WarlockGolem == null)
                {
                    return;
                }
                    foreach (var v in WarlockGolem)
                    {

                        if (target.Position.Distance2D(v.Position) < 1550 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var Necronomicons = ObjectMgr.GetEntities<Creep>().Where(x => (x.ClassID == ClassID.CDOTA_BaseNPC_Creep)
                        && x.IsAlive && x.IsControllable);
                if (Necronomicons == null)
                {
                    return;
                }
                    foreach (var v in Necronomicons)
                    {

                        var archer = ObjectMgr.GetEntities<Unit>().Where(unit => unit.Name == "npc_dota_necronomicon_archer").ToList();
                        if (archer != null && target.Position.Distance2D(v.Position) <= 650 && v.Spellbook.SpellQ.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))

                        {
                            v.Spellbook.SpellQ.UseAbility(target);
                            Utils.Sleep(300, v.Handle.ToString());
                        }

                        if (target.Position.Distance2D(v.Position) < 1550 &&
                           Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var spiritbear = ObjectMgr.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_Unit_SpiritBear)
                       && x.IsAlive && x.IsControllable);
                if (spiritbear == null)
                {
                    return;
                }
                 var aghanim = me.FindItem("item_phase_boots");
                foreach (var v in spiritbear)
                    if ((!me.AghanimState() && me.Position.Distance2D(v) <= 1200) || me.AghanimState())
                    {

                        var abyssal = v.FindItem("item_abyssal_blade");
                        var mjollnir = v.FindItem("item_mjollnir");
                        var boots = v.FindItem("item_phase_boots");
                        midas = v.FindItem("item_hand_of_midas");

                        if (target.Position.Distance2D(v.Position) < 1550 && boots.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.FindItem("item_phase_boots").UseAbility();
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                        if (target.Position.Distance2D(v.Position) < 525 && mjollnir.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.FindItem("item_mjollnir").UseAbility(v);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                        if (target.Position.Distance2D(v.Position) < 170 && abyssal.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.FindItem("item_abyssal_blade").UseAbility(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                        if (target.Position.Distance2D(v.Position) < 525 && mjollnir.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.FindItem("item_mjollnir").UseAbility(v);
                            Utils.Sleep(700, v.Handle.ToString());
                        }

                        foreach (var f in Neutrals)
                        {
                            if (target.Position.Distance2D(f.Position) < 650 && midas.CanBeCasted() &&
                                Utils.SleepCheck(f.Handle.ToString()))
                            {
                                v.FindItem("item_hand_of_midas").UseAbility(f);
                                Utils.Sleep(700, f.Handle.ToString());
                            }
                        }
                        if (target.Position.Distance2D(v.Position) < 1550 &&
                        Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var Familliar = ObjectMgr.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_Unit_VisageFamiliar)
                      && x.IsAlive && x.IsControllable);
                if (Familliar == null)
                {
                    return;
                }
                    foreach (var v in Familliar)
                    {
                        var damageModif = v.Modifiers.FirstOrDefault(x => x.Name == "modifier_visage_summon_familiars_damage_charge");

                        if (target.Position.Distance2D(v.Position) < 1550 && v.Health < 5 && v.Spellbook.Spell1.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Spellbook.Spell1.UseAbility();
                            Utils.Sleep(700, v.Handle.ToString());
                        }

                        if (target.Position.Distance2D(v.Position) < 340 && ((damageModif.StackCount < 1)  && !target.IsStunned()) && v.Spellbook.Spell1.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Spellbook.Spell1.UseAbility();
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                        if (target.Position.Distance2D(v.Position) < 1550 &&
                           Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var primalearth = ObjectMgr.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_Unit_Brewmaster_PrimalEarth)
                    && x.IsAlive && x.IsControllable);
                if (primalearth == null)
                {
                    return;
                }
                    foreach (var v in primalearth)
                    {

                        if (target.Position.Distance2D(v.Position) < 850 && v.Spellbook.SpellQ.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Spellbook.SpellQ.UseAbility(target);
                            Utils.Sleep(400, v.Handle.ToString());
                        }
                        if (target.Position.Distance2D(v.Position) < 340 && v.Spellbook.SpellR.CanBeCasted() &&
                           Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Spellbook.SpellR.UseAbility();
                            Utils.Sleep(400, v.Handle.ToString());
                        }

                        if (target.Position.Distance2D(v.Position) < 1550 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var primalstorm = ObjectMgr.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_Unit_Brewmaster_PrimalStorm)
                       && x.IsAlive && x.IsControllable);
                if (primalstorm == null)
                {
                    return;
                }

                    foreach (var v in primalstorm)
                    {

                        if (target.Position.Distance2D(v.Position) < 500 && v.Spellbook.SpellQ.CanBeCasted() &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Spellbook.SpellQ.UseAbility(target.Position);
                            Utils.Sleep(400, v.Handle.ToString());
                        }
                        if (target.Position.Distance2D(v.Position) < 850 && v.Spellbook.SpellR.CanBeCasted() &&
                           Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Spellbook.SpellR.UseAbility(target);
                            Utils.Sleep(400, v.Handle.ToString());
                        }
                        if (target.Position.Distance2D(v.Position) < 1550 &&
                           Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var primalfire = ObjectMgr.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_Unit_Brewmaster_PrimalFire)
                       && x.IsAlive && x.IsControllable);
                if (primalfire == null)
                {
                    return;
                }
                    foreach (var v in primalfire)
                    {

                        if (target.Position.Distance2D(v.Position) < 1550 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var boar = ObjectMgr.GetEntities<Unit>().Where(unit => unit.Name == "npc_dota_beastmaster_boar_1").ToList();
                if (boar == null)
                {
                    return;
                }
                    foreach (var v in boar)
                    {

                        if (target.Position.Distance2D(v.Position) < 1550 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var eidolon = ObjectMgr.GetEntities<Unit>().Where(unit => unit.Name == "npc_dota_eidolon").ToList();
                if (eidolon == null)
                {
                    return;
                }
                    foreach (var v in eidolon)
                    {

                        if (target.Position.Distance2D(v.Position) < 1550 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var Ward = ObjectMgr.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_NPC_WitchDoctor_Ward)
                       && x.IsAlive && x.IsControllable);
                if (Ward == null)
                {
                    return;
                }

                    foreach (var v in Ward)
                    {

                        if (target.Position.Distance2D(v.Position) < 900 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var Wolf = ObjectMgr.GetEntities<Creep>().Where(x => (x.ClassID == ClassID.CDOTA_BaseNPC_Creep_Neutral)
                     && x.IsAlive && x.IsControllable);
                if (Wolf == null)
                {
                    return;
                }
                    foreach (var v in Wolf)
                    {

                        if (target.Position.Distance2D(v.Position) < 1550 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

                var SerpentWard = ObjectMgr.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_BaseNPC_ShadowShaman_SerpentWard)
                    && x.IsAlive && x.IsControllable);
                if (SerpentWard == null)
                {
                    return;
                }

                    foreach (var v in SerpentWard)
                    {

                        if (target.Position.Distance2D(v.Position) < 650 &&
                            Utils.SleepCheck(v.Handle.ToString()))
                        {
                            v.Attack(target);
                            Utils.Sleep(700, v.Handle.ToString());
                        }
                    }

            }
        }
        public void Combo()
        {
            if (!Game.IsInGame || Game.IsPaused || Game.IsWatchingGame)
                return;

            //manta (when silenced)

            target = me.ClosestToMouseTarget(2000);
            if (target == null) return;
            Active = Game.IsKeyDown(menu.Item("Combo Key").GetValue<KeyBind>().Key) && !Game.IsChatOpen;
            Q = me.Spellbook.SpellQ;

            W = me.Spellbook.SpellW;

            R = me.Spellbook.SpellR;

            // item
            sheep = target.ClassID == ClassID.CDOTA_Unit_Hero_Tidehunter ? null : me.FindItem("item_sheepstick");

            satanic = me.FindItem("item_satanic");

            shiva = me.FindItem("item_shivas_guard");

            dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));

            arcane = me.FindItem("item_arcane_boots");

            mom = me.FindItem("item_mask_of_madness");

            vail = me.FindItem("item_veil_of_discord");

            medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");

            ethereal = me.FindItem("item_ethereal_blade");

            blink = me.FindItem("item_blink");

            soulring = me.FindItem("item_soul_ring");

            cheese = me.FindItem("item_cheese");

            halberd = me.FindItem("item_heavens_halberd");

            abyssal = me.FindItem("item_abyssal_blade");

            mjollnir = me.FindItem("item_mjollnir");
            var stoneModif = target.HasModifier("modifier_medusa_stone_gaze_stone");
            var linkens = target.IsLinkensProtected();
            var noBlade = target.HasModifier("modifier_item_blade_mail_reflect");
            if (Active && me.IsAlive && target.IsAlive)
            {
                if (target.IsVisible && me.Distance2D(target) <= 2300 && !noBlade)
                {
                    if (
                        me.Distance2D(target) <= 300 && (!me.IsAttackImmune() || !target.IsAttackImmune())
                        && me.NetworkActivity != NetworkActivity.Attack && me.CanAttack() && Utils.SleepCheck("attack")
                        )
                    {
                        me.Attack(target);
                        Utils.Sleep(190, "attack");
                    }
                    else if (
                         ((!me.CanAttack() && me.Distance2D(target) >= 0) || me.Distance2D(target) >= 300) && me.NetworkActivity != NetworkActivity.Attack &&
                         me.Distance2D(target) <= 1500 && Utils.SleepCheck("Move")
                         )
                    {
                        me.Move(target.Predict(350));
                        Utils.Sleep(350, "Move");
                    }
                    if (
                        R != null
                        && R.CanBeCasted()
                        && !me.HasModifier("modifier_nyx_assassin_vendetta")
                        && me.Distance2D(target) <= 1400
                        && menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                        && Utils.SleepCheck("R")
                        )
                    {
                        R.UseAbility();
                        Utils.Sleep(200, "R");
                    }
                    if (me.HasModifier("modifier_nyx_assassin_vendetta"))
                        return;
                    if (!R.CanBeCasted() ||
                        R == null || !me.HasModifier("modifier_nyx_assassin_vendetta") || !menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name))
                    {
                        if (stoneModif) return;
                        float angle = me.FindAngleBetween(target.Position, true);
                        Vector3 pos = new Vector3((float)(target.Position.X - 100 * Math.Cos(angle)), (float)(target.Position.Y - 100 * Math.Sin(angle)), 0);
                        if (
                            blink != null
                            && Q.CanBeCasted()
                            && me.CanCast()
                            && blink.CanBeCasted()
                            && me.Distance2D(target) >= 300
                            && me.Distance2D(pos) <= 1180
                            && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                            && Utils.SleepCheck("blink")
                            )
                        {
                            blink.UseAbility(pos);
                            Utils.Sleep(250, "blink");
                        }
                        if ( // vail
                            vail != null
                            && vail.CanBeCasted()
                            && me.CanCast()
                            && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name)
                            && !target.IsMagicImmune()
                            && Utils.SleepCheck("vail")
                            && me.Distance2D(target) <= 1500
                            )
                        {
                            vail.UseAbility(target.Position);
                            Utils.Sleep(250, "vail");
                        }

                        if ( // ethereal
                            ethereal != null &&
                            ethereal.CanBeCasted()
                            && (!vail.CanBeCasted()
                                || vail == null)
                            && me.CanCast() &&
                            !linkens &&
                            !target.IsMagicImmune() &&
                            Utils.SleepCheck("ethereal")
                            )
                        {
                            ethereal.UseAbility(target);
                            Utils.Sleep(150, "ethereal");
                        }

                        if ((vail == null || !vail.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name)) && (ethereal == null || !ethereal.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name)))
                        {
                            if ( // sheep
                                sheep != null
                                && sheep.CanBeCasted()
                                && me.CanCast()
                                && !target.IsLinkensProtected()
                                && !target.IsMagicImmune()
                                && me.Distance2D(target) <= 1400
                                && !stoneModif
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(sheep.Name)
                                && Utils.SleepCheck("sheep")
                                )
                            {
                                sheep.UseAbility(target);
                                Utils.Sleep(250, "sheep");
                            } // sheep Item end
                            if (Q.CanBeCasted()
                                && me.Position.Distance2D(target.Position) < Q.CastRange - 50
                                && !target.IsMagicImmune()
                                && menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                                && Utils.SleepCheck("Q"))
                            {
                                Q.CastSkillShot(target);
                                Utils.Sleep(90, "Q");
                            }
                            if (W.CanBeCasted()
                                && menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                                && me.Position.Distance2D(target.Position) < 800
                                && Utils.SleepCheck("W"))
                            {
                                W.UseAbility(target);
                                Utils.Sleep(60, "W");
                            }

                            if ( // SoulRing Item
                                soulring != null &&
                                me.Health >= (me.MaximumHealth * 0.3) &&
                                me.Mana <= R.ManaCost &&
                                soulring.CanBeCasted()
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(soulring.Name))
                            {
                                soulring.UseAbility();
                            } // SoulRing Item end

                            if ( // Arcane Boots Item
                                arcane != null &&
                                me.Mana <= Q.ManaCost &&
                                arcane.CanBeCasted()
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(arcane.Name))
                            {
                                arcane.UseAbility();
                            } // Arcane Boots Item end

                            if ( // Shiva Item
                                shiva != null &&
                                shiva.CanBeCasted() &&
                                me.CanCast() &&
                                !target.IsMagicImmune() &&
                                Utils.SleepCheck("shiva") &&
                                me.Distance2D(target) <= 600
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(shiva.Name)
                                )
                            {
                                shiva.UseAbility();
                                Utils.Sleep(250, "shiva");
                            } // Shiva Item end

                            if ( // Medall
                                medall != null &&
                                medall.CanBeCasted() &&
                                me.CanCast() &&
                                !target.IsMagicImmune() &&
                                Utils.SleepCheck("Medall")
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                                && me.Distance2D(target) <= 500
                                )
                            {
                                medall.UseAbility(target);
                                Utils.Sleep(250, "Medall");
                            } // Medall Item end

                            if ( // MOM
                                mom != null &&
                                mom.CanBeCasted() &&
                                me.CanCast() &&
                                Utils.SleepCheck("mom") &&
                                me.Distance2D(target) <= 700
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mom.Name)
                                )
                            {
                                mom.UseAbility();
                                Utils.Sleep(250, "mom");
                            } // MOM Item end

                            if (
                                // cheese
                                cheese != null
                                && cheese.CanBeCasted()
                                && me.Health <= (me.MaximumHealth * 0.3)
                                && me.Distance2D(target) <= 700
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(cheese.Name)
                                && Utils.SleepCheck("cheese")
                                )
                            {
                                cheese.UseAbility();
                                Utils.Sleep(200, "cheese");
                            } // cheese Item end
                            if ( // Abyssal Blade
                                abyssal != null &&
                                abyssal.CanBeCasted() &&
                                me.CanCast() &&
                                !target.IsMagicImmune() &&
                                Utils.SleepCheck("abyssal") &&
                                me.Distance2D(target) <= 400
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(abyssal.Name)
                                )
                            {
                                abyssal.UseAbility(target);
                                Utils.Sleep(250, "abyssal");
                            } // Abyssal Item end

                            if ( // Hellbard
                                halberd != null &&
                                halberd.CanBeCasted() &&
                                me.CanCast() &&
                                !target.IsMagicImmune() &&
                                Utils.SleepCheck("halberd") &&
                                me.Distance2D(target) <= 700
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(halberd.Name)
                                )
                            {
                                halberd.UseAbility(target);
                                Utils.Sleep(250, "halberd");
                            } // Hellbard Item end

                            if ( // Dagon
                                me.CanCast()
                                && dagon != null
                                && (ethereal == null
                                    || (target.HasModifier("modifier_item_ethereal_blade_slow")
                                        || ethereal.Cooldown < 17))
                                && !target.IsLinkensProtected()
                                && dagon.CanBeCasted()
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled("item_dagon")
                                && !target.IsMagicImmune()
                                && !stoneModif
                                && Utils.SleepCheck("dagon")
                                )
                            {
                                dagon.UseAbility(target);
                                Utils.Sleep(200, "dagon");
                            } // Dagon Item end

                            if ( // Mjollnir
                                mjollnir != null &&
                                mjollnir.CanBeCasted() &&
                                me.CanCast() &&
                                !target.IsMagicImmune() &&
                                Utils.SleepCheck("mjollnir")
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                                && me.Distance2D(target) <= 900
                                )
                            {
                                mjollnir.UseAbility(me);
                                Utils.Sleep(250, "mjollnir");
                            } // Mjollnir Item end

                            if ( // Satanic
                                satanic != null &&
                                me.Health <= (me.MaximumHealth * 0.3) &&
                                satanic.CanBeCasted() &&
                                me.Distance2D(target) <= 700 &&
                                Utils.SleepCheck("Satanic")
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                                )
                            {
                                satanic.UseAbility();
                                Utils.Sleep(350, "Satanic");
                            } // Satanic Item end
                        }
                    }
                }
            }
        }
        public void Combo()
        {
            if (!Menu.Item("enabled").IsActive())
                return;

            e = Toolset.ClosestToMouse(me);
            if (e == null)
                return;
            Q = me.Spellbook.SpellQ;
            W = me.Spellbook.SpellW;
            R = me.Spellbook.SpellR;
            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key);

            Shiva = me.FindItem("item_shivas_guard");
            ethereal = me.FindItem("item_ethereal_blade");
            mom = me.FindItem("item_mask_of_madness");
            urn = me.FindItem("item_urn_of_shadows");
            dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));
            halberd = me.FindItem("item_heavens_halberd");
            mjollnir = me.FindItem("item_mjollnir");
            orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");
            abyssal = me.FindItem("item_abyssal_blade");
            mail = me.FindItem("item_blade_mail");
            bkb = me.FindItem("item_black_king_bar");
            satanic = me.FindItem("item_satanic");
            blink = me.FindItem("item_blink");
            medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");
            cyclone = me.FindItem("item_cyclone");
            force = me.FindItem("item_force_staff");
            sheep = e.ClassID == ClassID.CDOTA_Unit_Hero_Tidehunter ? null : me.FindItem("item_sheepstick");
            cheese = me.FindItem("item_cheese");
            soul = me.FindItem("item_soul_ring");
            arcane = me.FindItem("item_arcane_boots");
            stick = me.FindItem("item_magic_stick") ?? me.FindItem("item_magic_wand");
            phase = me.FindItem("item_phase_boots");
            var v =
                ObjectManager.GetEntities<Hero>()
                    .Where(x => x.Team != me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion && !x.IsMagicImmune())
                    .ToList();

            var stoneModif = e.Modifiers.Any(y => y.Name == "modifier_medusa_stone_gaze_stone");
            var modifR = e.Modifiers.Any(y => y.Name == "modifier_bloodseeker_rupture");
            var modifQ = e.HasModifier("modifier_bloodseeker_bloodrage");
            if (Active && me.Distance2D(e) <= 1400 && e != null && e.IsAlive)
            {
                if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900)
                {
                    Orbwalking.Orbwalk(e, 0, 1600, true, true);
                }
            }
            if (Active && me.Distance2D(e) <= 1400 && e != null && e.IsAlive && !me.IsInvisible())
            {
                if (cyclone != null && cyclone.CanBeCasted() && W.CanBeCasted()
                       && me.Distance2D(e) <= cyclone.GetCastRange() + 300
                       && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(cyclone.Name)
                       && W.CanBeCasted()
                       && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                       && Utils.SleepCheck(me.Handle.ToString()))
                {
                    cyclone.UseAbility(e);
                    Utils.Sleep(500, me.Handle.ToString());
                }
                if (
                       Q != null && Q.CanBeCasted() && me.Distance2D(e) <= 700
                       && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                       && !modifQ
                       && Utils.SleepCheck("Q")
                       )
                {
                    Q.UseAbility(me);
                    Utils.Sleep(200, "Q");
                }
                if (
                      W != null && W.CanBeCasted() && me.Distance2D(e) <= 700
                      &&
                      (!cyclone.CanBeCasted() || cyclone == null ||
                       !Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(cyclone.Name))
                      && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                      && Utils.SleepCheck("W")
                      )
                {
                    W.UseAbility(e.Predict(300));
                    Utils.Sleep(200, "W");
                }

                if (
                    force != null
                    && force.CanBeCasted()
                    && me.Distance2D(e) < 800
                    && modifR
                    && e.IsSilenced()
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(force.Name)
                    && Utils.SleepCheck("force"))
                {
                    force.UseAbility(e);
                    Utils.Sleep(240, "force");
                }
                if (cyclone == null || !cyclone.CanBeCasted() || !Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(cyclone.Name))
                {

                    if (
                        R != null && R.CanBeCasted() && me.Distance2D(e) <= 900
                        && !e.HasModifier("modifier_bloodseeker_rupture")
                        && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                        && Utils.SleepCheck("R")
                        )
                    {
                        R.UseAbility(e);
                        Utils.Sleep(500, "R");
                    }
                    if ( // MOM
                        mom != null
                        && mom.CanBeCasted()
                        && me.CanCast()
                        && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(mom.Name)
                        && Utils.SleepCheck("mom")
                        && me.Distance2D(e) <= 700
                        )
                    {
                        mom.UseAbility();
                        Utils.Sleep(250, "mom");
                    }
                    if ( // Hellbard
                        halberd != null
                        && halberd.CanBeCasted()
                        && me.CanCast()
                        && !e.IsMagicImmune()
                        && (e.NetworkActivity == NetworkActivity.Attack
                            || e.NetworkActivity == NetworkActivity.Crit
                            || e.NetworkActivity == NetworkActivity.Attack2)
                        && Utils.SleepCheck("halberd")
                        && me.Distance2D(e) <= 700
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(halberd.Name)
                        )
                    {
                        halberd.UseAbility(e);
                        Utils.Sleep(250, "halberd");
                    }
                    if ( // Arcane Boots Item
                        arcane != null
                        && me.Mana <= R.ManaCost
                        && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(arcane.Name)
                        && arcane.CanBeCasted()
                        && Utils.SleepCheck("arcane")
                        )
                    {
                        arcane.UseAbility();
                        Utils.Sleep(250, "arcane");
                    } // Arcane Boots Item end
                    if ( // Mjollnir
                        mjollnir != null
                        && mjollnir.CanBeCasted()
                        && me.CanCast()
                        && !e.IsMagicImmune()
                        && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                        && Utils.SleepCheck("mjollnir")
                        && me.Distance2D(e) <= 900
                        )
                    {
                        mjollnir.UseAbility(me);
                        Utils.Sleep(250, "mjollnir");
                    } // Mjollnir Item end
                    if (
                        // cheese
                        cheese != null
                        && cheese.CanBeCasted()
                        && me.Health <= (me.MaximumHealth * 0.3)
                        && me.Distance2D(e) <= 700
                        && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(cheese.Name)
                        && Utils.SleepCheck("cheese")
                        )
                    {
                        cheese.UseAbility();
                        Utils.Sleep(200, "cheese");
                    } // cheese Item end
                    if ( // Medall
                        medall != null
                        && medall.CanBeCasted()
                        && Utils.SleepCheck("Medall")
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                        && me.Distance2D(e) <= 700
                        )
                    {
                        medall.UseAbility(e);
                        Utils.Sleep(250, "Medall");
                    } // Medall Item end

                    if ( // sheep
                        sheep != null
                        && sheep.CanBeCasted()
                        && me.CanCast()
                        && !e.IsLinkensProtected()
                        && !e.IsMagicImmune()
                        && me.Distance2D(e) <= 1400
                        && !stoneModif
                        && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(sheep.Name)
                        && Utils.SleepCheck("sheep")
                        )
                    {
                        sheep.UseAbility(e);
                        Utils.Sleep(250, "sheep");
                    } // sheep Item end
                    if ( // Abyssal Blade
                        abyssal != null
                        && abyssal.CanBeCasted()
                        && me.CanCast()
                        && !e.IsStunned()
                        && !e.IsHexed()
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(abyssal.Name)
                        && Utils.SleepCheck("abyssal")
                        && me.Distance2D(e) <= 400
                        )
                    {
                        abyssal.UseAbility(e);
                        Utils.Sleep(250, "abyssal");
                    } // Abyssal Item end
                    if (orchid != null && orchid.CanBeCasted() && me.Distance2D(e) <= 900
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name) &&
                        Utils.SleepCheck("orchid"))
                    {
                        orchid.UseAbility(e);
                        Utils.Sleep(100, "orchid");
                    }

                    if (Shiva != null && Shiva.CanBeCasted() && me.Distance2D(e) <= 600
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name)
                        && !e.IsMagicImmune() && Utils.SleepCheck("Shiva"))
                    {
                        Shiva.UseAbility();
                        Utils.Sleep(100, "Shiva");
                    }
                    if ( // ethereal
                        ethereal != null
                        && ethereal.CanBeCasted()
                        && me.CanCast()
                        && !e.IsLinkensProtected()
                        && !e.IsMagicImmune()
                        && !stoneModif
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name)
                        && Utils.SleepCheck("ethereal")
                        )
                    {
                        ethereal.UseAbility(e);
                        Utils.Sleep(200, "ethereal");
                    } // ethereal Item end
                    if (
                        blink != null
                        && me.CanCast()
                        && blink.CanBeCasted()
                        && me.Distance2D(e) >= 450
                        && me.Distance2D(e) <= 1150
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                        && Utils.SleepCheck("blink")
                        )
                    {
                        blink.UseAbility(e.Position);
                        Utils.Sleep(250, "blink");
                    }

                    if ( // SoulRing Item
                        soul != null
                        && soul.CanBeCasted()
                        && me.CanCast()
                        && me.Health >= (me.MaximumHealth * 0.5)
                        && me.Mana <= R.ManaCost
                        && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(soul.Name)
                        )
                    {
                        soul.UseAbility();
                    } // SoulRing Item end
                    if ( // Dagon
                        me.CanCast()
                        && dagon != null
                        && (ethereal == null
                            || (e.Modifiers.Any(y => y.Name == "modifier_item_ethereal_blade_slow")
                                || ethereal.Cooldown < 17))
                        && !e.IsLinkensProtected()
                        && dagon.CanBeCasted()
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled("item_dagon")
                        && !e.IsMagicImmune()
                        && !stoneModif
                        && Utils.SleepCheck("dagon")
                        )
                    {
                        dagon.UseAbility(e);
                        Utils.Sleep(200, "dagon");
                    } // Dagon Item end
                    if (phase != null
                        && phase.CanBeCasted()
                        && Utils.SleepCheck("phase")
                        && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(phase.Name)
                        && !blink.CanBeCasted()
                        && me.Distance2D(e) >= me.AttackRange + 20)
                    {
                        phase.UseAbility();
                        Utils.Sleep(200, "phase");
                    }
                    if (urn != null && urn.CanBeCasted() && urn.CurrentCharges > 0 && me.Distance2D(e) <= 400
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(urn.Name) && Utils.SleepCheck("urn"))
                    {
                        urn.UseAbility(e);
                        Utils.Sleep(240, "urn");
                    }
                    if (
                        stick != null
                        && stick.CanBeCasted()
                        && stick.CurrentCharges != 0
                        && me.Distance2D(e) <= 700
                        && (me.Health <= (me.MaximumHealth * 0.5)
                            || me.Mana <= (me.MaximumMana * 0.5))
                        && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(stick.Name))
                    {
                        stick.UseAbility();
                        Utils.Sleep(200, "mana_items");
                    }
                    if ( // Satanic
                        satanic != null &&
                        me.Health <= (me.MaximumHealth * 0.3) &&
                        satanic.CanBeCasted() &&
                        me.Distance2D(e) <= me.AttackRange + 50
                        && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                        && Utils.SleepCheck("satanic")
                        )
                    {
                        satanic.UseAbility();
                        Utils.Sleep(240, "satanic");
                    } // Satanic Item end
                    if (mail != null && mail.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                               (Menu.Item("Heelm").GetValue<Slider>().Value)) &&
                        Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mail.Name) && Utils.SleepCheck("mail"))
                    {
                        mail.UseAbility();
                        Utils.Sleep(100, "mail");
                    }
                    if (bkb != null && bkb.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                             (Menu.Item("Heel").GetValue<Slider>().Value)) &&
                        Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(bkb.Name) && Utils.SleepCheck("bkb"))
                    {
                        bkb.UseAbility();
                        Utils.Sleep(100, "bkb");
                    }

                }
            }
        }
Пример #8
0
        public static void Game_OnUpdate(EventArgs args)
        {
            var me = ObjectMgr.LocalHero;

            if (!Game.IsInGame || me.ClassID != ClassID.CDOTA_Unit_Hero_Pugna || me == null)
            {
                return;
            }

            var target = me.ClosestToMouseTarget(2000);
            if (target == null)
            {
                return;
            }

            //spell
            Q = me.Spellbook.SpellQ;

            W = me.Spellbook.SpellW;

            E = me.Spellbook.SpellE;

            R = me.Spellbook.SpellR;

            // Item
            ethereal = me.FindItem("item_ethereal_blade");

            sheep = target.ClassID == ClassID.CDOTA_Unit_Hero_Tidehunter ? null : me.FindItem("item_sheepstick");

            vail = me.FindItem("item_veil_of_discord");

            cheese = me.FindItem("item_cheese");

            ghost = me.FindItem("item_ghost");

            orchid = me.FindItem("item_orchid");

            atos = me.FindItem("item_rod_of_atos");

            soulring = me.FindItem("item_soul_ring");

            arcane = me.FindItem("item_arcane_boots");

            blink = me.FindItem("item_blink");

            shiva = me.FindItem("item_shivas_guard");

            dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));

            var ModifRod = target.Modifiers.Any(y => y.Name == "modifier_rod_of_atos_debuff");
            var ModifEther = target.Modifiers.Any(y => y.Name == "modifier_item_ethereal_blade_slow");
            var ModifVail = target.Modifiers.Any(y => y.Name == "modifier_item_veil_of_discord_debuff");
            var stoneModif = target.Modifiers.Any(y => y.Name == "modifier_medusa_stone_gaze_stone");

            if (activated && me.IsAlive && target.IsAlive && Utils.SleepCheck("activated"))
            {
                var noBlade = target.Modifiers.Any(y => y.Name == "modifier_item_blade_mail_reflect");
                if (R.IsInAbilityPhase || me.Modifiers.Any(y => y.Name == "modifier_pugna_life_drain") )
                    return;
                if (target.IsVisible && me.Distance2D(target) <= 2300 && !noBlade)
                {
                    if ((!me.IsChanneling() && !me.AghanimState()) || me.AghanimState())
                    {
                        if (
                                         blink != null
                                         && W.CanBeCasted()
                                         && me.CanCast()
                                         && blinkToggle
                                         && blink.CanBeCasted()
                                         && me.Distance2D(target) > 600
                                         && me.Distance2D(target) < 1150
                                         && !stoneModif
                                         && Utils.SleepCheck("blink")
                               )
                        {
                            blink.UseAbility(target.Position);
                            Utils.Sleep(250, "blink");
                        }
                        if (
                                             W != null
                                             && W.CanBeCasted()
                                             && (target.IsLinkensProtected()
                                             || !target.IsLinkensProtected())
                                             && me.CanCast()
                                             && me.Distance2D(target) < 1400
                                             && !stoneModif
                                             && Utils.SleepCheck("W")
                               )
                        {
                            W.UseAbility(target);
                            Utils.Sleep(200, "W");
                        }
                        if ( // atos Blade
                                      atos != null
                                     && atos.CanBeCasted()
                                     && me.CanCast()
                                     && !target.IsLinkensProtected()
                                     && !target.IsMagicImmune()
                                     && Utils.SleepCheck("atos")
                                     && me.Distance2D(target) <= 2000
                                      )
                        {
                            atos.UseAbility(target);
                            Utils.Sleep(250, "atos");
                        } // atos Item end
                        if (!W.CanBeCasted() || W == null)
                        {

                            if ( // atos Blade
                                           atos != null
                                          && atos.CanBeCasted()
                                          && me.CanCast()
                                          && !target.IsLinkensProtected()
                                          && !target.IsMagicImmune()
                                          && Utils.SleepCheck("atos")
                                          && me.Distance2D(target) <= 2000
                                           )
                            {
                                atos.UseAbility(target);
                                Utils.Sleep(250, "atos");
                            } // atos Item end

                            if (
                                                Q != null
                                               && Q.CanBeCasted()
                                               && me.CanCast()
                                               && me.Distance2D(target) < 1400
                                               && !stoneModif
                                               && Utils.SleepCheck("Q")
                                               )
                            {
                                Q.UseAbility(target.Position);
                                Utils.Sleep(200, "Q");
                            }
                            if ( // orchid
                                      orchid != null
                                      && orchid.CanBeCasted()
                                      && me.CanCast()
                                      && !target.IsLinkensProtected()
                                      && !target.IsMagicImmune()
                                      && Utils.SleepCheck("orchid")
                                      && me.Distance2D(target) <= 1400
                                      && !stoneModif
                                )
                            {
                                orchid.UseAbility(target);
                                Utils.Sleep(250 + Game.Ping, "orchid");
                            } // orchid Item end
                            if (!orchid.CanBeCasted() || orchid == null)
                            {
                                if ( // vail
                                       vail != null
                                      && vail.CanBeCasted()
                                      && me.CanCast()
                                      && !ModifVail
                                      && !target.IsMagicImmune()
                                      && Utils.SleepCheck("vail")
                                      && me.Distance2D(target) <= 1500
                                      )
                                {
                                    vail.UseAbility(target.Position);
                                    Utils.Sleep(250, "vail");
                                } // orchid Item end
                                if (!vail.CanBeCasted() || vail == null)
                                {

                                    if (// ethereal
                                           ethereal != null
                                           && ethereal.CanBeCasted()
                                           && me.CanCast()

                                           && !target.IsLinkensProtected()
                                           && !target.IsMagicImmune()
                                           && !stoneModif
                                           && Utils.SleepCheck("ethereal")
                                          )
                                    {
                                        ethereal.UseAbility(target);
                                        Utils.Sleep(200, "ethereal");
                                    } // ethereal Item end
                                    if (!ethereal.CanBeCasted() || ethereal == null)
                                    {

                                        if (// SoulRing Item
                                            soulring != null
                                            && soulring.CanBeCasted()
                                            && me.CanCast()
                                            && me.Health / me.MaximumHealth <= 0.5
                                            && me.Mana <= R.ManaCost
                                            )
                                        {
                                            soulring.UseAbility();
                                        } // SoulRing Item end

                                        if (// Arcane Boots Item
                                            arcane != null
                                            && arcane.CanBeCasted()
                                            && me.CanCast()
                                            && me.Mana <= R.ManaCost
                                            )
                                        {
                                            arcane.UseAbility();
                                        } // Arcane Boots Item end

                                        if (//Ghost
                                            ghost != null
                                            && ghost.CanBeCasted()
                                            && me.CanCast()
                                            && ((me.Position.Distance2D(target) < 300
                                            && me.Health <= (me.MaximumHealth * 0.7))
                                            || me.Health <= (me.MaximumHealth * 0.3))
                                            && Utils.SleepCheck("Ghost"))
                                        {
                                            ghost.UseAbility();
                                            Utils.Sleep(250, "Ghost");
                                        }

                                        if (// Shiva Item
                                            shiva != null
                                            && shiva.CanBeCasted()
                                            && me.CanCast()
                                            && !target.IsMagicImmune()
                                            && Utils.SleepCheck("shiva")
                                            && me.Distance2D(target) <= 600
                                            )

                                        {
                                            shiva.UseAbility();
                                            Utils.Sleep(250 + Game.Ping, "shiva");
                                        } // Shiva Item end

                                        if ( // sheep
                                            sheep != null
                                            && sheep.CanBeCasted()
                                            && me.CanCast()
                                            && !target.IsLinkensProtected()
                                            && !target.IsMagicImmune()
                                            && Utils.SleepCheck("sheep")
                                            && me.Distance2D(target) <= 1400
                                            && !stoneModif
                                            )
                                        {
                                            sheep.UseAbility(target);
                                            Utils.Sleep(250 + Game.Ping, "sheep");
                                        } // sheep Item end

                                        if (// Dagon
                                            me.CanCast()
                                            && dagon != null
                                            && (ethereal == null
                                            || (ModifEther
                                            || ethereal.Cooldown < 17))
                                            && !target.IsLinkensProtected()
                                            && dagon.CanBeCasted()
                                            && !target.IsMagicImmune()
                                            && !stoneModif
                                            && Utils.SleepCheck("dagon")
                                           )
                                        {
                                            dagon.UseAbility(target);
                                            Utils.Sleep(200, "dagon");
                                        } // Dagon Item end

                                        if (
                                             // cheese
                                             cheese != null
                                             && cheese.CanBeCasted()
                                             && Utils.SleepCheck("cheese")
                                             && me.Health <= (me.MaximumHealth * 0.3)
                                             && me.Distance2D(target) <= 700)
                                        {
                                            cheese.UseAbility();
                                            Utils.Sleep(200 + Game.Ping, "cheese");
                                        } // cheese Item end

                                    }
                                }
                            }
                        }
                        if (me.Modifiers.All(y => y.Name == "modifier_pugna_life_drain"))
                            return;
                        //, , , , arcane, blink, , , atos, , , ghost;
                        if (
                                       (R != null
                                       && R.CanBeCasted()
                                       && !me.IsChanneling()
                                       && !me.Modifiers.All(y => y.Name == "modifier_pugna_life_drain")
                                       && useUltimate
                                       && (!Q.CanBeCasted() || Q == null)
                                       && (!W.CanBeCasted() || W == null)
                                       && (!atos.CanBeCasted() || atos == null)
                                       && (!orchid.CanBeCasted() || orchid == null)
                                       && (!sheep.CanBeCasted() || sheep == null)
                                       && (!dagon.CanBeCasted() || dagon == null)
                                       && (!ethereal.CanBeCasted() || ethereal == null)
                                       && (!cheese.CanBeCasted() || cheese == null)
                                       && me.Position.Distance2D(target) < 1200
                                       && !stoneModif)

                                       && Utils.SleepCheck("R"))
                        {
                            R.UseAbility(target);
                            Utils.Sleep(330, "R");
                        }
                        return;
                    }
                }
                Utils.Sleep(200, "activated");
            }
        }
        public void Combo()
        {
            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key);

            Q = me.Spellbook.SpellQ;
            W = me.Spellbook.SpellW;
            R = me.Spellbook.SpellR;

            mom = me.FindItem("item_mask_of_madness");
            urn = me.FindItem("item_urn_of_shadows");
            dagon = me.Inventory.Items.FirstOrDefault(x => x.Name.Contains("item_dagon"));
            halberd = me.FindItem("item_heavens_halberd");
            mjollnir = me.FindItem("item_mjollnir");
            armlet = me.FindItem("item_armlet");
            abyssal = me.FindItem("item_abyssal_blade");
            mail = me.FindItem("item_blade_mail");
            bkb = me.FindItem("item_black_king_bar");
            blink = me.FindItem("item_blink");
            satanic = me.FindItem("item_satanic");
            medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");
            Shiva = me.FindItem("item_shivas_guard");
            manta = me.FindItem("item_manta");
            var v =
                ObjectManager.GetEntities<Hero>()
                    .Where(x => x.Team != me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion && !x.IsMagicImmune())
                    .ToList();
            e = Toolset.ClosestToMouse(me);
            if (e == null)
                return;
            var a = ObjectManager.GetEntities<Hero>()
                        .Where(x => x.Team == me.Team && x.IsAlive && x.IsVisible && x.IsIllusion && x.IsControllable).ToList();
            var illy = a.Count;
            if (illy >= 1)
            {
                for (int i = 0; i < illy; ++i)
                {
                    if (a[i].Distance2D(e) <= a[i].GetAttackRange() + a[i].HullRadius && !e.IsAttackImmune()
                        && !a[i].IsAttacking() && a[i].CanAttack() && Utils.SleepCheck(a[i].Handle + "Attack")
                        )
                    {
                        a[i].Attack(e);
                        Utils.Sleep(330, a[i].Handle + "Attack");
                    }
                    else if (a[i].Distance2D(e) <= 1000)
                    {
                        if ((!a[i].CanAttack() || a[i].Distance2D(e) >= 0)
                           && !a[i].IsAttacking()
                           && a[i].CanMove() && Utils.SleepCheck(a[i].Handle + "Move")
                           )
                        {
                            a[i].Move(Prediction.InFront(e, 100));
                            Utils.Sleep(400, a[i].Handle + "Move");
                        }
                    }
                }
            }
            if (Active)
            {
                if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900)
                {
                    Orbwalking.Orbwalk(e, 0, 1600, true, true);
                }
            }
            if (Active && me.Distance2D(e) <= 1400 && e != null && e.IsAlive && !Toolset.invUnit(me))
            {
                float angle = me.FindAngleBetween(e.Position, true);
                Vector3 pos = new Vector3((float) (e.Position.X - 70*Math.Cos(angle)), (float) (e.Position.Y - 70*Math.Sin(angle)),
                    0);
                if (
                    blink != null
                    && Q.CanBeCasted()
                    && me.CanCast()
                    && blink.CanBeCasted()
                    && me.Distance2D(e) >= 490
                    && me.Distance2D(pos) <= 1180
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                    && Utils.SleepCheck("blink")
                    )
                {
                    blink.UseAbility(pos);
                    Utils.Sleep(250, "blink");
                }
                if (
                    Q != null
                    && Q.CanBeCasted()
                    && me.Distance2D(e) <= 900
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                    && Utils.SleepCheck("Q")
                    )
                {
                    Q.UseAbility(e);
                    Utils.Sleep(200, "Q");
                }
                if (armlet != null
                    && !armlet.IsToggled
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(armlet.Name) &&
                    Utils.SleepCheck("armlet"))
                {
                    armlet.ToggleAbility();
                    Utils.Sleep(300, "armlet");
                }
                if ((manta != null
                     && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(manta.Name))
                    && manta.CanBeCasted() && me.IsSilenced() && Utils.SleepCheck("manta"))
                {
                    manta.UseAbility();
                    Utils.Sleep(400, "manta");
                }
                if ((manta != null && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(manta.Name))
                    && manta.CanBeCasted() && (e.Position.Distance2D(me.Position) <= me.GetAttackRange() + me.HullRadius)
                    && Utils.SleepCheck("manta"))
                {
                    manta.UseAbility();
                    Utils.Sleep(150, "manta");
                }
                if (
                    R != null
                    && R.CanBeCasted()
                    && me.Distance2D(e) <= 300
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                    && (armlet == null || armlet.IsToggled)
                    && Utils.SleepCheck("R")
                    )
                {
                    R.UseAbility();
                    Utils.Sleep(200, "R");
                }
                if (
                    W != null
                    && W.CanBeCasted()
                    && (me.Distance2D(e) <= W.GetCastRange() + 300
                        && (me.Distance2D(e) >= me.GetAttackRange()
                            || me.Distance2D(e) <= me.GetAttackRange()
                            && e.NetworkActivity == NetworkActivity.Attack)
                        )
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                    && Utils.SleepCheck("W")
                    )
                {
                    W.UseAbility(e);
                    Utils.Sleep(200, "W");
                }
                if ( // MOM
                    mom != null
                    && mom.CanBeCasted()
                    && me.CanCast()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mom.Name)
                    && Utils.SleepCheck("mom")
                    && me.Distance2D(e) <= 700
                    )
                {
                    mom.UseAbility();
                    Utils.Sleep(250, "mom");
                }
                if ( // Mjollnir
                    mjollnir != null
                    && mjollnir.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                    && Utils.SleepCheck("mjollnir")
                    && me.Distance2D(e) <= 900
                    )
                {
                    mjollnir.UseAbility(me);
                    Utils.Sleep(250, "mjollnir");
                } // Mjollnir Item end
                if ( // Medall
                    medall != null
                    && medall.CanBeCasted()
                    && Utils.SleepCheck("Medall")
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                    && me.Distance2D(e) <= 700
                    )
                {
                    medall.UseAbility(e);
                    Utils.Sleep(250, "Medall");
                } // Medall Item end

                if (Shiva != null
                    && Shiva.CanBeCasted()
                    && me.Distance2D(e) <= 600
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name)
                    && !e.IsMagicImmune()
                    && Utils.SleepCheck("Shiva"))
                {
                    Shiva.UseAbility();
                    Utils.Sleep(100, "Shiva");
                }
                if (dagon != null
                    && dagon.CanBeCasted()
                    && me.Distance2D(e) <= 500
                    && Utils.SleepCheck("dagon"))
                {
                    dagon.UseAbility(e);
                    Utils.Sleep(100, "dagon");
                }
                if ( // Abyssal Blade
                    abyssal != null
                    && abyssal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsStunned()
                    && !e.IsHexed()
                    && Utils.SleepCheck("abyssal")
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(abyssal.Name)
                    && me.Distance2D(e) <= 400
                    )
                {
                    abyssal.UseAbility(e);
                    Utils.Sleep(250, "abyssal");
                } // Abyssal Item end
                if (urn != null
                    && urn.CanBeCasted()
                    && urn.CurrentCharges > 0 && me.Distance2D(e) <= 400
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(urn.Name) && Utils.SleepCheck("urn"))
                {
                    urn.UseAbility(e);
                    Utils.Sleep(240, "urn");
                }
                if ( // Hellbard
                    halberd != null
                    && halberd.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && (e.NetworkActivity == NetworkActivity.Attack
                        || e.NetworkActivity == NetworkActivity.Crit
                        || e.NetworkActivity == NetworkActivity.Attack2)
                    && Utils.SleepCheck("halberd")
                    && me.Distance2D(e) <= 700
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(halberd.Name)
                    )
                {
                    halberd.UseAbility(e);
                    Utils.Sleep(250, "halberd");
                }
                if ( // Satanic
                    satanic != null &&
                    me.Health <= (me.MaximumHealth*0.3) &&
                    satanic.CanBeCasted() &&
                    me.Distance2D(e) <= me.GetAttackRange() + me.HullRadius
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                    && Utils.SleepCheck("satanic")
                    )
                {
                    satanic.UseAbility();
                    Utils.Sleep(240, "satanic");
                } // Satanic Item end
                if (mail != null && mail.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                           (Menu.Item("Heelm").GetValue<Slider>().Value)) &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mail.Name) && Utils.SleepCheck("mail"))
                {
                    mail.UseAbility();
                    Utils.Sleep(100, "mail");
                }
                if (bkb != null && bkb.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                         (Menu.Item("Heel").GetValue<Slider>().Value)) &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(bkb.Name) && Utils.SleepCheck("bkb"))
                {
                    bkb.UseAbility();
                    Utils.Sleep(100, "bkb");
                }
            }
        }
        public void Combo()
        {
            //spell
            Q = me.Spellbook.SpellQ;
            W = me.FindSpell("earthshaker_enchant_totem");
            E = me.Spellbook.SpellE;
            R = me.Spellbook.SpellR;

            // Item
            ethereal = me.FindItem("item_ethereal_blade");
            vail = me.FindItem("item_veil_of_discord");
            cheese = me.FindItem("item_cheese");
            ghost = me.FindItem("item_ghost");
            orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");
            atos = me.FindItem("item_rod_of_atos");
            soul = me.FindItem("item_soul_ring");
            arcane = me.FindItem("item_arcane_boots");
            blink = me.FindItem("item_blink");
            shiva = me.FindItem("item_shivas_guard");
            dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));

            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key) && !Game.IsChatOpen;

            if (Active && me.IsAlive && Utils.SleepCheck("activated"))
            {
                e = Toolset.ClosestToMouse(me);
                if (e == null) return; var modifEther = e.HasModifier("modifier_item_ethereal_blade_slow");
                var stoneModif = e.HasModifier("modifier_medusa_stone_gaze_stone");
                var noBlade = e.HasModifier("modifier_item_blade_mail_reflect");
                sheep = e.ClassID == ClassID.CDOTA_Unit_Hero_Tidehunter ? null : me.FindItem("item_sheepstick");
                if (e.IsAlive && e.IsVisible && me.Distance2D(e) <= 2300 && !noBlade)
                {
                    if (me.HasModifier("modifier_earthshaker_enchant_totem") && !me.IsAttacking() && me.Distance2D(e) <= 300 && Utils.SleepCheck("WMod"))
                    {
                        me.Attack(e);
                        Utils.Sleep(250, "WMod");
                    }
                    if ( // atos Blade
                        atos != null
                        && atos.CanBeCasted()
                        && me.CanCast()
                        && !e.IsLinkensProtected()
                        && !e.IsMagicImmune()
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(atos.Name)
                        && me.Distance2D(e) <= 2000
                        && Utils.SleepCheck("atos")
                        )
                    {
                        atos.UseAbility(e);
                        Utils.Sleep(250, "atos");
                    } // atos Item end

                    if (
                        blink != null
                        && me.CanCast()
                        && blink.CanBeCasted()
                        && me.Distance2D(e) > 400
                        && me.Distance2D(e) <= 1180
                        && !stoneModif
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                        && Utils.SleepCheck("blink")
                        )
                    {
                        blink.UseAbility(e.Position);
                        Utils.Sleep(250, "blink");
                    }
                    if ( // orchid
                        orchid != null
                        && orchid.CanBeCasted()
                        && me.CanCast()
                        && !e.IsLinkensProtected()
                        && !e.IsMagicImmune()
                        && me.Distance2D(e) <= 1400
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name)
                        && !stoneModif
                        && Utils.SleepCheck("orchid")
                        )
                    {
                        orchid.UseAbility(e);
                        Utils.Sleep(250, "orchid");
                    } // orchid Item end
                    if (!orchid.CanBeCasted() || orchid == null ||
                        !Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name))
                    {
                        if ( // vail
                            vail != null
                            && vail.CanBeCasted()
                            && me.CanCast()
                            && !e.IsMagicImmune()
                            && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name)
                            && me.Distance2D(e) <= 1500
                            && Utils.SleepCheck("vail")
                            )
                        {
                            vail.UseAbility(e.Position);
                            Utils.Sleep(250, "vail");
                        } // orchid Item end
                        if (!vail.CanBeCasted() || vail == null ||
                            !Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name))
                        {
                            if ( // ethereal
                                ethereal != null
                                && ethereal.CanBeCasted()
                                && me.CanCast()
                                && !e.IsLinkensProtected()
                                && !e.IsMagicImmune()
                                && !stoneModif
                                && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name)
                                && Utils.SleepCheck("ethereal")
                                )
                            {
                                ethereal.UseAbility(e);
                                Utils.Sleep(200, "ethereal");
                            } // ethereal Item end
                            if (!ethereal.CanBeCasted() || ethereal == null ||
                                !Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name))
                            {
                                if (
                                    W != null
                                    && W.CanBeCasted()
                                    && me.CanCast()
                                    && !me.HasModifier("modifier_earthshaker_enchant_totem")
                                    && me.Distance2D(e) < 2300
                                    && me.Distance2D(e) >= 1200
                                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                                    && Utils.SleepCheck("W"))
                                {
                                    W.UseAbility();
                                    Utils.Sleep(200, "W");
                                }
                                if (
                                    W != null
                                    && W.CanBeCasted()
                                    && me.CanCast()
                                    && !me.HasModifier("modifier_earthshaker_enchant_totem")
                                    && me.Distance2D(e) < W.GetCastRange()
                                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                                    && Utils.SleepCheck("W"))
                                {
                                    W.UseAbility();
                                    Utils.Sleep(200, "W");
                                }
                                if (me.AghanimState())
                                {
                                    if (
                                    W != null
                                    && W.CanBeCasted()
                                    && me.CanCast()
                                    && !me.HasModifier("modifier_earthshaker_enchant_totem")
                                    && me.Distance2D(e) >= 300
                                    && me.Distance2D(e) < 900 + me.HullRadius
                                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                                    && Utils.SleepCheck("W"))
                                    {
                                        W.UseAbility(e.Position);
                                        Utils.Sleep(200, "W");
                                    }
                                    if (
                                    W != null
                                    && W.CanBeCasted()
                                    && me.CanCast()
                                    && !me.HasModifier("modifier_earthshaker_enchant_totem")
                                    && me.Distance2D(e) <= 300
                                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                                    && Utils.SleepCheck("W"))
                                    {
                                        W.UseAbility(me);
                                        Utils.Sleep(200, "W");
                                    }
                                }
                                if (
                                    Q != null
                                    && Q.CanBeCasted()
                                    && (e.IsLinkensProtected()
                                        || !e.IsLinkensProtected())
                                    && me.CanCast()
                                    && me.Distance2D(e) < Q.GetCastRange() + me.HullRadius + 24
                                    && !stoneModif
                                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                                    && Utils.SleepCheck("Q")
                                    )
                                {
                                    Q.UseAbility(e.Position);
                                    Utils.Sleep(330, "Q");
                                }
                                if ( // SoulRing Item
                                    soul != null
                                    && soul.CanBeCasted()
                                    && me.CanCast()
                                    && me.Health >= (me.MaximumHealth * 0.6)
                                    && me.Mana <= R.ManaCost
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(soul.Name)
                                    )
                                {
                                    soul.UseAbility();
                                } // SoulRing Item end

                                if ( // Arcane Boots Item
                                    arcane != null
                                    && arcane.CanBeCasted()
                                    && me.CanCast()
                                    && me.Mana <= R.ManaCost
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(arcane.Name)
                                    )
                                {
                                    arcane.UseAbility();
                                } // Arcane Boots Item end

                                if ( //Ghost
                                    ghost != null
                                    && ghost.CanBeCasted()
                                    && me.CanCast()
                                    && ((me.Position.Distance2D(e) < 300
                                         && me.Health <= (me.MaximumHealth * 0.7))
                                        || me.Health <= (me.MaximumHealth * 0.3))
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ghost.Name)
                                    && Utils.SleepCheck("Ghost"))
                                {
                                    ghost.UseAbility();
                                    Utils.Sleep(250, "Ghost");
                                }

                                if ( // Shiva Item
                                    shiva != null
                                    && shiva.CanBeCasted()
                                    && me.CanCast()
                                    && !e.IsMagicImmune()
                                    && Utils.SleepCheck("shiva")
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(shiva.Name)
                                    && me.Distance2D(e) <= 600
                                    )
                                {
                                    shiva.UseAbility();
                                    Utils.Sleep(250, "shiva");
                                } // Shiva Item end
                                if ( // sheep
                                    sheep != null
                                    && sheep.CanBeCasted()
                                    && me.CanCast()
                                    && !e.IsLinkensProtected()
                                    && !e.IsMagicImmune()
                                    && !e.IsRooted()
                                    && !e.IsHexed()
                                    && !e.IsStunned()
                                    && me.Distance2D(e) <= 1400
                                    && !stoneModif
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(sheep.Name)
                                    && Utils.SleepCheck("sheep")
                                    )
                                {
                                    sheep.UseAbility(e);
                                    Utils.Sleep(250, "sheep");
                                } // sheep Item end

                                if ( // Dagon
                                    me.CanCast()
                                    && dagon != null
                                    && (ethereal == null
                                        || (modifEther
                                            || ethereal.Cooldown < 18))
                                    && !e.IsLinkensProtected()
                                    && dagon.CanBeCasted()
                                    && me.Distance2D(e) <= 1400
                                    && !e.IsMagicImmune()
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled("item_dagon")
                                    && !stoneModif
                                    && Utils.SleepCheck("dagon")
                                    )
                                {
                                    dagon.UseAbility(e);
                                    Utils.Sleep(200, "dagon");
                                } // Dagon Item end

                                if (
                                    // cheese
                                    cheese != null
                                    && cheese.CanBeCasted()
                                    && me.Health <= (me.MaximumHealth * 0.3)
                                    && me.Distance2D(e) <= 700
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(cheese.Name)
                                    && Utils.SleepCheck("cheese")
                                    )
                                {
                                    cheese.UseAbility();
                                    Utils.Sleep(200, "cheese");
                                } // cheese Item end
                            }
                        }
                    }
                    if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1600 && !me.HasModifier("modifier_earthshaker_enchant_totem"))
                    {
                        Orbwalking.Orbwalk(e, 0, 1600, true, true);
                    }
                }
                Utils.Sleep(150, "activated");
            }
            AutoSpells();
        }
Пример #11
0
        public static void Game_OnUpdate(EventArgs args)
        {
            me = ObjectMgr.LocalHero;

            if (me == null || !Game.IsInGame || Game.IsWatchingGame)
                return;

            if (me.ClassID != ClassID.CDOTA_Unit_Hero_Tinker)
                return;

            // Ability init
            Laser = me.Spellbook.Spell1;
            Rocket = me.Spellbook.Spell2;
            Refresh = me.Spellbook.Spell4;

            // Item init
            Blink = me.FindItem("item_blink");
            Dagon = me.GetDagon();
            Hex = me.FindItem("item_sheepstick");
            Soulring = me.FindItem("item_soul_ring");
            Ethereal = me.FindItem("item_ethereal_blade");
            Veil = me.FindItem("item_veil_of_discord");
            Orchid = me.FindItem("item_orchid");
            Shiva = me.FindItem("item_shiva");

            // Manacost calculations
            var manaForCombo = Laser.ManaCost + Rocket.ManaCost;
            if (Dagon != null && Dagon.CanBeCasted())
                manaForCombo += 180;
            if (Hex != null && Hex.CanBeCasted())
                manaForCombo += 100;
            if (Ethereal != null && Ethereal.CanBeCasted())
                manaForCombo += 150;
            if (Veil != null && Veil.CanBeCasted())
                manaForCombo += 50;

            // Main combo
            if (active && toggle)
            {
                target = me.ClosestToMouseTarget(1000);
                if (target != null && target.IsAlive && !target.IsIllusion && !target.IsMagicImmune() && Utils.SleepCheck("refresh") && !Refresh.IsChanneling)
                {
                    if (Soulring != null && me.Mana < manaForCombo && Soulring.CanBeCasted() && me.Health > 400 && Utils.SleepCheck("soulring"))
                    {
                        Soulring.UseAbility();
                        Utils.Sleep(150 + Game.Ping, "soulring");
                    }

                    // Blink
                    else if (Blink != null && Blink.CanBeCasted() && Utils.SleepCheck("blink"))
                    {
                        Utils.Sleep(300 + Game.Ping, "blink");
                        Utils.ChainStun(me, me.GetTurnTime(target) * 1000 + Game.Ping, null, false);
                        Blink.UseAbility(target.Position);
                    }

                    // Items
                    else if (Veil != null && Veil.CanBeCasted() && Utils.SleepCheck("veil"))
                    {
                        Veil.UseAbility(target.Position);
                        Utils.Sleep(150 + Game.Ping, "veil");
                        Utils.Sleep(300 + Game.Ping, "ve");
                        Utils.ChainStun(me, 170 + Game.Ping, null, false);
                    }

                    else if (Hex != null && Hex.CanBeCasted() && Utils.SleepCheck("hex"))
                    {
                        Hex.UseAbility(target);
                        Utils.Sleep(150 + Game.Ping, "hex");
                        Utils.Sleep(300 + Game.Ping, "h");
                        Utils.ChainStun(me, 170 + Game.Ping, null, false);
                    }

                    else if (Ethereal != null && Ethereal.CanBeCasted() && Utils.SleepCheck("ethereal"))
                    {
                        Ethereal.UseAbility(target);
                        Utils.Sleep(270 + Game.Ping, "ethereal");
                        Utils.ChainStun(me, 200 + Game.Ping, null, false);
                    }

                    else if (Dagon != null && Dagon.CanBeCasted() && Utils.SleepCheck("ethereal") && Utils.SleepCheck("h") && Utils.SleepCheck("dagon") && Utils.SleepCheck("veil"))
                    {
                        Dagon.UseAbility(target);
                        Utils.Sleep(270 + Game.Ping, "dagon");
                        Utils.ChainStun(me, 200 + Game.Ping, null, false);
                    }

                    // Skills
                    else if (Rocket != null && Rocket.CanBeCasted() && Utils.SleepCheck("rocket") && Utils.SleepCheck("ethereal") && Utils.SleepCheck("veil"))
                    {
                        Rocket.UseAbility();
                        Utils.Sleep(150 + Game.Ping, "rocket");
                        Utils.ChainStun(me, 150 + Game.Ping, null, false);
                    }

                    else if (Laser != null && Laser.CanBeCasted() && Utils.SleepCheck("laser") && Utils.SleepCheck("ethereal") && Utils.SleepCheck("rocket"))
                    {
                        Laser.UseAbility(target);
                        Utils.Sleep(150 + Game.Ping, "laser");
                        Utils.ChainStun(me, 150 + Game.Ping, null, false);
                    }

                    else if (Refresh != null && Refresh.CanBeCasted() && me.Mana > 200 && Utils.SleepCheck("refresh") && !Refresh.IsChanneling && nothingCanCast())
                    {
                        Refresh.UseAbility();
                        Utils.ChainStun(me, (Refresh.ChannelTime * 1000) + Game.Ping + 400, null, false);
                        Utils.Sleep(700 + Game.Ping, "refresh");
                    }

                    else if (!me.IsChanneling() && !Refresh.IsChanneling && nothingCanCast())
                    {
                        me.Attack(target);
                    }
                }
            }
        }
Пример #12
0
        public void RunScript()
        {
            me = ObjectManager.LocalHero;
            if (!MainMenu.CCMenu.Item("controll").IsActive() || !Game.IsInGame || me == null || Game.IsPaused ||
                Game.IsChatOpen) return;

            var holdKey = MainMenu.CCMenu.Item("Press Key").GetValue<KeyBind>().Active;
            var toggleKey = MainMenu.CCMenu.Item("Toogle Key").GetValue<KeyBind>().Active;
            var lockTargetKey = MainMenu.CCMenu.Item("Lock target Key").GetValue<KeyBind>().Active;

            var TargetMode = MainMenu.CCMenu.Item("Target mode").GetValue<StringList>().SelectedIndex;

            var TargetFindSource = MainMenu.CCMenu.Item("Target find source").GetValue<StringList>().SelectedIndex;
            var TargetFindRange = MainMenu.CCMenu.Item("Target find range").GetValue<Slider>().Value;
            var units = ObjectManager.GetEntities<Unit>().Where(creep =>
                (creep.ClassID == ClassID.CDOTA_BaseNPC_Creep_Neutral
                || creep.ClassID == ClassID.CDOTA_BaseNPC_Additive
                || creep.ClassID == ClassID.CDOTA_BaseNPC_Tusk_Sigil
                || creep.ClassID == ClassID.CDOTA_BaseNPC_Invoker_Forged_Spirit
                || creep.ClassID == ClassID.CDOTA_BaseNPC_Warlock_Golem
                || creep.ClassID == ClassID.CDOTA_BaseNPC_Creep
                || creep.ClassID == ClassID.CDOTA_Unit_VisageFamiliar
                || creep.ClassID == ClassID.CDOTA_Unit_Brewmaster_PrimalEarth
                || creep.ClassID == ClassID.CDOTA_Unit_Brewmaster_PrimalStorm
                || creep.ClassID == ClassID.CDOTA_Unit_Brewmaster_PrimalFire
                || creep.ClassID == ClassID.CDOTA_NPC_WitchDoctor_Ward
                || creep.ClassID == ClassID.CDOTA_Unit_Hero_Beastmaster_Boar
                || creep.ClassID == ClassID.CDOTA_Unit_SpiritBear
                || creep.ClassID == ClassID.CDOTA_BaseNPC_Venomancer_PlagueWard
                || creep.ClassID == ClassID.CDOTA_BaseNPC_ShadowShaman_SerpentWard
                || creep.ClassID == ClassID.CDOTA_Unit_Broodmother_Spiderling
                || creep.ClassID == ClassID.CDOTA_Unit_Elder_Titan_AncestralSpirit
                || creep.IsIllusion
                )
                && creep.IsAlive
                && creep.Team == me.Team
                && creep.IsControllable).ToList();
            if (lockTargetKey)
            {
                TargetLock = TargetSelector.ClosestToMouse(me, TargetFindRange);
            }

            if (TargetLock != null)
            {
                if (TargetLock.IsAlive)
                {
                    e = TargetLock;
                }
                else
                {
                    switch (TargetMode)
                    {
                        case 0:
                            switch (TargetFindSource)
                            {
                                case 0:
                                    var EnemyHero0 = ObjectManager.GetEntities<Hero>().Where(enemy => enemy.Team == me.GetEnemyTeam() && enemy.IsAlive && !enemy.IsIllusion && enemy.Distance2D(Game.MousePosition) <= TargetFindRange).ToList();
                                    e = EnemyHero0.MinOrDefault(x => x.Distance2D(me.Position));
                                    break;
                                case 1:
                                    e = TargetSelector.ClosestToMouse(me, 5000);
                                    break;
                            }
                            break;
                        case 1:
                            switch (TargetFindSource)
                            {
                                case 0:
                                    var EnemyHero0 = ObjectManager.GetEntities<Hero>().Where(enemy => enemy.Team == me.GetEnemyTeam() && enemy.IsAlive && !enemy.IsIllusion && enemy.Distance2D(Game.MousePosition) <= TargetFindRange).ToList();
                                    e = EnemyHero0.MinOrDefault(x => x.Health);
                                    break;
                                case 1:
                                    var EnemyHero1 = ObjectManager.GetEntities<Hero>().Where(enemy => enemy.Team == me.GetEnemyTeam() && enemy.IsAlive && !enemy.IsIllusion && enemy.Distance2D(me.Position) <= TargetFindRange).ToList();
                                    e = EnemyHero1.MinOrDefault(x => x.Health);
                                    break;
                            }
                            break;
                    }
                }
            }
            else
            {
                switch (TargetMode)
                {
                    case 0:
                        e = TargetSelector.ClosestToMouse(me, 5000);
                        break;
                    case 1:
                        var EnemyHero = ObjectManager.GetEntities<Hero>().Where(enemy => enemy.Team == me.GetEnemyTeam() && enemy.IsAlive && !enemy.IsIllusion && enemy.Distance2D(Game.MousePosition) <= TargetFindRange).ToList();
                        e = EnemyHero.MinOrDefault(x => x.Health);
                        break;
                }
            }
            if (Utils.SleepCheck("delay"))
            {
                if (me.IsAlive)
                {
                    var count = units.Count();
                    if (count <= 0) return;
                    for (int i = 0; i < count; ++i)
                    {
                        var v = ObjectManager.GetEntities<Hero>()
                                          .Where(x => x.Team == me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion).ToList();
                       if (units[i].Name == "npc_dota_juggernaut_healing_ward")

                            {
                                if (me.Position.Distance2D(units[i].Position) > 5 && Utils.SleepCheck(units[i].Handle.ToString()))
                                {
                                    units[i].Move(me.Position);
                                    Utils.Sleep(50, units[i].Handle.ToString());
                                }
                        }
                        else if (units[i].Name == "npc_dota_neutral_ogre_magi")
                        {
                            for (int z = 0; z < v.Count(); ++z)
                            {
                                var armor = units[i].Spellbook.SpellQ;

                                if ((!v[z].HasModifier("modifier_ogre_magi_frost_armor") || !me.HasModifier("modifier_ogre_magi_frost_armor")) && armor.CanBeCasted() && units[i].Position.Distance2D(v[z]) <= 900
                                    && Utils.SleepCheck(units[i].Handle.ToString()))
                                {
                                    armor.UseAbility(v[z]);
                                    Utils.Sleep(400, units[i].Handle.ToString());
                                }
                            }
                        }
                        else if (units[i].Name == "npc_dota_neutral_forest_troll_high_priest")
                        {
                            if (units[i].Spellbook.SpellQ.CanBeCasted())
                            {
                                for (int z = 0; z < v.Count(); ++z)
                                {
                                    if (units[i].Position.Distance2D(v[z]) <= 900
                                    && Utils.SleepCheck(units[i].Handle + "high_priest"))
                                    {
                                        units[i].Spellbook.SpellQ.UseAbility(v[z]);
                                        Utils.Sleep(350, units[i].Handle + "high_priest");
                                    }
                                }
                            }
                        }

                        if (e == null) return;

                        if (e.IsAlive && !e.IsInvul() && (holdKey || toggleKey))
                        {

                            //spell
                            var CheckStun = e.HasModifier("modifier_centaur_hoof_stomp");
                            var CheckSetka = e.HasModifier("modifier_dark_troll_warlord_ensnare");
                            if (units[i].Name == "npc_dota_neutral_dark_troll_warlord")
                            {
                                if (e.Position.Distance2D(units[i].Position) < 550 && (!CheckSetka || !CheckStun || !e.IsHexed() || !e.IsStunned()) && units[i].Spellbook.SpellQ.CanBeCasted() &&
                                         Utils.SleepCheck(units[i].Handle + "warlord"))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility(e);
                                    Utils.Sleep(450, units[i].Handle + "warlord");
                                }
                            }
                            else if (units[i].Name == "npc_dota_neutral_big_thunder_lizard")
                            {
                                if (e.Position.Distance2D(units[i].Position) < 250 && units[i].Spellbook.SpellQ.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle + "lizard"))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility();
                                    Utils.Sleep(450, units[i].Handle + "lizard");
                                }
                                if (e.Position.Distance2D(units[i].Position) < 550 && units[i].Spellbook.SpellW.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle + "lizard"))
                                {
                                    units[i].Spellbook.SpellW.UseAbility();
                                    Utils.Sleep(450, units[i].Handle + "lizard");
                                }
                            }
                            else if (units[i].Name == "npc_dota_neutral_centaur_khan")
                            {
                                if (e.Position.Distance2D(units[i].Position) < 200 && (!CheckSetka || !CheckStun || !e.IsHexed() || !e.IsStunned()) && units[i].Spellbook.SpellQ.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle + "centaur"))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility();
                                    Utils.Sleep(450, units[i].Handle + "centaur");
                                }
                            }
                            else if (units[i].Name == "npc_dota_neutral_satyr_hellcaller")
                            {
                                if (e.Position.Distance2D(units[i].Position) < 850 && units[i].Spellbook.SpellQ.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle + "satyr"))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility(e);
                                    Utils.Sleep(350, units[i].Handle + "satyr");
                                }
                            }
                            else if (units[i].Name == "npc_dota_neutral_satyr_trickster")
                            {
                                if (e.Position.Distance2D(units[i].Position) < 850 && units[i].Spellbook.SpellQ.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle + "satyr_trickster"))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility(e);
                                    Utils.Sleep(350, units[i].Handle + "satyr_trickster");
                                }
                            }
                            else if (units[i].Name == "npc_dota_neutral_satyr_soulstealer")
                            {
                                if (e.Position.Distance2D(units[i].Position) < 850 && units[i].Spellbook.SpellQ.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle + "satyrsoulstealer"))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility(e);
                                    Utils.Sleep(350, units[i].Handle + "satyrsoulstealer");
                                }
                            }
                            else if (units[i].Name == "npc_dota_neutral_black_dragon")
                            {
                                if (e.Position.Distance2D(units[i].Position) < 700 && units[i].Spellbook.SpellQ.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle + "dragonspawn"))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility(e.Predict(600));
                                    Utils.Sleep(350, units[i].Handle + "dragonspawn");
                                }
                            }
                            else if (units[i].Name == "npc_dota_neutral_big_thunder_lizard")
                            {
                                if (e.Position.Distance2D(units[i].Position) < 200 && units[i].Spellbook.SpellQ.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle + "lizard"))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility();
                                    Utils.Sleep(350, units[i].Handle + "lizard");
                                }

                                for (int z = 0; z < v.Count(); z++)
                                {
                                    if (units[i].Spellbook.SpellW.CanBeCasted() && units[i].Position.Distance2D(v[z]) <= 900)
                                    {
                                        if (e.Position.Distance2D(v[z]) < v[z].AttackRange + 150 &&
                                        Utils.SleepCheck(units[i].Handle + "lizard"))
                                        {
                                            units[i].Spellbook.SpellW.UseAbility(v[z]);
                                            Utils.Sleep(350, units[i].Handle + "lizard");
                                        }
                                    }
                                }
                            }
                            else if (units[i].Name == "npc_dota_neutral_mud_golem")
                            {
                                if (e.Position.Distance2D(units[i].Position) < 850 && (!CheckSetka || !CheckStun || !e.IsHexed() || !e.IsStunned())
                                    && units[i].Spellbook.SpellQ.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle + "golem"))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility(e);
                                    Utils.Sleep(350, units[i].Handle + "golem");
                                }
                            }
                            else if (units[i].Name == "npc_dota_neutral_polar_furbolg_ursa_warrior")
                            {
                                if (e.Position.Distance2D(units[i].Position) < 240 && units[i].Spellbook.SpellQ.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle + "ursa"))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility();
                                    Utils.Sleep(350, units[i].Handle + "ursa");
                                }
                            }
                            else if (units[i].Name == "npc_dota_neutral_harpy_storm")
                            {
                                if (e.Position.Distance2D(units[i].Position) < 900 && units[i].Spellbook.SpellQ.CanBeCasted() &&
                                        Utils.SleepCheck(units[i].Handle + "harpy"))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility(e);
                                    Utils.Sleep(350, units[i].Handle + "harpy");
                                }
                            }
                            else if (units[i].ClassID == ClassID.CDOTA_BaseNPC_Tusk_Sigil)
                            {
                                if (e.Position.Distance2D(units[i].Position) < 1550 &&
                                        Utils.SleepCheck(units[i].Handle.ToString()))
                                {
                                    units[i].Move(e.Predict(1500));
                                    Utils.Sleep(700, units[i].Handle.ToString());
                                }
                            }
                            else if (units[i].ClassID == ClassID.CDOTA_BaseNPC_Creep)
                            {
                                if (units[i].Name == "npc_dota_necronomicon_archer")
                                {
                                    if (e.Position.Distance2D(units[i].Position) <= 700 && units[i].Spellbook.SpellQ.CanBeCasted() &&
                                        Utils.SleepCheck(units[i].Handle.ToString()))

                                    {
                                        units[i].Spellbook.SpellQ.UseAbility(e);
                                        Utils.Sleep(300, units[i].Handle.ToString());
                                    }
                                }
                            }
                            else if (units[i].ClassID == ClassID.CDOTA_Unit_VisageFamiliar)
                            {
                                var damageModif = units[i].Modifiers.FirstOrDefault(x => x.Name == "modifier_visage_summon_familiars_damage_charge");

                                if (e.Position.Distance2D(units[i].Position) < 1550 && units[i].Health < 6 && units[i].Spellbook.Spell1.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle.ToString()))
                                {
                                    units[i].Spellbook.Spell1.UseAbility();
                                    Utils.Sleep(200, units[i].Handle.ToString());
                                }

                                if (e.Position.Distance2D(units[i].Position) < 340 && ((damageModif.StackCount < 1) && !e.IsStunned()) && units[i].Spellbook.Spell1.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle.ToString()))
                                {
                                    units[i].Spellbook.Spell1.UseAbility();
                                    Utils.Sleep(350, units[i].Handle.ToString());
                                }
                            }
                            else if (units[i].ClassID == ClassID.CDOTA_Unit_Brewmaster_PrimalEarth)
                            {
                                if (e.Position.Distance2D(units[i].Position) < 1300 &&
                                    units[i].Spellbook.SpellQ.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle.ToString()))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility(e);
                                    Utils.Sleep(400, units[i].Handle.ToString());
                                }
                                if (e.Position.Distance2D(units[i].Position) < 340 &&
                                    units[i].Spellbook.SpellR.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle.ToString()))
                                {
                                    units[i].Spellbook.SpellR.UseAbility();
                                    Utils.Sleep(400, units[i].Handle.ToString());
                                }
                            }
                            else if (units[i].ClassID == ClassID.CDOTA_Unit_Brewmaster_PrimalStorm)
                            {
                                if (e.Position.Distance2D(units[i].Position) < 700 &&
                                    units[i].Spellbook.SpellQ.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle.ToString()))
                                {
                                    units[i].Spellbook.SpellQ.UseAbility(e.Position);
                                    Utils.Sleep(400, units[i].Handle.ToString());
                                }
                                if (e.Position.Distance2D(units[i].Position) < 900 &&
                                    units[i].Spellbook.SpellE.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle.ToString()))
                                {
                                    units[i].Spellbook.SpellE.UseAbility();
                                    Utils.Sleep(400, units[i].Handle.ToString());
                                }
                                if (e.Position.Distance2D(units[i].Position) < 850 &&
                                    units[i].Spellbook.SpellR.CanBeCasted() &&
                                    Utils.SleepCheck(units[i].Handle.ToString()))
                                {
                                    units[i].Spellbook.SpellR.UseAbility(e);
                                    Utils.Sleep(400, units[i].Handle.ToString());
                                }
                            }
                            else if (units[i].ClassID == ClassID.CDOTA_Unit_SpiritBear)
                            {
                                if ((!me.AghanimState() && me.Position.Distance2D(units[i]) <= 1200) || me.AghanimState())
                                {
                                    abyssal = units[i].FindItem("item_abyssal_blade");

                                    mjollnir = units[i].FindItem("item_mjollnir");

                                    boots = units[i].FindItem("item_phase_boots");

                                    midas = units[i].FindItem("item_hand_of_midas");

                                    mom = units[i].FindItem("item_mask_of_madness");

                                    medall = units[i].FindItem("item_medallion_of_courage") ?? units[i].FindItem("item_solar_crest");

                                    if (boots != null && e.Position.Distance2D(units[i].Position) < 1550 && boots.CanBeCasted() &&
                                        Utils.SleepCheck(units[i].Handle.ToString()))
                                    {
                                        boots.UseAbility();
                                        Utils.Sleep(350, units[i].Handle.ToString());
                                    }
                                    if (mjollnir != null && e.Position.Distance2D(units[i].Position) < 525 && mjollnir.CanBeCasted() &&
                                        Utils.SleepCheck(units[i].Handle.ToString()))
                                    {
                                        mjollnir.UseAbility(units[i]);
                                        Utils.Sleep(350, units[i].Handle.ToString());
                                    }
                                    if (medall != null && e.Position.Distance2D(units[i].Position) < 525 && medall.CanBeCasted() &&
                                       Utils.SleepCheck(units[i].Handle.ToString()))
                                    {
                                        medall.UseAbility(e);
                                        Utils.Sleep(350, units[i].Handle.ToString());
                                    }

                                    if (mom != null && e.Position.Distance2D(units[i].Position) < 525 && mom.CanBeCasted() &&
                                       Utils.SleepCheck(units[i].Handle.ToString()))
                                    {
                                        mom.UseAbility();
                                        Utils.Sleep(350, units[i].Handle.ToString());
                                    }
                                    if (abyssal != null && e.Position.Distance2D(units[i].Position) < 500 && abyssal.CanBeCasted() &&
                                        Utils.SleepCheck(units[i].Handle.ToString()))
                                    {
                                        abyssal.UseAbility(e);
                                        Utils.Sleep(350, units[i].Handle.ToString());
                                    }
                                    if (midas != null)
                                    {
                                        var neutrals = ObjectManager.GetEntities<Creep>().Where(creep => (creep.ClassID == ClassID.CDOTA_BaseNPC_Creep_Lane || creep.ClassID == ClassID.CDOTA_BaseNPC_Creep_Siege || creep.ClassID == ClassID.CDOTA_BaseNPC_Creep_Neutral || creep.ClassID == ClassID.CDOTA_BaseNPC_Invoker_Forged_Spirit || creep.ClassID == ClassID.CDOTA_BaseNPC_Creep) &&
                                            creep.IsAlive && creep.IsVisible && creep.IsSpawned && creep.Distance2D(units[i])<= 700 && creep.Team != me.Team).OrderBy(x => x.Health).LastOrDefault();

                                       if (midas.CanBeCasted() && Utils.SleepCheck(neutrals.Handle.ToString()))
                                        {
                                            midas.UseAbility(neutrals);
                                            Utils.Sleep(350, neutrals.Handle.ToString());
                                        }
                                    }
                                }
                            }
                            else if (units[i].ClassID == ClassID.CDOTA_BaseNPC_Additive)
                            {
                                if (units[i].Name == "npc_dota_templar_assassin_psionic_trap")
                                {

                                    if (e.Position.Distance2D(units[i].Position) < 250
                                        && units[i].Spellbook.Spell1.CanBeCasted()
                                        && e.Distance2D(Game.MousePosition) <= 1000
                                        && Utils.SleepCheck(units[i].Handle.ToString()))
                                    {
                                        units[i].Spellbook.Spell1.UseAbility();
                                        Utils.Sleep(250, units[i].Handle.ToString());
                                    }
                                }
                            }
                            if (units[i].Distance2D(e) <= units[i].AttackRange + 100 && !e.IsAttackImmune()
                            && !units[i].IsAttacking() && units[i].CanAttack() && Utils.SleepCheck(units[i].Handle + "Attack")
                            )
                            {
                                units[i].Attack(e);
                                Utils.Sleep(250, units[i].Handle + "Attack");
                            }
                            else if (!units[i].CanAttack() && !units[i].IsAttacking()
                                && units[i].CanMove() && units[i].Distance2D(e) <= 4000 && Utils.SleepCheck(units[i].Handle + "Move")
                                )
                            {
                                units[i].Move(e.Predict(300));
                                Utils.Sleep(350, units[i].Handle + "Move");
                            }
                            else if (units[i].Distance2D(e) >= units[i].GetAttackRange() && !units[i].IsAttacking()
                               && units[i].CanMove() && units[i].Distance2D(e) <= 4000 && Utils.SleepCheck(units[i].Handle + "MoveAttack")
                               )
                            {
                                units[i].Move(e.Predict(300));
                                Utils.Sleep(350, units[i].Handle + "MoveAttack");
                            }
                        }
                        Utils.Sleep(500, "delay");
                    }
                }
            }
        }
        public void Combo()
        {
            if (!Menu.Item("enabled").IsActive())
                return;
            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key) && !Game.IsChatOpen;

            Q = me.Spellbook.SpellQ;
            R = me.Spellbook.SpellR;
            Shiva = me.FindItem("item_shivas_guard");
            mom = me.FindItem("item_mask_of_madness");
            urn = me.FindItem("item_urn_of_shadows");
            dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));
            halberd = me.FindItem("item_heavens_halberd");
            mjollnir = me.FindItem("item_mjollnir");
            orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");
            abyssal = me.FindItem("item_abyssal_blade");
            mail = me.FindItem("item_blade_mail");
            bkb = me.FindItem("item_black_king_bar");
            ethereal = me.FindItem("item_ethereal_blade");
            glimmer = me.FindItem("item_glimmer_cape");
            vail = me.FindItem("item_veil_of_discord");
            satanic = me.FindItem("item_satanic");
            blink = me.FindItem("item_blink");
            medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");
            e = Toolset.ClosestToMouse(me);
            if (e == null) return;

            var stoneModif = e.HasModifier("modifier_medusa_stone_gaze_stone");

            if (me.IsChanneling() || R.IsInAbilityPhase || R.IsChanneling) return;
            var v =
                ObjectManager.GetEntities<Hero>()
                    .Where(x => x.Team != me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion && !x.IsMagicImmune())
                    .ToList();
            var modifInv = me.IsInvisible();
            if (Active && Utils.SleepCheck("Combo"))
            {
                if (me.HasModifier("modifier_sandking_sand_storm")) return;
                float angle = me.FindAngleBetween(e.Position, true);

                Vector3 pos = new Vector3((float)(e.Position.X - (Q.GetCastRange() - 100) * Math.Cos(angle)),
                    (float)(e.Position.Y - (Q.GetCastRange() - 100) * Math.Sin(angle)), 0);
                uint elsecount = 1;
                if (elsecount == 1 && (blink != null && blink.CanBeCasted() && me.Distance2D(pos) <= 1100 || blink == null && me.Distance2D(e) <= Q.GetCastRange() - 50))
                {
                    if (
                        R != null && R.CanBeCasted()
                        && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                        && Utils.SleepCheck("R")
                        )
                    {
                        R.UseAbility();
                        Utils.Sleep(200, "R");
                        Utils.Sleep(300, "Combo");
                    }
                }

                if (!Utils.SleepCheck("Combo") || me.IsChanneling() || R.IsChanneling || R.IsInAbilityPhase) return;

                if (!Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name) || !R.CanBeCasted())
                {
                    if (
                        blink != null
                        && blink.CanBeCasted()
                        && me.Distance2D(e) >= (Q.CanBeCasted() ? Q.GetCastRange() : 450)
                        && me.Distance2D(pos) <= 1190
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                        && Utils.SleepCheck("blink")
                        )
                    {
                        blink.UseAbility(pos);
                        Utils.Sleep(250, "blink");
                    }
                    if (
                        blink != null
                        && blink.CanBeCasted()
                        && me.Distance2D(e) < 1180
                        && me.Distance2D(e) > (Q.CanBeCasted() ? Q.GetCastRange() : 450)
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                        && Utils.SleepCheck("blink")
                        )
                    {
                        blink.UseAbility(e.Position);
                        Utils.Sleep(250, "blink");
                    }

                    if (
                    Q != null && Q.CanBeCasted() && me.Distance2D(e) <= Q.GetCastRange() + 300
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                    && Utils.SleepCheck("Q")
                    )
                    {
                        Q.UseAbility(e);
                        Utils.Sleep(200, "Q");
                    }
                }
                if (me.Distance2D(e) <= 2000 && e != null && e.IsAlive && !modifInv && !me.IsChanneling() && (!R.CanBeCasted() || !Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)))
                {
                    if (ethereal != null && ethereal.CanBeCasted() && me.Distance2D(e) <= 700 &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name) &&
                    Utils.SleepCheck("ethereal"))
                    {
                        ethereal.UseAbility(e);
                        Utils.Sleep(100, "ethereal");
                    }

                    if (vail != null && vail.CanBeCasted() && me.Distance2D(e) <= 1100 &&
                       Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name) && Utils.SleepCheck("vail"))
                    {
                        vail.UseAbility(e.Position);
                        Utils.Sleep(130, "vail");
                    }

                    if ( // Abyssal Blade
                    abyssal != null
                    && abyssal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsStunned()
                    && !e.IsHexed()
                    && Utils.SleepCheck("abyssal")
                    && me.Distance2D(e) <= 400
                    )
                    {
                        abyssal.UseAbility(e);
                        Utils.Sleep(250, "abyssal");
                    } // Abyssal Item end
                    if (glimmer != null
                        && glimmer.CanBeCasted()
                        && me.Distance2D(e) <= 300
                        && Utils.SleepCheck("glimmer"))
                    {
                        glimmer.UseAbility(me);
                        Utils.Sleep(200, "glimmer");
                    }
                    if ( // Mjollnir
                   mjollnir != null
                   && mjollnir.CanBeCasted()
                   && me.CanCast()
                   && !e.IsMagicImmune()
                   && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                   && Utils.SleepCheck("mjollnir")
                   && me.Distance2D(e) <= 900
                   )
                    {
                        mjollnir.UseAbility(me);
                        Utils.Sleep(250, "mjollnir");
                    } // Mjollnir Item end
                    if ( // Medall
                        medall != null
                        && medall.CanBeCasted()
                        && Utils.SleepCheck("Medall")
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                        && me.Distance2D(e) <= 700
                        )
                    {
                        medall.UseAbility(e);
                        Utils.Sleep(250, "Medall");
                    } // Medall Item end

                    if ( // MOM
                        mom != null
                        && mom.CanBeCasted()
                        && me.CanCast()
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mom.Name)
                        && Utils.SleepCheck("mom")
                        && me.Distance2D(e) <= 700
                        )
                    {
                        mom.UseAbility();
                        Utils.Sleep(250, "mom");
                    }
                    if (orchid != null && orchid.CanBeCasted() && me.Distance2D(e) <= 900 &&
                        Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name) && Utils.SleepCheck("orchid"))
                    {
                        orchid.UseAbility(e);
                        Utils.Sleep(100, "orchid");
                    }

                    if (Shiva != null && Shiva.CanBeCasted() && me.Distance2D(e) <= 600
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name)
                        && !e.IsMagicImmune() && Utils.SleepCheck("Shiva"))
                    {
                        Shiva.UseAbility();
                        Utils.Sleep(100, "Shiva");
                    }

                    if ( // Dagon
                        me.CanCast()
                        && dagon != null
                        && !e.IsLinkensProtected()
                        && dagon.CanBeCasted()
                        && !e.IsMagicImmune()
                        && !stoneModif
                        && Utils.SleepCheck("dagon")
                        )
                    {
                        dagon.UseAbility(e);
                        Utils.Sleep(200, "dagon");
                    } // Dagon Item end

                    if (urn != null && urn.CanBeCasted() && urn.CurrentCharges > 0 && me.Distance2D(e) <= 400
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(urn.Name) && Utils.SleepCheck("urn"))
                    {
                        urn.UseAbility(e);
                        Utils.Sleep(240, "urn");
                    }
                    if ( // Satanic
                        satanic != null &&
                        me.Health <= (me.MaximumHealth * 0.3) &&
                        satanic.CanBeCasted() &&
                        me.Distance2D(e) <= me.AttackRange + 50
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                        && Utils.SleepCheck("satanic")
                        )
                    {
                        satanic.UseAbility();
                        Utils.Sleep(240, "satanic");
                    } // Satanic Item end
                    if (mail != null && mail.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                               (Menu.Item("Heelm").GetValue<Slider>().Value)) &&
                        Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mail.Name) && Utils.SleepCheck("mail"))
                    {
                        mail.UseAbility();
                        Utils.Sleep(100, "mail");
                    }
                    if (bkb != null && bkb.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                             (Menu.Item("Heel").GetValue<Slider>().Value)) &&
                        Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(bkb.Name) && Utils.SleepCheck("bkb"))
                    {
                        bkb.UseAbility();
                        Utils.Sleep(100, "bkb");
                    }
                    if (Menu.Item("logic").IsActive())
                    {
                        if (mail != null && mail.CanBeCasted() && Toolset.HasStun(e) && !e.IsStunned() &&
                            Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mail.Name) && Utils.SleepCheck("mail"))
                        {
                            mail.UseAbility();
                            Utils.Sleep(100, "mail");
                        }
                        if (bkb != null && bkb.CanBeCasted() && Toolset.HasStun(e) && !e.IsStunned() &&
                            Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(bkb.Name) && Utils.SleepCheck("bkb"))
                        {
                            bkb.UseAbility();
                            Utils.Sleep(100, "bkb");
                        }
                    }
                }
                if (me.IsChanneling() || R.IsChanneling || R.IsInAbilityPhase) return;
                elsecount++;
                if (elsecount == 2 && e != null && e.IsAlive)
                {

                    if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900 && !me.IsChanneling())
                    {
                        Orbwalking.Orbwalk(e, 0, 1600, true, true);
                    }
                }
                Utils.Sleep(200, "Combo");
            }
        }
        /* Доп. функции скрипта
        -----------------------------------------------------------------------------*/
        public void Combo()
        {
            e = Toolset.ClosestToMouse(me);
            if (e.HasModifier("modifier_abaddon_borrowed_time")
            || e.HasModifier("modifier_item_blade_mail_reflect")
            || e.IsMagicImmune())
            {
                var enemies = ObjectManager.GetEntities<Hero>()
                        .Where(x => x.IsAlive && x.Team != me.Team && !x.IsIllusion && !x.IsMagicImmune()
                        && (!x.HasModifier("modifier_abaddon_borrowed_time")
                        || !x.HasModifier("modifier_item_blade_mail_reflect"))
                        && x.Distance2D(e) > 200).ToList();
                e = GetClosestToTarget(enemies, e) ?? null;
                if (Utils.SleepCheck("spam"))
                {
                    Utils.Sleep(5000, "spam");
                }
            }
            if (e == null) return;
            //spell
            Q = me.Spellbook.SpellQ;

            W = me.Spellbook.SpellW;

            E = me.Spellbook.SpellE;

            R = me.Spellbook.SpellR;
            // Item
            ethereal = me.FindItem("item_ethereal_blade");

            sheep = e.ClassID == ClassID.CDOTA_Unit_Hero_Tidehunter ? null : me.FindItem("item_sheepstick");

            vail = me.FindItem("item_veil_of_discord");

            cheese = me.FindItem("item_cheese");

            ghost = me.FindItem("item_ghost");

            orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");

            atos = me.FindItem("item_rod_of_atos");

            soul = me.FindItem("item_soul_ring");

            arcane = me.FindItem("item_arcane_boots");

            blink = me.FindItem("item_blink");

            shiva = me.FindItem("item_shivas_guard");

            dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));

            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key);

            Push = Game.IsKeyDown(Menu.Item("keyQ").GetValue<KeyBind>().Key);

            var stoneModif = e.HasModifier("modifier_medusa_stone_gaze_stone");
            A();
            if (Push && Q != null && Q.CanBeCasted())
            {
                if (
                    Q != null
                    && Q.CanBeCasted()
                    && (e.IsLinkensProtected()
                    || !e.IsLinkensProtected())
                    && me.CanCast()
                    && me.Distance2D(e) < Q.GetCastRange() + me.HullRadius + 24
                    && Utils.SleepCheck("Q")
                    )
                {
                    Q.UseAbility(e);
                    Utils.Sleep(200, "Q");
                }
            }
            if (Active && me.IsAlive && e.IsAlive && Utils.SleepCheck("activated"))
            {
                if (stoneModif) return;
                //var noBlade = e.HasModifier("modifier_item_blade_mail_reflect");
                if (e.IsVisible && me.Distance2D(e) <= 2300)
                {
                    var distance = me.IsVisibleToEnemies ? 1400 : E.GetCastRange() + me.HullRadius;
                    if (
                        Q != null
                        && Q.CanBeCasted()
                        && me.CanCast()
                        && e.IsLinkensProtected()
                        && !e.IsMagicImmune()
                        && me.Distance2D(e) < Q.GetCastRange() + me.HullRadius
                        && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                        && Utils.SleepCheck("Q")
                        )
                    {
                        Q.UseAbility(e);
                        Utils.Sleep(200, "Q");
                    }

                    if (
                        E != null
                        && E.CanBeCasted()
                        && me.CanCast()
                        && !e.IsLinkensProtected()
                        && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(E.Name)
                        && me.Position.Distance2D(e) < E.GetCastRange() + me.HullRadius + 500
                        && Utils.SleepCheck("E"))
                    {
                        E.UseAbility(e);
                        Utils.Sleep(200, "E");
                    }
                    if (
                      Q != null
                      && Q.CanBeCasted()
                      && me.CanCast()
                      && !e.IsMagicImmune()
                      && me.Distance2D(e) < distance
                      && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                      && Utils.SleepCheck("Q")
                      )
                    {
                        Q.UseAbility(e);
                        Utils.Sleep(200, "Q");
                    }
                    if ( // sheep
                        sheep != null
                        && sheep.CanBeCasted()
                        && me.CanCast()
                        && !e.IsLinkensProtected()
                        && !e.IsMagicImmune()
                        && me.Distance2D(e) <= 1400
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(sheep.Name)
                        && Utils.SleepCheck("sheep")
                        )
                    {
                        sheep.UseAbility(e);
                        Utils.Sleep(250, "sheep");
                    } // sheep Item end
                    if (E == null || !E.CanBeCasted() || me.IsSilenced() || me.Position.Distance2D(e) > E.GetCastRange() + me.HullRadius || !Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(E.Name))
                    {
                        if (
                           Q != null
                           && Q.CanBeCasted()
                           && me.CanCast()
                           && !e.IsMagicImmune()
                           && me.Distance2D(e) < 1400
                           && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                           && Utils.SleepCheck("Q")
                       )
                        {
                            Q.UseAbility(e);
                            Utils.Sleep(200, "Q");
                        }
                        if ( // atos Blade
                            atos != null
                            && atos.CanBeCasted()
                            && me.CanCast()
                            && !e.IsLinkensProtected()
                            && !e.IsMagicImmune()
                            && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(atos.Name)
                            && me.Distance2D(e) <= distance
                            && Utils.SleepCheck("atos")
                            )
                        {
                            atos.UseAbility(e);

                            Utils.Sleep(250 + Game.Ping, "atos");
                        } // atos Item end
                        if (
                            W != null
                            && e.IsVisible
                            && W.CanBeCasted()
                            && me.CanCast()
                            && !e.IsMagicImmune()
                            && me.Distance2D(e) < distance
                            && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                            && Utils.SleepCheck("W"))
                        {
                            W.UseAbility();
                            Utils.Sleep(300, "W");
                        }
                        float angle = me.FindAngleBetween(e.Position, true);
                        Vector3 pos = new Vector3((float)(e.Position.X - 500 * Math.Cos(angle)), (float)(e.Position.Y - 500 * Math.Sin(angle)), 0);
                        if (
                            blink != null
                            && Q.CanBeCasted()
                            && me.CanCast()
                            && blink.CanBeCasted()
                            && me.Distance2D(e) >= 490
                            && me.Distance2D(pos) <= 1180
                            && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                            && Utils.SleepCheck("blink")
                            )
                        {
                            blink.UseAbility(pos);
                            Utils.Sleep(250, "blink");
                        }
                        if ( // orchid
                            orchid != null
                            && orchid.CanBeCasted()
                            && me.CanCast()
                            && !e.IsLinkensProtected()
                            && !e.IsMagicImmune()
                            && me.Distance2D(e) <= distance
                            && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name)
                            && Utils.SleepCheck("orchid")
                            )
                        {
                            orchid.UseAbility(e);
                            Utils.Sleep(250, "orchid");
                        } // orchid Item end
                        if (!orchid.CanBeCasted() || orchid == null || me.IsSilenced() || !Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name))
                        {
                            if ( // vail
                                vail != null
                               && vail.CanBeCasted()
                               && me.CanCast()
                               && !e.IsMagicImmune()
                               && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name)
                               && me.Distance2D(e) <= distance
                               && Utils.SleepCheck("vail")
                               )
                            {
                                vail.UseAbility(e.Position);
                                Utils.Sleep(250, "vail");
                            } // orchid Item end
                            if (vail == null || !vail.CanBeCasted() || me.IsSilenced() || !Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name))
                            {
                                if (// ethereal
                                       ethereal != null
                                       && ethereal.CanBeCasted()
                                       && me.CanCast()
                                       && !e.IsLinkensProtected()
                                       && !e.IsMagicImmune()
                                       && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name)
                                       && Utils.SleepCheck("ethereal")
                                      )
                                {
                                    ethereal.UseAbility(e);
                                    Utils.Sleep(200, "ethereal");
                                } // ethereal Item end
                                if (ethereal == null || !ethereal.CanBeCasted() || me.IsSilenced() || !Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name))
                                {
                                    if (
                                         Q != null
                                        && Q.CanBeCasted()
                                        && me.CanCast()
                                        && me.Distance2D(e) < 1400
                                         && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                                        && Utils.SleepCheck("Q")
                                        )
                                    {
                                        Q.UseAbility(e);
                                        Utils.Sleep(200, "Q");
                                    }

                                    if (
                                       R != null
                                       && R.CanBeCasted()
                                       && me.CanCast()
                                       && !e.HasModifier("modifier_skywrath_mystic_flare_aura_effect")
                                       && e.MovementSpeed <= 220
                                       && me.Position.Distance2D(e) < 1200
                                       && e.Health >= (e.MaximumHealth / 100 * Menu.Item("Healh").GetValue<Slider>().Value)
                                          && !me.HasModifier("modifier_pugna_nether_ward_aura")
                                          && !e.HasModifier("modifier_item_blade_mail_reflect")
                                       && !e.HasModifier("modifier_skywrath_mystic_flare_aura_effect")
                                       && !e.HasModifier("modifier_obsidian_destroyer_astral_imprisonment_prison")
                                       && !e.HasModifier("modifier_puck_phase_shift")
                                       && !e.HasModifier("modifier_eul_cyclone")
                                          && !e.HasModifier("modifier_dazzle_shallow_grave")
                                       && !e.HasModifier("modifier_brewmaster_storm_cyclone")
                                       && !e.HasModifier("modifier_spirit_breaker_charge_of_darkness")
                                       && !e.HasModifier("modifier_shadow_demon_disruption")
                                       && !e.HasModifier("modifier_tusk_snowball_movement")
                                       && !e.IsMagicImmune()
                                       && (e.FindSpell("abaddon_borrowed_time").Cooldown > 0 && !e.HasModifier("modifier_abaddon_borrowed_time_damage_redirect"))
                                       && (e.FindItem("item_cyclone") != null && e.FindItem("item_cyclone").Cooldown > 0
                                       || (e.FindItem("item_cyclone") == null || e.IsStunned() || e.IsHexed() || e.IsRooted()))
                                       && (e.FindItem("item_force_staff") != null && e.FindItem("item_force_staff").Cooldown > 0
                                       || (e.FindItem("item_force_staff") == null || e.IsStunned() || e.IsHexed() || e.IsRooted()))

                                       && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                                       && Utils.SleepCheck("R"))
                                    {
                                        R.UseAbility(Prediction.InFront(e, 100));
                                        Utils.Sleep(330, "R");
                                    }

                                    if (// SoulRing Item
                                        soul != null
                                        && soul.CanBeCasted()
                                        && me.CanCast()
                                        && me.Health >= (me.MaximumHealth * 0.5)
                                        && me.Mana <= R.ManaCost
                                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(soul.Name)
                                        )
                                    {
                                        soul.UseAbility();
                                    } // SoulRing Item end

                                    if (// Arcane Boots Item
                                        arcane != null
                                        && arcane.CanBeCasted()
                                        && me.CanCast()
                                        && me.Mana <= R.ManaCost
                                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(arcane.Name)
                                        )
                                    {
                                        arcane.UseAbility();
                                    } // Arcane Boots Item end

                                    if (//Ghost
                                        ghost != null
                                        && ghost.CanBeCasted()
                                        && me.CanCast()
                                        && ((me.Position.Distance2D(e) < 300
                                        && me.Health <= (me.MaximumHealth * 0.7))
                                        || me.Health <= (me.MaximumHealth * 0.3))
                                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ghost.Name)
                                        && Utils.SleepCheck("Ghost"))
                                    {
                                        ghost.UseAbility();
                                        Utils.Sleep(250, "Ghost");
                                    }

                                    if (// Shiva Item
                                        shiva != null
                                        && shiva.CanBeCasted()
                                        && me.CanCast()
                                        && !e.IsMagicImmune()
                                        && Utils.SleepCheck("shiva")
                                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(shiva.Name)
                                        && me.Distance2D(e) <= 600
                                        )

                                    {
                                        shiva.UseAbility();
                                        Utils.Sleep(250, "shiva");
                                    } // Shiva Item end

                                    if (// Dagon
                                        me.CanCast()
                                        && dagon != null
                                        && (ethereal == null
                                        || (e.HasModifier("modifier_item_ethereal_blade_slow")
                                        || ethereal.Cooldown < 17))
                                        && !e.IsLinkensProtected()
                                        && dagon.CanBeCasted()
                                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled("item_dagon")
                                        && !e.IsMagicImmune()
                                        && Utils.SleepCheck("dagon")
                                       )
                                    {
                                        dagon.UseAbility(e);
                                        Utils.Sleep(200, "dagon");
                                    } // Dagon Item end

                                    if (
                                         // cheese
                                         cheese != null
                                         && cheese.CanBeCasted()
                                         && me.Health <= (me.MaximumHealth * 0.3)
                                         && me.Distance2D(e) <= 700
                                         && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(cheese.Name)
                                         && Utils.SleepCheck("cheese")
                                     )
                                    {
                                        cheese.UseAbility();
                                        Utils.Sleep(200, "cheese");
                                    } // cheese Item end
                                }
                            }
                        }
                        if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900)
                        {
                            Orbwalking.Orbwalk(e, 0, 1600, true, true);
                        }
                    }
                }
                Utils.Sleep(100, "activated");
            }
        }
        public void Combo()
        {
            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key);

            Push = Game.IsKeyDown(Menu.Item("keyEscape").GetValue<KeyBind>().Key);
            wKey = Game.IsKeyDown(Menu.Item("wKey").GetValue<KeyBind>().Key);
            oneULT = Menu.Item("oneult").IsActive();
            if (!Menu.Item("enabled").IsActive())
                return;

            e = Toolset.ClosestToMouse(me);
            if (Push)
            {
                Unit fount = ObjectManager.GetEntities<Unit>().FirstOrDefault(x => x.Team == me.Team && x.ClassID == ClassID.CDOTA_Unit_Fountain);
                var remnant = ObjectManager.GetEntities<Unit>().Where(unit => unit.IsValid && unit.IsAlive && unit.Team == me.Team && unit.Name == "npc_dota_ember_spirit_remnant").ToList();

                if (fount != null)
                {
                    float angle = me.FindAngleBetween(fount.Position, true);
                    Vector3 pos = new Vector3((float)(me.Position.X + R.GetCastRange() * Math.Cos(angle)),
                        (float)(me.Position.Y + R.GetCastRange() * Math.Sin(angle)), 0);

                    if (remnant.Count(x => x.Distance2D(me) <= 10000) == 0)
                    {
                        if (R != null && R.CanBeCasted()
                            && me.FindModifier("modifier_ember_spirit_fire_remnant_charge_counter").StackCount >= 1
                            && Utils.SleepCheck("z"))
                        {
                            R.UseAbility(pos);
                            Utils.Sleep(1000, "z");
                        }
                    }
                    if (remnant.Count(x => x.Distance2D(me) <= 10000) > 0)
                    {
                        if (D != null && D.CanBeCasted())
                        {
                            for (int i = 0; i < remnant.Count; ++i)
                            {
                                var kill =
                                    remnant[i].Modifiers.Where(y => y.Name == "modifier_ember_spirit_fire_remnant_thinker")
                                        .DefaultIfEmpty(null)
                                        .FirstOrDefault();

                                if (kill != null
                                    && kill.RemainingTime < 44
                                    && Utils.SleepCheck("Rem"))
                                {
                                    D.UseAbility(fount.Position);
                                    Utils.Sleep(300, "Rem");
                                }
                            }
                        }
                    }
                }
            }

            Q = me.Spellbook.SpellQ;

            W = me.Spellbook.SpellW;

            E = me.Spellbook.SpellE;

            R = me.Spellbook.SpellR;

            D = me.Spellbook.SpellD;

            ethereal = me.FindItem("item_ethereal_blade");
            mom = me.FindItem("item_mask_of_madness");
            urn = me.FindItem("item_urn_of_shadows");
            dagon =
                me.Inventory.Items.FirstOrDefault(
                    item =>
                        item.Name.Contains("item_dagon"));
            halberd = me.FindItem("item_heavens_halberd");
            mjollnir = me.FindItem("item_mjollnir");
            orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");
            abyssal = me.FindItem("item_abyssal_blade");
            mail = me.FindItem("item_blade_mail");
            bkb = me.FindItem("item_black_king_bar");
            satanic = me.FindItem("item_satanic");
            blink = me.FindItem("item_blink");
            medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");
            if (e == null) return;
            sheep = e.ClassID == ClassID.CDOTA_Unit_Hero_Tidehunter ? null : me.FindItem("item_sheepstick");
            vail = me.FindItem("item_veil_of_discord");
            cheese = me.FindItem("item_cheese");
            ghost = me.FindItem("item_ghost");
            atos = me.FindItem("item_rod_of_atos");
            soul = me.FindItem("item_soul_ring");
            arcane = me.FindItem("item_arcane_boots");
            stick = me.FindItem("item_magic_stick") ?? me.FindItem("item_magic_wand");
            Shiva = me.FindItem("item_shivas_guard");

            var stoneModif = e.HasModifier("modifier_medusa_stone_gaze_stone");

            var v =
                ObjectManager.GetEntities<Hero>()
                    .Where(x => x.Team != me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion && !x.IsMagicImmune())
                    .ToList();

            if ((Active || wKey) && me.Distance2D(e) <= 1400 && e != null && e.IsAlive)
            {
                if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900)
                {
                    Orbwalking.Orbwalk(e, 0, 1600, true, true);
                }
            }

            if (Active && me.Distance2D(e) <= 1400 && e != null && e.IsAlive && !Toolset.invUnit(e))
            {
                if (stoneModif) return;
                if ( // MOM
                    mom != null
                    && mom.CanBeCasted()
                    && me.CanCast()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mom.Name)
                    && Utils.SleepCheck("mom")
                    && me.Distance2D(e) <= 700
                    )
                {
                    mom.UseAbility();
                    Utils.Sleep(250, "mom");
                }
                if ( // Hellbard
                    halberd != null
                    && halberd.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && (e.NetworkActivity == NetworkActivity.Attack
                        || e.NetworkActivity == NetworkActivity.Crit
                        || e.NetworkActivity == NetworkActivity.Attack2)
                    && Utils.SleepCheck("halberd")
                    && me.Distance2D(e) <= 700
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(halberd.Name)
                    )
                {
                    halberd.UseAbility(e);
                    Utils.Sleep(250, "halberd");
                }
                if ( //Ghost
                    ghost != null
                    && ghost.CanBeCasted()
                    && me.CanCast()
                    && ((me.Position.Distance2D(e) < 300
                         && me.Health <= (me.MaximumHealth * 0.7))
                        || me.Health <= (me.MaximumHealth * 0.3))
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(ghost.Name)
                    && Utils.SleepCheck("Ghost"))
                {
                    ghost.UseAbility();
                    Utils.Sleep(250, "Ghost");
                }
                if ( // Arcane Boots Item
                    arcane != null
                    && me.Mana <= W.ManaCost
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(arcane.Name)
                    && arcane.CanBeCasted()
                    && Utils.SleepCheck("arcane")
                    )
                {
                    arcane.UseAbility();
                    Utils.Sleep(250, "arcane");
                } // Arcane Boots Item end
                if ( // Mjollnir
                    mjollnir != null
                    && mjollnir.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                    && Utils.SleepCheck("mjollnir")
                    && me.Distance2D(e) <= 900
                    )
                {
                    mjollnir.UseAbility(me);
                    Utils.Sleep(250, "mjollnir");
                } // Mjollnir Item end
                if (
                    // cheese
                    cheese != null
                    && cheese.CanBeCasted()
                    && me.Health <= (me.MaximumHealth * 0.3)
                    && me.Distance2D(e) <= 700
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(cheese.Name)
                    && Utils.SleepCheck("cheese")
                    )
                {
                    cheese.UseAbility();
                    Utils.Sleep(200, "cheese");
                } // cheese Item end
                if ( // Medall
                    medall != null
                    && medall.CanBeCasted()
                    && Utils.SleepCheck("Medall")
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                    && me.Distance2D(e) <= 700
                    )
                {
                    medall.UseAbility(e);
                    Utils.Sleep(250, "Medall");
                } // Medall Item end
                if (
                    W != null && W.CanBeCasted() && me.Distance2D(e) <= 700
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                    && Utils.SleepCheck("W")
                    )
                {
                    W.UseAbility(e.Predict(300));
                    Utils.Sleep(200, "W");
                }
                if ( // Q Skill
                    Q != null
                    && Q.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                    && me.Distance2D(e) <= 150 &&
                    Utils.SleepCheck("Q")
                    )

                {
                    Q.UseAbility();
                    Utils.Sleep(50, "Q");
                } // Q Skill end

                if ( // W Skill
                    W != null
                    && W.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                    && Utils.SleepCheck("W")
                    )
                {
                    W.UseAbility(e.Position);
                    Utils.Sleep(200, "W");
                } // W Skill end
                if ( // E Skill
                    E != null
                    && E.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Utils.SleepCheck("E")
                    && me.Distance2D(e) <= 400
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(E.Name)
                    )
                {
                    E.UseAbility();
                    Utils.Sleep(350, "E");
                } // E Skill end
                if ( //R Skill
                    R != null
                    && !oneULT
                    && R.CanBeCasted()
                    && me.CanCast()
                    && me.Distance2D(e) <= 1100
                    && Utils.SleepCheck("R")
                    )
                {
                    R.UseAbility(e.Predict(700));
                    Utils.Sleep(110, "R");
                } // R Skill end
                if ( //R Skill
                    R != null
                    && oneULT
                    && R.CanBeCasted()
                    && me.CanCast()
                    && me.Distance2D(e) <= 1100
                    && Utils.SleepCheck("R")
                    )
                {
                    R.UseAbility(e.Predict(700));
                    Utils.Sleep(5000, "R");
                } // R Skill end
                if ( // sheep
                    sheep != null
                    && sheep.CanBeCasted()
                    && me.CanCast()
                    && !e.IsLinkensProtected()
                    && !e.IsMagicImmune()
                    && me.Distance2D(e) <= 1400
                    && !stoneModif
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(sheep.Name)
                    && Utils.SleepCheck("sheep")
                    )
                {
                    sheep.UseAbility(e);
                    Utils.Sleep(250, "sheep");
                } // sheep Item end
                if ( // Abyssal Blade
                    abyssal != null
                    && abyssal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsStunned()
                    && !e.IsHexed()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(abyssal.Name)
                    && Utils.SleepCheck("abyssal")
                    && me.Distance2D(e) <= 400
                    )
                {
                    abyssal.UseAbility(e);
                    Utils.Sleep(250, "abyssal");
                } // Abyssal Item end
                if (orchid != null && orchid.CanBeCasted() && me.Distance2D(e) <= 900
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name) &&
                    Utils.SleepCheck("orchid"))
                {
                    orchid.UseAbility(e);
                    Utils.Sleep(100, "orchid");
                }

                if (Shiva != null && Shiva.CanBeCasted() && me.Distance2D(e) <= 600
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name)
                    && !e.IsMagicImmune() && Utils.SleepCheck("Shiva"))
                {
                    Shiva.UseAbility();
                    Utils.Sleep(100, "Shiva");
                }
                if ( // ethereal
                    ethereal != null
                    && ethereal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsLinkensProtected()
                    && !e.IsMagicImmune()
                    && !stoneModif
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name)
                    && Utils.SleepCheck("ethereal")
                    )
                {
                    ethereal.UseAbility(e);
                    Utils.Sleep(200, "ethereal");
                } // ethereal Item end
                if (
                    blink != null
                    && me.CanCast()
                    && blink.CanBeCasted()
                    && me.Distance2D(e) >= 450
                    && me.Distance2D(e) <= 1150
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                    && Utils.SleepCheck("blink")
                    )
                {
                    blink.UseAbility(e.Position);
                    Utils.Sleep(250, "blink");
                }

                if ( // SoulRing Item
                    soul != null
                    && soul.CanBeCasted()
                    && me.CanCast()
                    && me.Health >= (me.MaximumHealth * 0.5)
                    && me.Mana <= R.ManaCost
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(soul.Name)
                    )
                {
                    soul.UseAbility();
                } // SoulRing Item end
                if ( // Dagon
                    me.CanCast()
                    && dagon != null
                    && (ethereal == null
                        || (e.HasModifier("modifier_item_ethereal_blade_slow")
                            || ethereal.Cooldown < 17))
                    && !e.IsLinkensProtected()
                    && dagon.CanBeCasted()
                    && !e.IsMagicImmune()
                    && !stoneModif
                    && Utils.SleepCheck("dagon")
                    )
                {
                    dagon.UseAbility(e);
                    Utils.Sleep(200, "dagon");
                } // Dagon Item end
                if ( // atos Blade
                    atos != null
                    && atos.CanBeCasted()
                    && me.CanCast()
                    && !e.IsLinkensProtected()
                    && !e.IsMagicImmune()
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(atos.Name)
                    && me.Distance2D(e) <= 2000
                    && Utils.SleepCheck("atos")
                    )
                {
                    atos.UseAbility(e);

                    Utils.Sleep(250, "atos");
                } // atos Item end
                if (urn != null && urn.CanBeCasted() && urn.CurrentCharges > 0 && me.Distance2D(e) <= 400
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(urn.Name) && Utils.SleepCheck("urn"))
                {
                    urn.UseAbility(e);
                    Utils.Sleep(240, "urn");
                }
                if ( // vail
                    vail != null
                    && vail.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name)
                    && me.Distance2D(e) <= 1500
                    && Utils.SleepCheck("vail")
                    )
                {
                    vail.UseAbility(e.Position);
                    Utils.Sleep(250, "vail");
                } // orchid Item end
                  /*	if (
                      force != null
                      && force.CanBeCasted()
                      && me.Distance2D(e) < force.GetCastRange()
                      && Utils.SleepCheck(e.Handle.ToString()))
                  {
                      force.UseAbility(e);
                      Utils.Sleep(500, e.Handle.ToString());
                  }
              */
                if (
                    stick != null
                    && stick.CanBeCasted()
                    && stick.CurrentCharges != 0
                    && me.Distance2D(e) <= 700
                    && (me.Health <= (me.MaximumHealth * 0.5)
                        || me.Mana <= (me.MaximumMana * 0.5))
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(stick.Name))
                {
                    stick.UseAbility();
                    Utils.Sleep(200, "mana_items");
                }
                if ( // Satanic
                    satanic != null &&
                    me.Health <= (me.MaximumHealth * 0.3) &&
                    satanic.CanBeCasted() &&
                    me.Distance2D(e) <= me.AttackRange + 50
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                    && Utils.SleepCheck("satanic")
                    )
                {
                    satanic.UseAbility();
                    Utils.Sleep(240, "satanic");
                } // Satanic Item end
                if (mail != null && mail.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                           (Menu.Item("Heelm").GetValue<Slider>().Value)) &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mail.Name) && Utils.SleepCheck("mail"))
                {
                    mail.UseAbility();
                    Utils.Sleep(100, "mail");
                }
                if (bkb != null && bkb.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                         (Menu.Item("Heel").GetValue<Slider>().Value)) &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(bkb.Name) && Utils.SleepCheck("bkb"))
                {
                    bkb.UseAbility();
                    Utils.Sleep(100, "bkb");
                }

                var remnant = ObjectManager.GetEntities<Unit>().Where(unit => unit.Name == "npc_dota_ember_spirit_remnant").ToList();

                if (remnant.Count <= 0)
                    return;
                for (int i = 0; i < remnant.Count; ++i)
                {
                    if (//D Skill
                       remnant != null
                       && D.CanBeCasted()
                       && me.CanCast()
                       && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(D.Name)
                       && remnant[i].Distance2D(e) <= 500
                       && Utils.SleepCheck("D")
                       )
                    {
                        D.UseAbility(e.Position);
                        Utils.Sleep(400, "D");
                    }
                }
            }
            if (wKey && me.Distance2D(e) <= 1400 && e != null && e.IsAlive)
            {
                if ( // Q Skill
                    Q != null
                    && Q.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                    && me.Distance2D(e) <= 150 &&
                    Utils.SleepCheck("Q")
                    )

                {
                    Q.UseAbility();
                    Utils.Sleep(50, "Q");
                } // Q Skill end

                if ( // W Skill
                    W != null
                    && W.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                    && Utils.SleepCheck("W")
                    )
                {
                    W.UseAbility(e.Position);
                    Utils.Sleep(200, "W");
                } // W Skill end
            }
            else if (wKey && me.Distance2D(e) <= 1400 && e != null && e.IsAlive && !Toolset.invUnit(e))
            {
                if ( // MOM
                    mom != null
                    && mom.CanBeCasted()
                    && me.CanCast()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mom.Name)
                    && Utils.SleepCheck("mom")
                    && me.Distance2D(e) <= 700
                    )
                {
                    mom.UseAbility();
                    Utils.Sleep(250, "mom");
                }
                if ( // Hellbard
                    halberd != null
                    && halberd.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && (e.NetworkActivity == NetworkActivity.Attack
                        || e.NetworkActivity == NetworkActivity.Crit
                        || e.NetworkActivity == NetworkActivity.Attack2)
                    && Utils.SleepCheck("halberd")
                    && me.Distance2D(e) <= 700
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(halberd.Name)
                    )
                {
                    halberd.UseAbility(e);
                    Utils.Sleep(250, "halberd");
                }
                if ( //Ghost
                    ghost != null
                    && ghost.CanBeCasted()
                    && me.CanCast()
                    && ((me.Position.Distance2D(e) < 300
                         && me.Health <= (me.MaximumHealth * 0.7))
                        || me.Health <= (me.MaximumHealth * 0.3))
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(ghost.Name)
                    && Utils.SleepCheck("Ghost"))
                {
                    ghost.UseAbility();
                    Utils.Sleep(250, "Ghost");
                }
                if ( // Arcane Boots Item
                    arcane != null
                    && me.Mana <= W.ManaCost
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(arcane.Name)
                    && arcane.CanBeCasted()
                    && Utils.SleepCheck("arcane")
                    )
                {
                    arcane.UseAbility();
                    Utils.Sleep(250, "arcane");
                } // Arcane Boots Item end
                if ( // Mjollnir
                    mjollnir != null
                    && mjollnir.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                    && Utils.SleepCheck("mjollnir")
                    && me.Distance2D(e) <= 900
                    )
                {
                    mjollnir.UseAbility(me);
                    Utils.Sleep(250, "mjollnir");
                } // Mjollnir Item end
                if (
                    // cheese
                    cheese != null
                    && cheese.CanBeCasted()
                    && me.Health <= (me.MaximumHealth * 0.3)
                    && me.Distance2D(e) <= 700
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(cheese.Name)
                    && Utils.SleepCheck("cheese")
                    )
                {
                    cheese.UseAbility();
                    Utils.Sleep(200, "cheese");
                } // cheese Item end
                if ( // Medall
                    medall != null
                    && medall.CanBeCasted()
                    && Utils.SleepCheck("Medall")
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                    && me.Distance2D(e) <= 700
                    )
                {
                    medall.UseAbility(e);
                    Utils.Sleep(250, "Medall");
                } // Medall Item end

                if ( // Q Skill
                    Q != null
                    && Q.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                    && me.Distance2D(e) <= 150 &&
                    Utils.SleepCheck("Q")
                    )

                {
                    Q.UseAbility();
                    Utils.Sleep(50, "Q");
                } // Q Skill end

                if ( // W Skill
                    W != null
                    && W.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                    && Utils.SleepCheck("W")
                    )
                {
                    W.UseAbility(e.Position);
                    Utils.Sleep(200, "W");
                } // W Skill end

                if ( // sheep
                    sheep != null
                    && sheep.CanBeCasted()
                    && me.CanCast()
                    && !e.IsLinkensProtected()
                    && !e.IsMagicImmune()
                    && me.Distance2D(e) <= 1400
                    && !stoneModif
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(sheep.Name)
                    && Utils.SleepCheck("sheep")
                    )
                {
                    sheep.UseAbility(e);
                    Utils.Sleep(250, "sheep");
                } // sheep Item end
                if ( // Abyssal Blade
                    abyssal != null
                    && abyssal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsStunned()
                    && !e.IsHexed()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(abyssal.Name)
                    && Utils.SleepCheck("abyssal")
                    && me.Distance2D(e) <= 400
                    )
                {
                    abyssal.UseAbility(e);
                    Utils.Sleep(250, "abyssal");
                } // Abyssal Item end
                if (orchid != null && orchid.CanBeCasted() && me.Distance2D(e) <= 900
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name) &&
                    Utils.SleepCheck("orchid"))
                {
                    orchid.UseAbility(e);
                    Utils.Sleep(100, "orchid");
                }

                if (Shiva != null && Shiva.CanBeCasted() && me.Distance2D(e) <= 600
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name)
                    && !e.IsMagicImmune() && Utils.SleepCheck("Shiva"))
                {
                    Shiva.UseAbility();
                    Utils.Sleep(100, "Shiva");
                }
                if ( // ethereal
                    ethereal != null
                    && ethereal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsLinkensProtected()
                    && !e.IsMagicImmune()
                    && !stoneModif
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name)
                    && Utils.SleepCheck("ethereal")
                    )
                {
                    ethereal.UseAbility(e);
                    Utils.Sleep(200, "ethereal");
                } // ethereal Item end
                if (
                    blink != null
                    && me.CanCast()
                    && blink.CanBeCasted()
                    && me.Distance2D(e) >= 450
                    && me.Distance2D(e) <= 1150
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                    && Utils.SleepCheck("blink")
                    )
                {
                    blink.UseAbility(e.Position);
                    Utils.Sleep(250, "blink");
                }

                if ( // SoulRing Item
                    soul != null
                    && soul.CanBeCasted()
                    && me.CanCast()
                    && me.Health >= (me.MaximumHealth * 0.5)
                    && me.Mana <= R.ManaCost
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(soul.Name)
                    )
                {
                    soul.UseAbility();
                } // SoulRing Item end
                if ( // Dagon
                    me.CanCast()
                    && dagon != null
                    && (ethereal == null
                        || (e.HasModifier("modifier_item_ethereal_blade_slow")
                            || ethereal.Cooldown < 17))
                    && !e.IsLinkensProtected()
                    && dagon.CanBeCasted()
                    && !e.IsMagicImmune()
                    && !stoneModif
                    && Utils.SleepCheck("dagon")
                    )
                {
                    dagon.UseAbility(e);
                    Utils.Sleep(200, "dagon");
                } // Dagon Item end
                if ( // atos Blade
                    atos != null
                    && atos.CanBeCasted()
                    && me.CanCast()
                    && !e.IsLinkensProtected()
                    && !e.IsMagicImmune()
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(atos.Name)
                    && me.Distance2D(e) <= 2000
                    && Utils.SleepCheck("atos")
                    )
                {
                    atos.UseAbility(e);

                    Utils.Sleep(250, "atos");
                } // atos Item end
                if (urn != null && urn.CanBeCasted() && urn.CurrentCharges > 0 && me.Distance2D(e) <= 400
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(urn.Name) && Utils.SleepCheck("urn"))
                {
                    urn.UseAbility(e);
                    Utils.Sleep(240, "urn");
                }
                if ( // vail
                    vail != null
                    && vail.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name)
                    && me.Distance2D(e) <= 1500
                    && Utils.SleepCheck("vail")
                    )
                {
                    vail.UseAbility(e.Position);
                    Utils.Sleep(250, "vail");
                } // orchid Item end

                if (
                    stick != null
                    && stick.CanBeCasted()
                    && stick.CurrentCharges != 0
                    && me.Distance2D(e) <= 700
                    && (me.Health <= (me.MaximumHealth * 0.5)
                        || me.Mana <= (me.MaximumMana * 0.5))
                    && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(stick.Name))
                {
                    stick.UseAbility();
                    Utils.Sleep(200, "mana_items");
                }
                if ( // Satanic
                    satanic != null &&
                    me.Health <= (me.MaximumHealth * 0.3) &&
                    satanic.CanBeCasted() &&
                    me.Distance2D(e) <= me.AttackRange + 50
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                    && Utils.SleepCheck("satanic")
                    )
                {
                    satanic.UseAbility();
                    Utils.Sleep(240, "satanic");
                }

            }
        }
Пример #16
0
        public void Combo()
        {
            // Target initialization

            // Spells initialization
            Q = me.Spellbook.SpellQ;
            W = me.Spellbook.SpellW;
            E = me.Spellbook.SpellE;
            R = me.Spellbook.SpellR;
            // Items initialization
            ethereal = me.FindItem("item_ethereal_blade");
            vail = me.FindItem("item_veil_of_discord");
            cheese = me.FindItem("item_cheese");
            ghost = me.FindItem("item_ghost");
            orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");
            atos = me.FindItem("item_rod_of_atos");
            soul = me.FindItem("item_soul_ring");
            arcane = me.FindItem("item_arcane_boots");
            blink = me.FindItem("item_blink");
            shiva = me.FindItem("item_shivas_guard");
            dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));

            // State of keys initialization
            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key) && !Game.IsChatOpen;
            Push = Game.IsKeyDown(Menu.Item("keyQ").GetValue<KeyBind>().Key) && !Game.IsChatOpen;

            enemies = ObjectManager.GetEntities<Hero>()
                 .Where(x => x.IsVisible && x.IsAlive && x.Team != me.Team && !x.IsFullMagicResist() && !x.IsIllusion).ToList();
            // OnUpdateEvent::END

            // [VickTheRock]

            if (Push)
            {
                if (Q == null) return;

                var unitsList = ObjectManager.GetEntities<Unit>().Where(creep =>
                    (creep.ClassID == ClassID.CDOTA_BaseNPC_Creep_Neutral
                    || creep.ClassID == ClassID.CDOTA_BaseNPC_Invoker_Forged_Spirit
                    || creep.ClassID == ClassID.CDOTA_BaseNPC_Warlock_Golem
                    || creep.ClassID == ClassID.CDOTA_BaseNPC_Creep
                    || creep.ClassID == ClassID.CDOTA_BaseNPC_Creep_Lane
                    || creep.ClassID == ClassID.CDOTA_Unit_Hero_Beastmaster_Boar
                    || creep.ClassID == ClassID.CDOTA_Unit_SpiritBear
                    || creep.ClassID == ClassID.CDOTA_Unit_Broodmother_Spiderling
                    )
                    && creep.IsAlive
                    && creep.Distance2D(me) <= Q.GetCastRange() + me.HullRadius
                    && creep.IsSpawned
                    && creep.Team != me.Team
                    ).ToList();

                foreach (var v in unitsList)
                {
                    var damageQ = qDmg[Q.Level];
                    if (me.Distance2D(v) < 1200)
                        damageQ += E.GetAbilityData("damage_health_pct") * 0.01 * v.Health;

                    var lens = me.HasModifier("modifier_item_aether_lens");
                    var spellamplymult = 1 + (me.TotalIntelligence / 16 / 100);
                    if (lens) damageQ *= 1.08;
                    damageQ *= spellamplymult;
                    damageQ *= (1 - v.MagicDamageResist);
                    if (Q.CanBeCasted() && v.Distance2D(me) <= Q.GetCastRange() + me.HullRadius && v.Health <= damageQ && Utils.SleepCheck("qq"))
                    {
                        Q.UseAbility(v);
                        Utils.Sleep(250, "qq");
                    }
                }
            } // if(Push)::END

            e = Toolset.ClosestToMouse(me);
            if (e == null) return;

            var modifEther = e.HasModifier("modifier_item_ethereal_blade_slow");
            var stoneModif = e.HasModifier("modifier_medusa_stone_gaze_stone");
            sheep = e.Name == "npc_dota_hero_tidehunter" ? null : me.FindItem("item_sheepstick");

            if (Active && me.IsAlive && e.IsAlive && Utils.SleepCheck("activated"))
            {
                var noBlade = e.HasModifier("modifier_item_blade_mail_reflect");
                if (e.IsVisible && me.Distance2D(e) <= 2300 && !noBlade)
                {
                    if ( // atos Blade
                        atos != null
                        && atos.CanBeCasted()
                        && me.CanCast()
                        && !e.IsLinkensProtected()
                        && !e.IsMagicImmune()
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(atos.Name)
                        && me.Distance2D(e) <= 2000
                        && Utils.SleepCheck("atos")
                        )
                    {
                        atos.UseAbility(e);
                        Utils.Sleep(250, "atos");
                    } // atos Item end

                    if (
                        blink != null
                        && Q.CanBeCasted()
                        && me.CanCast()
                        && blink.CanBeCasted()
                        && me.Distance2D(e) > 1000
                        && !stoneModif
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                        && Utils.SleepCheck("blink")
                        )
                    {
                        blink.UseAbility(e.Position);
                        Utils.Sleep(250, "blink");
                    }
                    if ( // orchid
                        orchid != null
                        && orchid.CanBeCasted()
                        && me.CanCast()
                        && !e.IsLinkensProtected()
                        && !e.IsMagicImmune()
                        && me.Distance2D(e) <= 1400
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name)
                        && !stoneModif
                        && Utils.SleepCheck("orchid")
                        )
                    {
                        orchid.UseAbility(e);
                        Utils.Sleep(250, "orchid");
                    } // orchid Item end
                    if (!orchid.CanBeCasted() || orchid == null ||
                        !Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name))
                    {
                        if ( // vail
                            vail != null
                            && vail.CanBeCasted()
                            && me.CanCast()
                            && !e.IsMagicImmune()
                            && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name)
                            && me.Distance2D(e) <= 1500
                            && Utils.SleepCheck("vail")
                            )
                        {
                            vail.UseAbility(e.Position);
                            Utils.Sleep(250, "vail");
                        } // orchid Item end
                        if (!vail.CanBeCasted() || vail == null ||
                            !Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name))
                        {
                            if ( // ethereal
                                ethereal != null
                                && ethereal.CanBeCasted()
                                && me.CanCast()
                                && !e.IsLinkensProtected()
                                && !e.IsMagicImmune()
                                && !stoneModif
                                && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name)
                                && Utils.SleepCheck("ethereal")
                                )
                            {
                                ethereal.UseAbility(e);
                                Utils.Sleep(200, "ethereal");
                            } // ethereal Item end
                            if (!ethereal.CanBeCasted() || ethereal == null ||
                                !Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name))
                            {
                                if (
                                    W != null
                                    && W.CanBeCasted()
                                    && me.CanCast()
                                    && me.Distance2D(e) < W.GetCastRange()+me.HullRadius
                                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                                    && Utils.SleepCheck("W"))
                                {
                                    W.UseAbility(e.Position);
                                    Utils.Sleep(200, "W");
                                }
                                float angle = me.FindAngleBetween(E.Position, true);
                                Vector3 pos = new Vector3((float)(e.Position.X - 290 * Math.Cos(angle)), (float)(e.Position.Y - 290 * Math.Sin(angle)), 0);
                                var Units = ObjectManager.GetEntities<Hero>().Where(x =>
                                             !x.Equals(e)
                                             && x.IsAlive
                                             && x.Distance2D(pos) < e.Distance2D(pos)
                                             && x.Distance2D(e) <= 320
                                             && x.Team != me.Team
                                             ).ToList();
                                if (
                                   W != null
                                   && W.CanBeCasted()
                                   && me.CanCast()
                                   && Units.Count(x => x.Distance2D(pos) <= 290) == 0
                                   && me.Distance2D(e) > W.GetCastRange() + me.HullRadius
                                   && me.Distance2D(e) < W.GetCastRange() + 300
                                   && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                                   && Utils.SleepCheck("W"))
                                {
                                    W.UseAbility(e.Position);
                                    Utils.Sleep(200, "W");
                                }
                                if (
                                    Q != null
                                    && Q.CanBeCasted()
                                    && (!W.CanBeCasted() || e.Health <= (e.MaximumHealth * 0.5))
                                    && (e.IsLinkensProtected()
                                        || !e.IsLinkensProtected())
                                    && me.CanCast()
                                    && me.Distance2D(e) < 1400
                                    && !stoneModif
                                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                                    && Utils.SleepCheck("Q")
                                    )
                                {
                                    Q.UseAbility(e);
                                    Utils.Sleep(330, "Q");
                                }
                                if (
                                    R != null
                                    && R.CanBeCasted()
                                    && !Q.CanBeCasted()
                                    && !W.CanBeCasted()
                                    && me.CanCast()
                                    && me.Position.Distance2D(e) < 1200
                                    && e.Health <= (e.MaximumHealth * 0.5)
                                    && !stoneModif
                                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                                    && Utils.SleepCheck("R"))
                                {
                                    R.UseAbility();
                                    Utils.Sleep(330, "R");
                                }
                                if ( // SoulRing Item
                                    soul != null
                                    && soul.CanBeCasted()
                                    && me.CanCast()
                                    && me.Health >= (me.MaximumHealth * 0.6)
                                    && me.Mana <= R.ManaCost
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(soul.Name)
                                    )
                                {
                                    soul.UseAbility();
                                } // SoulRing Item end

                                if ( // Arcane Boots Item
                                    arcane != null
                                    && arcane.CanBeCasted()
                                    && me.CanCast()
                                    && me.Mana <= R.ManaCost
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(arcane.Name)
                                    )
                                {
                                    arcane.UseAbility();
                                } // Arcane Boots Item end

                                if ( //Ghost
                                    ghost != null
                                    && ghost.CanBeCasted()
                                    && me.CanCast()
                                    && ((me.Position.Distance2D(e) < 300
                                         && me.Health <= (me.MaximumHealth * 0.7))
                                        || me.Health <= (me.MaximumHealth * 0.3))
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ghost.Name)
                                    && Utils.SleepCheck("Ghost"))
                                {
                                    ghost.UseAbility();
                                    Utils.Sleep(250, "Ghost");
                                }

                                if ( // Shiva Item
                                    shiva != null
                                    && shiva.CanBeCasted()
                                    && me.CanCast()
                                    && !e.IsMagicImmune()
                                    && Utils.SleepCheck("shiva")
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(shiva.Name)
                                    && me.Distance2D(e) <= 600
                                    )

                                {
                                    shiva.UseAbility();
                                    Utils.Sleep(250, "shiva");
                                } // Shiva Item end
                                if ( // sheep
                                    sheep != null
                                    && sheep.CanBeCasted()
                                    && me.CanCast()
                                    && !e.IsLinkensProtected()
                                    && !e.IsMagicImmune()
                                    && me.Distance2D(e) <= 1400
                                    && !stoneModif
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(sheep.Name)
                                    && Utils.SleepCheck("sheep")
                                    )
                                {
                                    sheep.UseAbility(e);
                                    Utils.Sleep(250, "sheep");
                                } // sheep Item end

                                if ( // Dagon
                                    me.CanCast()
                                    && dagon != null
                                    && (ethereal == null
                                        || (modifEther
                                            || ethereal.Cooldown < 17))
                                    && !e.IsLinkensProtected()
                                    && dagon.CanBeCasted()
                                    && me.Distance2D(e) <= 1400
                                    && !e.IsMagicImmune()
                                    && !stoneModif
                                    && Utils.SleepCheck("dagon")
                                    )
                                {
                                    dagon.UseAbility(e);
                                    Utils.Sleep(200, "dagon");
                                } // Dagon Item end

                                if (
                                    // cheese
                                    cheese != null
                                    && cheese.CanBeCasted()
                                    && me.Health <= (me.MaximumHealth * 0.3)
                                    && me.Distance2D(e) <= 700
                                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(cheese.Name)
                                    && Utils.SleepCheck("cheese")
                                    )
                                {
                                    cheese.UseAbility();
                                    Utils.Sleep(200, "cheese");
                                } // cheese Item end
                            }
                        }
                    }
                    Utils.Sleep(200, "activated");
                } // if(e.IsVisible)::END

                if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900)
                {
                    Orbwalking.Orbwalk(e, 0, 1600, true, true);
                }
            } // if(Active)::END

            // Run real-time modules
            AutoSpells();
        }
Пример #17
0
        public void Combo()
        {
            Active = Game.IsKeyDown(menu.Item("keyBind").GetValue<KeyBind>().Key);

            Q = me.Spellbook.SpellQ;
            R = me.Spellbook.SpellR;
            E = me.Spellbook.SpellE;

            mom = me.FindItem("item_mask_of_madness");
            urn = me.FindItem("item_urn_of_shadows");
            dagon = me.Inventory.Items.FirstOrDefault(x => x.Name.Contains("item_dagon"));
            ethereal = me.FindItem("item_ethereal_blade");
            halberd = me.FindItem("item_heavens_halberd");
            mjollnir = me.FindItem("item_mjollnir");
            blink = me.FindItem("item_blink");
            orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");
            abyssal = me.FindItem("item_abyssal_blade");
            mail = me.FindItem("item_blade_mail");
            bkb = me.FindItem("item_black_king_bar");
            satanic = me.FindItem("item_satanic");
            medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");
            Shiva = me.FindItem("item_shivas_guard");
            var v =
                ObjectManager.GetEntities<Hero>()
                    .Where(x => x.Team != me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion && !x.IsMagicImmune())
                    .ToList();
            e = me.ClosestToMouseTarget(1800);
            if (e == null)
                return;
            if (Active)
            {
                if (
                    me.Distance2D(e) <= me.AttackRange + 100 && (!me.IsAttackImmune() || !e.IsAttackImmune())
                    && me.NetworkActivity != NetworkActivity.Attack && me.CanAttack() && Utils.SleepCheck("attack")
                          )
                {
                    me.Attack(e);
                    Utils.Sleep(150, "attack");
                }
                else if (
                    (!me.CanAttack() || me.Distance2D(e) >= 0) && me.NetworkActivity != NetworkActivity.Attack &&
                    me.Distance2D(e) <= 1000 && Utils.SleepCheck("Move")
                    )
                {
                    me.Move(e.Predict(300));
                    Utils.Sleep(390, "Move");
                }

            }
            if (Active && me.Distance2D(e) <= 1400 && e != null && e.IsAlive && !Toolset.invUnit(me))
            {
                if (
                        blink != null
                        && Q.CanBeCasted()
                        && me.CanCast()
                        && blink.CanBeCasted()
                        && me.Distance2D(e) < 1180
                        && me.Distance2D(e) > 700
                        && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                        && Utils.SleepCheck("blink")
                        )
                {
                    blink.UseAbility(e.Position);

                    Utils.Sleep(250, "blink");
                }
                if (
                    Q != null && Q.CanBeCasted() && me.Distance2D(e) <= Q.CastRange
                    && me.CanAttack()
                    && menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                    && Utils.SleepCheck("Q")
                    )
                {
                    Q.UseAbility(e.Predict(250));
                    Utils.Sleep(150, "Q");
                }
                if (
                    E != null && E.CanBeCasted() && me.Distance2D(e) <= 800
                    && !Q.CanBeCasted()
                    && !R.CanBeCasted()
                    && menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(E.Name)
                    && me.NetworkActivity != NetworkActivity.Attack
                    && Utils.SleepCheck("E")
                    )
                {
                    E.UseAbility(e.Position);
                    Utils.Sleep(150, "E");
                }
                var enemy = ObjectManager.GetEntities<Hero>().Where(x => x.IsAlive && x.Team != me.Team).ToList();
                for (int i = 0; i < enemy.Count(); i++)
                {
                    if (
                    R != null && R.CanBeCasted() && me.Distance2D(enemy[i]) <= 800
                    && !Q.CanBeCasted()
                    && menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                    && Utils.SleepCheck("R")
                    )
                    {
                        R.UseAbility();
                        Utils.Sleep(250, "R");
                    }
                }
                if ( // MOM
                mom != null
                && mom.CanBeCasted()
                && me.CanCast()
                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mom.Name)
                && Utils.SleepCheck("mom")
                && me.Distance2D(e) <= 700
                )
                {
                    mom.UseAbility();
                    Utils.Sleep(250, "mom");
                }
                if ( // Mjollnir
                    mjollnir != null
                    && mjollnir.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                    && Utils.SleepCheck("mjollnir")
                    && me.Distance2D(e) <= 900
                    )
                {
                    mjollnir.UseAbility(me);
                    Utils.Sleep(250, "mjollnir");
                } // Mjollnir Item end
                if ( // Medall
                    medall != null
                    && medall.CanBeCasted()
                    && Utils.SleepCheck("Medall")
                    && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                    && me.Distance2D(e) <= 700
                    )
                {
                    medall.UseAbility(e);
                    Utils.Sleep(250, "Medall");
                } // Medall Item end
                if ( // orchid
                    orchid != null
                    && orchid.CanBeCasted()
                    && me.CanCast()
                    && !e.IsLinkensProtected()
                    && !e.IsMagicImmune()
                    && me.Distance2D(e) <= me.AttackRange + 40
                    && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name)
                    && Utils.SleepCheck("orchid")
                    )
                {
                    orchid.UseAbility(e);
                    Utils.Sleep(250, "orchid");
                } // orchid Item end

                if (Shiva != null && Shiva.CanBeCasted() && me.Distance2D(e) <= 600
                    && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name)
                    && !e.IsMagicImmune() && Utils.SleepCheck("Shiva"))
                {
                    Shiva.UseAbility();
                    Utils.Sleep(100, "Shiva");
                }

                if (ethereal != null && ethereal.CanBeCasted()
                    && me.Distance2D(e) <= 700 && me.Distance2D(e) <= 400
                    && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name) &&
                    Utils.SleepCheck("ethereal"))
                {
                    ethereal.UseAbility(e);
                    Utils.Sleep(100, "ethereal");
                }

                if (dagon != null
                    && dagon.CanBeCasted()
                    && me.Distance2D(e) <= 500
                    && Utils.SleepCheck("dagon"))
                {
                    dagon.UseAbility(e);
                    Utils.Sleep(100, "dagon");
                }
                if ( // Abyssal Blade
                    abyssal != null
                    && abyssal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsStunned()
                    && !e.IsHexed()
                    && Utils.SleepCheck("abyssal")
                    && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(abyssal.Name)
                    && me.Distance2D(e) <= 400
                    )
                {
                    abyssal.UseAbility(e);
                    Utils.Sleep(250, "abyssal");
                } // Abyssal Item end
                if (urn != null && urn.CanBeCasted() && urn.CurrentCharges > 0 && me.Distance2D(e) <= 400
                    && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(urn.Name) && Utils.SleepCheck("urn"))
                {
                    urn.UseAbility(e);
                    Utils.Sleep(240, "urn");
                }
                if ( // Hellbard
                    halberd != null
                    && halberd.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && (e.NetworkActivity == NetworkActivity.Attack
                        || e.NetworkActivity == NetworkActivity.Crit
                        || e.NetworkActivity == NetworkActivity.Attack2)
                    && Utils.SleepCheck("halberd")
                    && me.Distance2D(e) <= 700
                    && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(halberd.Name)
                    )
                {
                    halberd.UseAbility(e);
                    Utils.Sleep(250, "halberd");
                }
                if ( // Satanic
                    satanic != null &&
                    me.Health <= (me.MaximumHealth * 0.3) &&
                    satanic.CanBeCasted() &&
                    me.Distance2D(e) <= me.AttackRange + 50
                    && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                    && Utils.SleepCheck("satanic")
                    )
                {
                    satanic.UseAbility();
                    Utils.Sleep(240, "satanic");
                } // Satanic Item end
                if (mail != null && mail.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                           (menu.Item("Heelm").GetValue<Slider>().Value)) &&
                    menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mail.Name) && Utils.SleepCheck("mail"))
                {
                    mail.UseAbility();
                    Utils.Sleep(100, "mail");
                }
                if (bkb != null && bkb.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                         (menu.Item("Heel").GetValue<Slider>().Value)) &&
                    menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(bkb.Name) && Utils.SleepCheck("bkb"))
                {
                    bkb.UseAbility();
                    Utils.Sleep(100, "bkb");
                }
            }
        }
Пример #18
0
		public static void Game_OnUpdate(EventArgs args)
		{
			var me = ObjectMgr.LocalHero;

			if (!Game.IsInGame || me.ClassID != ClassID.CDOTA_Unit_Hero_Skywrath_Mage || me == null || Game.IsWatchingGame)
			{
				return;
			}

			var target = me.ClosestToMouseTarget(2000);
			if (target == null)
			{
				return;
			}
			
			//spell
			Q = me.Spellbook.SpellQ;

			W = me.Spellbook.SpellW;

			E = me.Spellbook.SpellE;

			R = me.Spellbook.SpellR;
			
			// Item
			ethereal = me.FindItem("item_ethereal_blade");

			sheep = target.ClassID == ClassID.CDOTA_Unit_Hero_Tidehunter ? null : me.FindItem("item_sheepstick");

			vail = me.FindItem("item_veil_of_discord");

			cheese = me.FindItem("item_cheese");

			ghost = me.FindItem("item_ghost");

			orchid = me.FindItem("item_orchid");

			atos = me.FindItem("item_rod_of_atos");

			soulring = me.FindItem("item_soul_ring");

			arcane = me.FindItem("item_arcane_boots");

			blink = me.FindItem("item_blink");

			shiva = me.FindItem("item_shivas_guard");

			dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));




			
			var ModifW = target.Modifiers.Any(y => y.Name == "modifier_skywrath_mage_concussive_shot_slow");
			var ModifR = target.Modifiers.Any(y => y.Name == "modifier_skywrath_mystic_flare_aura_effect");
			var ModifE = target.Modifiers.Any(y => y.Name == "modifier_skywrath_mage_ancient_seal");
			var ModifRod = target.Modifiers.Any(y => y.Name == "modifier_rod_of_atos_debuff");
			var ModifEther = target.Modifiers.Any(y => y.Name == "modifier_item_ethereal_blade_slow");
			var ModifVail = target.Modifiers.Any(y => y.Name == "modifier_item_veil_of_discord_debuff");
			var stoneModif = target.Modifiers.Any(y => y.Name == "modifier_medusa_stone_gaze_stone");

			if (Game.IsKeyDown(keyCode: 70) && Q.CanBeCasted() && target != null)
			{
				if (
					Q != null
					&& Q.CanBeCasted()
					&& (target.IsLinkensProtected()
					|| !target.IsLinkensProtected())
					&& me.CanCast()
					&& me.Distance2D(target) < 900
					&& !stoneModif
					&& Utils.SleepCheck("Q")
					)
				{
					Q.UseAbility(target);
					Utils.Sleep(200, "Q");
				}
			}
			if (Game.IsKeyDown(Menu.Item("Combo Key").GetValue<KeyBind>().Key) && me.IsAlive && target.IsAlive && Utils.SleepCheck("activated"))
			{
				var noBlade = target.Modifiers.Any(y => y.Name == "modifier_item_blade_mail_reflect");
				if (target.IsVisible && me.Distance2D(target) <= 2300 && !noBlade)
				{
					if (
									  Q != null
									  && Q.CanBeCasted()
									  && (target.IsLinkensProtected()
									  || !target.IsLinkensProtected())
									  && me.CanCast()
									  && me.Distance2D(target) < 1400
									  && !stoneModif
									  && Menu.Item("Skills: ").GetValue<AbilityToggler>().IsEnabled(Q.Name)
									  && Utils.SleepCheck("Q")
						)
					{
						Q.UseAbility(target);
						Utils.Sleep(200, "Q");
					}
					if ( // atos Blade
                        atos != null
						&& atos.CanBeCasted() 
						&& me.CanCast()
                        && !target.IsLinkensProtected()
						&& !target.IsMagicImmune()
						&& Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(atos.Name)
						&& me.Distance2D(target) <= 2000
						&& Utils.SleepCheck("atos")
						)
					{
						atos.UseAbility(target);

						Utils.Sleep(250 + Game.Ping, "atos");
					} // atos Item end
					if (
						W != null
						&& target.IsVisible
						&& W.CanBeCasted()
						&& me.CanCast()
						&& me.Distance2D(target) < 900
                        && Menu.Item("Skills: ").GetValue<AbilityToggler>().IsEnabled(W.Name)
                        && Utils.SleepCheck("W"))
					{
						W.UseAbility();
						Utils.Sleep(300, "W");
					}
					if (
                                  blink != null
								  && Q.CanBeCasted()
								  && me.CanCast()
								  && blink.CanBeCasted()
								  && me.Distance2D(target) > 1000
								  && !stoneModif
								  && Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(blink.Name)
								  && Utils.SleepCheck("blink")
						)
					{
						blink.UseAbility(target.Position);

						Utils.Sleep(250, "blink");
					}
					if (
						   E != null
						   && E.CanBeCasted()
						   && me.CanCast() 
                           && !target.IsLinkensProtected()
						   && me.Position.Distance2D(target) < 1400
						   && !stoneModif
						   && Utils.SleepCheck("E"))
					{
						E.UseAbility(target);
						Utils.Sleep(200, "E");
					}
					if(!E.CanBeCasted() || E == null)
					{
						if ( // orchid
								  orchid != null
								  && orchid.CanBeCasted()
								  && me.CanCast()
								  && !target.IsLinkensProtected()
								  && !target.IsMagicImmune()
								  && me.Distance2D(target) <= 1400
								  && Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(orchid.Name)
								  && !stoneModif
								  && Utils.SleepCheck("orchid")
							)
						{
							orchid.UseAbility(target);
							Utils.Sleep(250, "orchid");
						} // orchid Item end
						if (!orchid.CanBeCasted() || orchid == null || !Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(orchid.Name))
						{
							if ( // vail
                                   vail != null
								  && vail.CanBeCasted()
								  && me.CanCast() 
                                  && !target.IsMagicImmune()
								  && Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(vail.Name)
								  && me.Distance2D(target) <= 1500
								  && Utils.SleepCheck("vail")
								  )
							{
								vail.UseAbility(target.Position);
								Utils.Sleep(250, "vail");
							} // orchid Item end
							if (!vail.CanBeCasted() || vail == null || !Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(vail.Name))
							{
								if (// ethereal
									   ethereal != null
									   && ethereal.CanBeCasted()
									   && me.CanCast()
									   && !target.IsLinkensProtected()
									   && !target.IsMagicImmune()
									   && !stoneModif
									   && Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(ethereal.Name)
									   && Utils.SleepCheck("ethereal")
									  )
								{
									ethereal.UseAbility(target);
									Utils.Sleep(200, "ethereal");
								} // ethereal Item end
								if (!ethereal.CanBeCasted() || ethereal == null || !Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(ethereal.Name))
								{
									if (
										 Q != null
										&& Q.CanBeCasted()
										&& me.CanCast()
										&& me.Distance2D(target) < 1400
										&& !stoneModif
										 && Menu.Item("Skills: ").GetValue<AbilityToggler>().IsEnabled(Q.Name)
										&& Utils.SleepCheck("Q")
										)
									{
										Q.UseAbility(target);
										Utils.Sleep(200, "Q");
									}


									if (
									   R != null
									   && R.CanBeCasted()
									   && me.CanCast()
									   && !ModifR
									   && (ModifW
									   || ModifEther
									   || ModifRod)
									   && me.Position.Distance2D(target) < 1200
									   && target.Health >= (target.MaximumHealth * Menu.Item("Healh").GetValue<Slider>().Value)
									   && !stoneModif
									   && Menu.Item("Skills: ").GetValue<AbilityToggler>().IsEnabled(R.Name)
									   && Utils.SleepCheck("R"))
									{
										R.UseAbility(target.Predict(500));
										Utils.Sleep(330, "R");
									}

									if (// SoulRing Item 
										soulring != null
										&& soulring.CanBeCasted()
										&& me.CanCast()
										&& me.Health / me.MaximumHealth <= 0.5
										&& me.Mana <= R.ManaCost
										&& Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(soulring.Name)
										)
									{
										soulring.UseAbility();
									} // SoulRing Item end

									if (// Arcane Boots Item
										arcane != null
										&& arcane.CanBeCasted()
										&& me.CanCast()
										&& me.Mana <= R.ManaCost
										&& Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(arcane.Name)
										)
									{
										arcane.UseAbility();
									} // Arcane Boots Item end

									if (//Ghost
										ghost != null
										&& ghost.CanBeCasted()
										&& me.CanCast()
										&& ((me.Position.Distance2D(target) < 300
										&& me.Health <= (me.MaximumHealth * 0.7))
										|| me.Health <= (me.MaximumHealth * 0.3))
										&& Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(ghost.Name)
										&& Utils.SleepCheck("Ghost"))
									{
										ghost.UseAbility();
										Utils.Sleep(250, "Ghost");
									}


									if (// Shiva Item
										shiva != null
										&& shiva.CanBeCasted()
										&& me.CanCast()
										&& !target.IsMagicImmune()
										&& Utils.SleepCheck("shiva")
										&& Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(shiva.Name)
										&& me.Distance2D(target) <= 600
										)

									{
										shiva.UseAbility();
										Utils.Sleep(250, "shiva");
									} // Shiva Item end





									if ( // sheep
										sheep != null
										&& sheep.CanBeCasted()
										&& me.CanCast()
										&& !target.IsLinkensProtected()
										&& !target.IsMagicImmune()
										&& me.Distance2D(target) <= 1400
										&& !stoneModif
										&& Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(sheep.Name)
										&& Utils.SleepCheck("sheep")
										)
									{
										sheep.UseAbility(target);
										Utils.Sleep(250, "sheep");
									} // sheep Item end

									if (// Dagon
										me.CanCast()
										&& dagon != null
										&& (ethereal == null
										|| (ModifEther
										|| ethereal.Cooldown < 17))
										&& !target.IsLinkensProtected()
										&& dagon.CanBeCasted()
										&& !target.IsMagicImmune()
										&& !stoneModif
										&& Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(dagon.Name)
										&& Utils.SleepCheck("dagon")
									   )
									{
										dagon.UseAbility(target);
										Utils.Sleep(200, "dagon");
									} // Dagon Item end

									if (
										 // cheese
										 cheese != null
										 && cheese.CanBeCasted()
										 && me.Health <= (me.MaximumHealth * 0.3)
										 && me.Distance2D(target) <= 700
										 && Menu.Item("Items: ").GetValue<AbilityToggler>().IsEnabled(cheese.Name)
										 && Utils.SleepCheck("cheese")
									 )
                                {
									cheese.UseAbility();
									Utils.Sleep(200, "cheese");
								} // cheese Item end

								}
							}
						}
					}
				}
				Utils.Sleep(200, "activated");
			}
		}
Пример #19
0
		public static void A(EventArgs args)
		{
			var me = ObjectMgr.LocalHero;

			if (!Game.IsInGame || me.ClassID != ClassID.CDOTA_Unit_Hero_Skywrath_Mage || me == null)
			{
				return;
			}


			var enemies =ObjectMgr.GetEntities<Hero>().Where(x => x.IsVisible && x.IsAlive && x.Team == me.GetEnemyTeam() && !x.IsIllusion);
			if (Menu.Item("autoUlt").GetValue<bool>())
			{
				 core = me.FindItem("item_octarine_core");
				 force = me.FindItem("item_force_staff");
				 cyclone = me.FindItem("item_cyclone");
				 orchid = me.FindItem("item_orchid");
				 atos = me.FindItem("item_rod_of_atos");
				
				foreach (var e in enemies)
				{
					if (e == null)
						return;
					bool reflect = e.Modifiers.Any(y => y.Name == "modifier_item_blade_mail_reflect");
					{

						if (cyclone != null && reflect && cyclone.CanBeCasted() && me.Distance2D(e) < cyclone.CastRange && Utils.SleepCheck(e.Handle.ToString()))
						{
							cyclone.UseAbility(me);
							Utils.Sleep(500, e.Handle.ToString());
						}
						if ((Game.IsKeyDown(Menu.Item("Combo Key").GetValue<KeyBind>().Key) && e.MovementSpeed <= 200 && e.Modifiers.Any(y => y.Name == "modifier_skywrath_mage_ancient_seal") || ((E.Cooldown <= 14 && core == null) || E.Cooldown <= 10 && core != null || e.Modifiers.Any(y => y.Name == "modifier_item_ethereal_blade_slow"))))
						{
							if (R != null && e != null && R.CanBeCasted() && me.Distance2D(e) <= 1200
								&& e.MovementSpeed <= 200
								&& !e.Modifiers.Any(y => y.Name == "modifier_item_blade_mail_reflect")
								&& !e.Modifiers.Any(y => y.Name == "modifier_sniper_headshot")
								&& !e.Modifiers.Any(y => y.Name == "modifier_leshrac_lightning_storm_slow")
								&& !e.Modifiers.Any(y => y.Name == "modifier_razor_unstablecurrent_slow")
								&& !e.Modifiers.Any(y => y.Name == "modifier_pudge_meat_hook")
								&& !e.Modifiers.Any(y => y.Name == "modifier_tusk_snowball_movement")
								&& !e.Modifiers.Any(y => y.Name == "modifier_obsidian_destroyer_astral_imprisonment_prison")
								&& !e.Modifiers.Any(y => y.Name == "modifier_puck_phase_shift")
								&& !e.Modifiers.Any(y => y.Name == "modifier_eul_cyclone")
								&& !e.Modifiers.Any(y => y.Name == "modifier_dazzle_shallow_grave")
								&& !e.Modifiers.Any(y => y.Name == "modifier_brewmaster_storm_cyclone")
								&& !e.Modifiers.Any(y => y.Name == "modifier_spirit_breaker_charge_of_darkness")
								&& !e.Modifiers.Any(y => y.Name == "modifier_shadow_demon_disruption")
								&& (!e.FindSpell("abaddon_borrowed_time").CanBeCasted() && !e.Modifiers.Any(y => y.Name == "modifier_abaddon_borrowed_time_damage_redirect"))
								&& e.Health >= (e.MaximumHealth / 100 * (Menu.Item("Healh").GetValue<Slider>().Value))
								&& !e.IsMagicImmune()
								&& Menu.Item("AutoUlt: ").GetValue<AbilityToggler>().IsEnabled(R.Name)
								&& Utils.SleepCheck(e.Handle.ToString()))
							{
								R.UseAbility(e.Predict(500));
								Utils.Sleep(300, e.Handle.ToString());
							}
							if (R != null && e != null && R.CanBeCasted() && me.Distance2D(e) <= 1200
							   &&
							   (
								  e.Modifiers.Any(y => y.Name == "modifier_meepo_earthbind")
							   || e.Modifiers.Any(y => y.Name == "modifier_pudge_dismember")
							   || e.Modifiers.Any(y => y.Name == "modifier_naga_siren_ensnare")
							   || e.Modifiers.Any(y => y.Name == "modifier_lone_druid_spirit_bear_entangle_effect")
							   || (e.Modifiers.Any(y => y.Name == "modifier_legion_commander_duel") && !e.AghanimState())
							   || e.Modifiers.Any(y => y.Name == "modifier_kunkka_torrent")
							   || e.Modifiers.Any(y => y.Name == "modifier_ice_blast")
							   || e.Modifiers.Any(y => y.Name == "modifier_enigma_black_hole_pull")
							   || e.Modifiers.Any(y => y.Name == "modifier_ember_spirit_searing_chains")
							   || e.Modifiers.Any(y => y.Name == "modifier_dark_troll_warlord_ensnare")
							   || e.Modifiers.Any(y => y.Name == "modifier_crystal_maiden_frostbite")
							   || e.ClassID == ClassID.CDOTA_Unit_Hero_Rattletrap && e.FindSpell("rattletrap_power_cogs").IsInAbilityPhase
							   || e.Modifiers.Any(y => y.Name == "modifier_axe_berserkers_call")
							   || e.Modifiers.Any(y => y.Name == "modifier_bane_fiends_grip")
							   || e.Modifiers.Any(y => y.Name == "modifier_faceless_void_chronosphere_freeze") && e.ClassID != ClassID.CDOTA_Unit_Hero_FacelessVoid
							   || e.Modifiers.Any(y => y.Name == "modifier_storm_spirit_electric_vortex_pull")
							   || (e.ClassID == ClassID.CDOTA_Unit_Hero_WitchDoctor && e.FindSpell("witch_doctor_death_ward").IsInAbilityPhase)
							   || (e.ClassID == ClassID.CDOTA_Unit_Hero_CrystalMaiden && e.FindSpell("crystal_maiden_crystal_nova").IsInAbilityPhase)
							   || e.IsStunned()
							   )
							   && (!e.Modifiers.Any(y => y.Name == "modifier_medusa_stone_gaze_stone")
							   && !e.Modifiers.Any(y => y.Name == "modifier_item_monkey_king_bar")
							   && !e.FindSpell("abaddon_borrowed_time").CanBeCasted() && !e.Modifiers.Any(y => y.Name == "modifier_abaddon_borrowed_time_damage_redirect")
							   && !e.Modifiers.Any(y => y.Name == "modifier_rattletrap_battery_assault")
							   && !e.Modifiers.Any(y => y.Name == "modifier_item_blade_mail_reflect")
							   && !e.Modifiers.Any(y => y.Name == "modifier_skywrath_mystic_flare_aura_effect")
							   && !e.Modifiers.Any(y => y.Name == "modifier_pudge_meat_hook")
							   && !e.Modifiers.Any(y => y.Name == "modifier_obsidian_destroyer_astral_imprisonment_prison")
							   && !e.Modifiers.Any(y => y.Name == "modifier_puck_phase_shift")
							   && !e.Modifiers.Any(y => y.Name == "modifier_eul_cyclone")
							   && !e.Modifiers.Any(y => y.Name == "modifier_dazzle_shallow_grave")
							   && !e.Modifiers.Any(y => y.Name == "modifier_brewmaster_storm_cyclone")
							   && !e.Modifiers.Any(y => y.Name == "modifier_spirit_breaker_charge_of_darkness")
							   && !e.Modifiers.Any(y => y.Name == "modifier_shadow_demon_disruption")
							   && !e.Modifiers.Any(y => y.Name == "modifier_tusk_snowball_movement")
							   && (!e.FindSpell("abaddon_borrowed_time").CanBeCasted() && !e.Modifiers.Any(y => y.Name == "modifier_abaddon_borrowed_time_damage_redirect"))
							   && e.Health >= (e.MaximumHealth / 100 * (Menu.Item("Healh").GetValue<Slider>().Value))
							   && !e.IsMagicImmune())
							   && Menu.Item("AutoUlt: ").GetValue<AbilityToggler>().IsEnabled(R.Name)
							   && Utils.SleepCheck(e.Handle.ToString()))
							{
								R.UseAbility(e.Predict(500));
								Utils.Sleep(300, e.Handle.ToString());
							}
							if (R != null && e != null && R.CanBeCasted() && me.Distance2D(e) <= 1200
							   && e.MovementSpeed <= 200
							   && e.MagicDamageResist <= 0.07
							   && e.Health >= (e.MaximumHealth/100 * (Menu.Item("Healh").GetValue<Slider>().Value))
							   && !e.Modifiers.Any(y => y.Name == "modifier_item_blade_mail_reflect")
							   && !e.Modifiers.Any(y => y.Name == "modifier_skywrath_mystic_flare_aura_effect")
							   && !e.Modifiers.Any(y => y.Name == "modifier_obsidian_destroyer_astral_imprisonment_prison")
							   && !e.Modifiers.Any(y => y.Name == "modifier_puck_phase_shift")
							   && !e.Modifiers.Any(y => y.Name == "modifier_eul_cyclone")
							   && !e.Modifiers.Any(y => y.Name == "modifier_dazzle_shallow_grave")
							   && !e.Modifiers.Any(y => y.Name == "modifier_brewmaster_storm_cyclone")
							   && !e.Modifiers.Any(y => y.Name == "modifier_spirit_breaker_charge_of_darkness")
							   && !e.Modifiers.Any(y => y.Name == "modifier_shadow_demon_disruption")
							   && !e.Modifiers.Any(y => y.Name == "modifier_tusk_snowball_movement")
							   && !e.IsMagicImmune()
							   && (!e.FindSpell("abaddon_borrowed_time").CanBeCasted() && !e.Modifiers.Any(y => y.Name == "modifier_abaddon_borrowed_time_damage_redirect"))
							   && Menu.Item("AutoUlt: ").GetValue<AbilityToggler>().IsEnabled(R.Name)
							   && Utils.SleepCheck(e.Handle.ToString()))
							{
								R.UseAbility(e.Predict(500));
								Utils.Sleep(500, e.Handle.ToString()); goto leave;
							}
						}
						if (E != null && e != null && E.CanBeCasted() && me.Distance2D(e) <= 730
							&& !e.IsLinkensProtected()
						&&
						(
						   e.Modifiers.Any(y => y.Name == "modifier_meepo_earthbind")
						|| e.Modifiers.Any(y => y.Name == "modifier_pudge_dismember")
						|| e.Modifiers.Any(y => y.Name == "modifier_naga_siren_ensnare")
						|| e.Modifiers.Any(y => y.Name == "modifier_lone_druid_spirit_bear_entangle_effect")
						|| e.Modifiers.Any(y => y.Name == "modifier_legion_commander_duel")
						|| e.Modifiers.Any(y => y.Name == "modifier_kunkka_torrent")
						|| e.Modifiers.Any(y => y.Name == "modifier_ice_blast")
						|| e.Modifiers.Any(y => y.Name == "modifier_enigma_black_hole_pull")
						|| e.Modifiers.Any(y => y.Name == "modifier_ember_spirit_searing_chains")
						|| e.Modifiers.Any(y => y.Name == "modifier_dark_troll_warlord_ensnare")
						|| e.Modifiers.Any(y => y.Name == "modifier_crystal_maiden_frostbite")
						|| e.Modifiers.Any(y => y.Name == "modifier_axe_berserkers_call")
						|| e.Modifiers.Any(y => y.Name == "modifier_bane_fiends_grip")
						|| e.ClassID == ClassID.CDOTA_Unit_Hero_Magnataur && e.FindSpell("magnataur_reverse_polarity").IsInAbilityPhase
						|| e.FindItem("item_blink").IsInAbilityPhase
						|| e.ClassID == ClassID.CDOTA_Unit_Hero_QueenOfPain && e.FindSpell("queenofpain_blink").IsInAbilityPhase
						|| e.ClassID == ClassID.CDOTA_Unit_Hero_AntiMage && e.FindSpell("antimage_blink").IsInAbilityPhase
						|| e.ClassID == ClassID.CDOTA_Unit_Hero_AntiMage && e.FindSpell("antimage_mana_void").IsInAbilityPhase
						|| e.ClassID == ClassID.CDOTA_Unit_Hero_DoomBringer && e.FindSpell("doom_bringer_doom").IsInAbilityPhase
						|| e.Modifiers.Any(y => y.Name == "modifier_rubick_telekinesis")
						|| e.Modifiers.Any(y => y.Name == "modifier_storm_spirit_electric_vortex_pull")
						|| e.Modifiers.Any(y => y.Name == "modifier_winter_wyvern_cold_embrace")
						|| e.Modifiers.Any(y => y.Name == "modifier_winter_wyvern_winters_curse")
						|| e.Modifiers.Any(y => y.Name == "modifier_shadow_shaman_shackles")
						|| e.Modifiers.Any(y => y.Name == "modifier_faceless_void_chronosphere_freeze") && e.ClassID != ClassID.CDOTA_Unit_Hero_FacelessVoid
						|| e.ClassID == ClassID.CDOTA_Unit_Hero_WitchDoctor && e.FindSpell("witch_doctor_death_ward").IsInAbilityPhase
						|| e.ClassID == ClassID.CDOTA_Unit_Hero_Rattletrap && e.FindSpell("rattletrap_power_cogs").IsInAbilityPhase
						|| e.ClassID == ClassID.CDOTA_Unit_Hero_Tidehunter && e.FindSpell("tidehunter_ravage").IsInAbilityPhase
						|| e.IsStunned()
						&& !e.IsMagicImmune()
						)
						&& !e.Modifiers.Any(y => y.Name == "modifier_medusa_stone_gaze_stone")
						&& Utils.SleepCheck(e.Handle.ToString()))
						{
							E.UseAbility(e);
							Utils.Sleep(250, e.Handle.ToString()); goto leave;
						}
						 if (W != null && e != null && W.CanBeCasted() && me.Distance2D(e) <= 1400
							&& e.MovementSpeed <= 255
							&& !e.IsMagicImmune()
							&& Utils.SleepCheck(e.Handle.ToString()))
						{
							W.UseAbility();
							Utils.Sleep(500, e.Handle.ToString()); goto leave;
						}
						 if (atos != null && e != null && R != null && R.CanBeCasted() && atos.CanBeCasted()
							&& !e.IsLinkensProtected()
							&& me.Distance2D(e) <= 1200
							&& e.MagicDamageResist <= 0.07
							&& !e.IsMagicImmune()
							&& Utils.SleepCheck(e.Handle.ToString()))
						{
							atos.UseAbility(e);
							Utils.Sleep(500, e.Handle.ToString()); goto leave;
						}
						 if (vail != null && e.Modifiers.Any(y => y.Name == "modifier_skywrath_mystic_flare_aura_effect")
						   && vail.CanBeCasted() 
						   && me.Distance2D(e) <= 1200
						   && Utils.SleepCheck(e.Handle.ToString())
						  )
						{
							vail.UseAbility(e.Position);
							Utils.Sleep(500, e.Handle.ToString()); goto leave;
						}
						 if (E != null && e.Modifiers.Any(y => y.Name == "modifier_skywrath_mystic_flare_aura_effect")
							&& E.CanBeCasted()
							&& me.Distance2D(e) <= 900
							&& Utils.SleepCheck(e.Handle.ToString())
							)
						{
							E.UseAbility(e);
							Utils.Sleep(500, e.Handle.ToString()); goto leave;
						}
						 if (ethereal != null && e.Modifiers.Any(y => y.Name == "modifier_skywrath_mystic_flare_aura_effect")
							&& !e.Modifiers.Any(y => y.Name == "modifier_legion_commander_duel")
							&& ethereal.CanBeCasted()
							&& E.CanBeCasted()
							&& me.Distance2D(e) <= 1000
							&& Utils.SleepCheck(e.Handle.ToString())
							)
						{
							ethereal.UseAbility(e);
							Utils.Sleep(500, e.Handle.ToString()); goto leave;
						}
					}
					if(e.IsLinkensProtected() && (me.IsVisibleToEnemies || Game.IsKeyDown(Menu.Item("Combo Key").GetValue<KeyBind>().Key)))
					{
						if(force !=null && force.CanBeCasted() && me.Distance2D(e) < force.CastRange && Menu.Item("Link: ").GetValue<AbilityToggler>().IsEnabled(force.Name) && Utils.SleepCheck(e.Handle.ToString()))
						{
							force.UseAbility(e);
							Utils.Sleep(500, e.Handle.ToString());
						}
						else if (cyclone != null && cyclone.CanBeCasted() && me.Distance2D(e) < cyclone.CastRange && Menu.Item("Link: ").GetValue<AbilityToggler>().IsEnabled(cyclone.Name) && Utils.SleepCheck(e.Handle.ToString()))
						{
							cyclone.UseAbility(e);
							Utils.Sleep(500, e.Handle.ToString());
						}
						else if (orchid != null && orchid.CanBeCasted() && me.Distance2D(e) < orchid.CastRange && Menu.Item("Link: ").GetValue<AbilityToggler>().IsEnabled(orchid.Name) && Utils.SleepCheck(e.Handle.ToString()))
						{
							orchid.UseAbility(e);
							Utils.Sleep(500, e.Handle.ToString());
						}
						else if (atos != null && atos.CanBeCasted() && me.Distance2D(e) < atos.CastRange-400 && Menu.Item("Link: ").GetValue<AbilityToggler>().IsEnabled(atos.Name) && Utils.SleepCheck(e.Handle.ToString()))
						{
							atos.UseAbility(e);
							Utils.Sleep(500, e.Handle.ToString());
						}
						else if (dagon != null && dagon.CanBeCasted() && me.Distance2D(e) < dagon.CastRange && Menu.Item("Link: ").GetValue<AbilityToggler>().IsEnabled(dagon.Name) && Utils.SleepCheck(e.Handle.ToString()))
						{
							dagon.UseAbility(e);
							Utils.Sleep(500, e.Handle.ToString());
						}
					}
				}
				leave:;
			}
		}
Пример #20
0
        private static void Game_OnUpdate(EventArgs args)
        {
            if (!loaded)
            {
                me = ObjectMgr.LocalHero;
                if (!Game.IsInGame || Game.IsWatchingGame || me == null || me.ClassID != ClassID.CDOTA_Unit_Hero_Huskar)
                {
                    return;
                }
                loaded = true;

                // Spells
                spellQ = me.Spellbook.SpellQ;
                spellR = me.Spellbook.SpellR;


                //Aghs = me.FindItem("item_ultimate_scepter");
            }

            if (me == null || !me.IsValid)
            {
                loaded = false;
                me = ObjectMgr.LocalHero;
                if (rangeDisplay == null)
                {
                    return;
                }
                rangeDisplay = null;
                return;
            }

            if (Game.IsPaused)
            {
                return;
            }

            // Items
            Urn = me.FindItem("item_urn_of_shadows");

            Abyssal = me.FindItem("item_abyssal_blade");

            Blademail = me.FindItem("item_blade_mail");

            Mjollnir = me.FindItem("item_mjollnir");

            Orchid = me.FindItem("item_orchid");

            Halberd = me.FindItem("item_heavens_halberd");

            Satanic = me.FindItem("item_satanic");

            Hex = me.FindItem("item_sheepstick");

            Medallion = me.FindItem("item_medallion_of_courage");

            SolarCrest = me.FindItem("item_solar_crest");

            Blink = me.FindItem("item_blink");

            Armlet = me.FindItem("item_armlet");


            if (rangeDisplay == null)
            {
                rangeDisplay = me.AddParticleEffect(@"particles\ui_mouseactions\range_display.vpcf");
                lastRange = me.GetAttackRange() + me.HullRadius + 25;
                rangeDisplay.SetControlPoint(1, new Vector3(lastRange, 0, 0));
            }
            else
            {
                if (lastRange != (me.GetAttackRange() + me.HullRadius + 25))
                {
                    lastRange = me.GetAttackRange() + me.HullRadius + 25;
                    rangeDisplay.Dispose();
                    rangeDisplay = me.AddParticleEffect(@"particles\ui_mouseactions\range_display.vpcf");
                    rangeDisplay.SetControlPoint(1, new Vector3(lastRange, 0, 0));
                }
            }

            if (target != null && (!target.IsValid || !target.IsVisible || !target.IsAlive || target.Health <= 0))
            {
                target = null;
            }
            var canCancel = Orbwalking.CanCancelAnimation();
            if (canCancel)
            {
                if (target != null && !target.IsVisible && !Orbwalking.AttackOnCooldown(target))
                {
                    target = me.ClosestToMouseTarget();
                }
                else if (target == null || !Orbwalking.AttackOnCooldown(target))
                {
                    var bestAa = me.BestAATarget();
                    if (bestAa != null)
                    {
                        target = me.BestAATarget();
                    }
                }
            }

            if (Game.IsChatOpen)
            {
                return;
            }

            /*if (Game.IsKeyDown(ComboKey))
            {*/
                if (Armlet != null && me.CanUseItems())
                {
                    var enemiesInRange =
                        ObjectMgr.GetEntities<Hero>()
                            .Where(x => me.Distance2D(x) <= lastRange && x.IsAlive && x.Team != me.Team).ToList();
                    var projectiles =
                        ObjectMgr.Projectiles.Where(
                            x =>
                                x.Target != null && x.Target == me && (me.Distance2D(x.Position)/x.Speed)*1000 < 600/2.5)
                            .ToList();

                    if (me.Health > 250 && enemiesInRange.Count > 0)
                    {
                        if (!me.IsStunned() && me.IsAlive && !Armlet.IsToggled &&
                            !me.Modifiers.Any(x => x.Name == "modifier_item_armlet_unholy_strength") &&
                            Utils.SleepCheck("Armlet"))
                        {
//                            Console.WriteLine("Activating Armlet!");
                            Armlet.ToggleAbility();
                            Utils.Sleep(100 + Game.Ping, "Armlet");
                        }
                    }
                    else if (me.Health > 250 && enemiesInRange.Count < 1 && !me.IsStunned() && Armlet.IsToggled &&
                             Utils.SleepCheck("Armlet") &&
                             me.Modifiers.Any(x => x.Name == "modifier_item_armlet_unholy_strength"))
                    {
//                        Console.WriteLine("Deactivating Armlet!");
                        Armlet.ToggleAbility();
                        Utils.Sleep(100 + Game.Ping, "Armlet");
                    }
                    else if (me.Health < 250 && projectiles.Any() && Armlet.IsToggled && !me.IsStunned() &&
                             Utils.SleepCheck("Armlet"))
                    {
//                        Console.WriteLine("Toggling armlet!");
                        Armlet.ToggleAbility();
                        Armlet.ToggleAbility();
                        Utils.Sleep(100 + Game.Ping, "Armlet");
                    }
                }

                if (target != null)
                {
                    turnTime = me.GetTurnTime(target);

                    if (Blink != null && Blink.CanBeCasted() && me.Distance2D(target) <= Blink.CastRange &&
                        Utils.SleepCheck("Blink") &&
                        target != null)
                    {
                        Blink.UseAbility(target.Position);
                        Utils.Sleep(turnTime*1000 + 100 + Game.Ping, "Blink");
                    }

                    /*if (spellR.CanBeCasted(target) && me.Distance2D(target) <= spellR.CastRange && Utils.SleepCheck("R") &&
                        target != null && target.Health > (target.MaximumHealth*0.8) && !target.IsMagicImmune())
                    {
                        spellR.UseAbility(target);
                        Utils.Sleep(LifebreakCastTime + Game.Ping, "R");
                    }*/

                    if (Abyssal != null && Abyssal.CanBeCasted(target) && me.Distance2D(target) <= Abyssal.CastRange &&
                        Utils.SleepCheck("abyssal") && target != null)
                    {
                        var canUse = Utils.ChainStun(target, turnTime + 0.1 + Game.Ping/1000, null, false);
                        if (canUse)
                        {
                            Abyssal.UseAbility(target);
                            Utils.Sleep(turnTime*1000 + 100 + Game.Ping, "abyssal");
                        }
                    }

                    if (Hex != null && Hex.CanBeCasted(target) && me.Distance2D(target) <= (Hex.CastRange) &&
                        Utils.SleepCheck("hex") &&
                        target != null)
                    {
                        var canUse = Utils.ChainStun(target, turnTime + 0.1 + Game.Ping/1000, null, false);
                        if (canUse)
                        {
                            Hex.UseAbility(target);
                            Utils.Sleep(turnTime*1000 + 100 + Game.Ping, "hex");
                        }
                    }

                    if (Urn != null && Urn.CanBeCasted(target) && me.Distance2D(target) <= Urn.CastRange &&
                        Urn.CurrentCharges >= 1 &&
                        Utils.SleepCheck("Urn") && target != null &&
                        target.Modifiers.All(x => x.Name != "modifier_item_urn_heal"))
                    {
                        Urn.UseAbility(target);
                        Utils.Sleep(turnTime*1000 + 100 + Game.Ping, "Urn");
                    }

                    if (Medallion != null && Medallion.CanBeCasted(target) &&
                        me.Distance2D(target) <= Medallion.CastRange &&
                        Utils.SleepCheck("Medallion") && target != null)
                    {
                        Medallion.UseAbility(target);
                        Utils.Sleep(turnTime*1000 + 100 + Game.Ping, "Medallion");
                    }

                    if (SolarCrest != null && SolarCrest.CanBeCasted(target) &&
                        me.Distance2D(target) <= SolarCrest.CastRange &&
                        Utils.SleepCheck("SolarCrest") && target != null)
                    {
                        SolarCrest.UseAbility(target);
                        Utils.Sleep(turnTime*1000 + 100 + Game.Ping, "SolarCrest");
                    }

                    if (Blademail != null && Blademail.CanBeCasted() && me.Distance2D(target) < target.AttackRange &&
                        Utils.SleepCheck("Blademail") && target != null)
                    {
                        Blademail.UseAbility();
                        Utils.Sleep(turnTime*1000 + 100 + Game.Ping, "Blademail");
                    }

                    if (Mjollnir != null && Mjollnir.CanBeCasted(me) && target.IsValid &&
                        me.Distance2D(target) <= spellR.CastRange &&
                        Utils.SleepCheck("Mjollnir") && target != null)
                    {
                        Mjollnir.UseAbility(me);
                        Utils.Sleep(turnTime*1000 + 100 + Game.Ping, "Mjollnir");
                    }

                    if (Orchid != null && Orchid.CanBeCasted(target) && me.Distance2D(target) <= Orchid.CastRange &&
                        Utils.SleepCheck("Orchid") && target != null)
                    {
                        Orchid.UseAbility(target);
                        Utils.Sleep(turnTime*1000 + 100 + Game.Ping, "Orchid");
                    }

                    if (Halberd != null && Halberd.CanBeCasted(target) && me.Distance2D(target) <= Halberd.CastRange &&
                        (!target.IsHexed() && !target.IsStunned() && !target.IsDisarmed()) &&
                        Utils.SleepCheck("Halberd") && target != null)
                    {
                        Halberd.UseAbility(target);
                        Utils.Sleep(turnTime*1000 + 100 + Game.Ping, "Halberd");
                    }

                    if (Satanic != null && Satanic.CanBeCasted() && me.Health <= (me.MaximumHealth*0.3) &&
                        me.Distance2D(target) <= lastRange)
                    {
                        Satanic.UseAbility();
                    }

                    if (spellQ.CanBeCasted() && me.Health <= (me.MaximumHealth*0.4) && Utils.SleepCheck("Q"))
                    {
                        spellQ.UseAbility(me);
                        Utils.Sleep(InnervitalityCastTime + Game.Ping, "Q");
                    } 
                }
                /*if (target != null && target.IsMagicImmune())
                {
                    Orbwalking.Orbwalk(target, Game.Ping);
                }*/
                /*else if (target == null || !target.IsMagicImmune())
                {
                    Orbwalking.Orbwalk(target, Game.Ping, attackmodifiers: true);
                }
            }*/
        }
        public void Combo()
        {
            if (!Menu.Item("enabled").IsActive())
                return;
            //spell
            Q = me.Spellbook.SpellQ;
            W = me.Spellbook.SpellW;
            E = me.Spellbook.SpellE;
            R = me.Spellbook.SpellR;
            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key);
            var s = ObjectManager.GetEntities<Hero>()
               .Where(x => x.IsVisible && x.IsAlive && x.Team != me.Team && !x.IsIllusion && x.Distance2D(me) <= 1500).ToList();
            if (Active)
            {
                e = Toolset.ClosestToMouse(me);
                if (e == null) return;
                if (e.IsAlive && !e.IsInvul())
                {
                    if (me.IsAlive && me.Distance2D(e) <= 1900)
                    {
                        // item
                        satanic = me.FindItem("item_satanic");
                        shiva = me.FindItem("item_shivas_guard");
                        dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));
                        arcane = me.FindItem("item_arcane_boots");
                        mom = me.FindItem("item_mask_of_madness");
                        medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");
                        ethereal = me.FindItem("item_ethereal_blade");
                        blink = me.FindItem("item_blink");
                        soulring = me.FindItem("item_soul_ring");
                        cheese = me.FindItem("item_cheese");
                        halberd = me.FindItem("item_heavens_halberd");
                        abyssal = me.FindItem("item_abyssal_blade");
                        mjollnir = me.FindItem("item_mjollnir");
                        manta = me.FindItem("item_manta");
                        mail = me.FindItem("item_blade_mail");
                        orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");
                        bkb = me.FindItem("item_black_king_bar");
                        phase = me.FindItem("item_phase_boots");
                        sheep = e.ClassID == ClassID.CDOTA_Unit_Hero_Tidehunter ? null : me.FindItem("item_sheepstick");
                        var linkens = e.IsLinkensProtected();

                        if (
                            (R.CanBeCasted()
                             || me.Health >= (me.MaximumHealth * 0.4))
                            && blink.CanBeCasted()
                            && me.Position.Distance2D(e) > 300
                            && me.Position.Distance2D(e) < 1180
                            && Utils.SleepCheck("blink"))
                        {
                            blink.UseAbility(e.Position);
                            Utils.Sleep(250, "blink");
                        }
                        if (
                            Q.CanBeCasted()
                            && ((dagon != null && !dagon.CanBeCasted())
                                || (R.CanBeCasted()
                                    && me.Health >= (me.MaximumHealth * 0.3))
                                || (!R.CanBeCasted() && me.Health <= (me.MaximumHealth * 0.3)))
                            && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                            && me.Position.Distance2D(e) < Q.GetCastRange() &&
                            Utils.SleepCheck("Q"))
                        {
                            Q.UseAbility();
                            Utils.Sleep(150, "Q");
                        }
                        if (E.CanBeCasted()
                            && !Q.CanBeCasted()
                            && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(E.Name)
                            && me.Position.Distance2D(e) < me.GetAttackRange()
                            && Utils.SleepCheck("E"))
                        {
                            E.UseAbility();
                            Utils.Sleep(150, "E");
                        }
                        if (W.CanBeCasted()
                            && !Q.CanBeCasted()
                            && (E == null || !E.CanBeCasted() || !Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(E.Name))
                            && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                            && me.Position.Distance2D(e) < me.GetAttackRange()
                            && Utils.SleepCheck("W"))
                        {
                            W.UseAbility();
                            Utils.Sleep(150, "W");
                        }
                        if ( // sheep
                            sheep != null
                            && sheep.CanBeCasted()
                            && me.CanCast()
                            && !e.IsLinkensProtected()
                            && !e.IsMagicImmune()
                            && me.Distance2D(e) <= 1400
                            && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(sheep.Name)
                            && Utils.SleepCheck("sheep")
                            )
                        {
                            sheep.UseAbility(e);
                            Utils.Sleep(250, "sheep");
                        } // sheep Item end
                        var stoneModif = e.HasModifier("modifier_medusa_stone_gaze_stone");
                        if (phase != null
                            && phase.CanBeCasted()
                            && Utils.SleepCheck("phase")
                            && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(phase.Name)
                            && !blink.CanBeCasted()
                            && me.Distance2D(e) >= me.GetAttackRange() + 20)
                        {
                            phase.UseAbility();
                            Utils.Sleep(200, "phase");
                        }
                        if ( // Dagon
                            dagon != null
                            && (e.Health <= (e.MaximumHealth * 0.4)
                                || !R.CanBeCasted())
                            && dagon.CanBeCasted()
                            && me.CanCast()
                            && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled("item_dagon")
                            && !e.IsMagicImmune() &&
                            Utils.SleepCheck("dagon"))
                        {
                            dagon.UseAbility(e);
                            Utils.Sleep(150, "dagon");
                        } // Dagon Item end
                        if ((manta != null && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(manta.Name)) &&
                            manta.CanBeCasted() && me.IsSilenced() && Utils.SleepCheck("manta"))
                        {
                            manta.UseAbility();
                            Utils.Sleep(400, "manta");
                        }
                        if ((manta != null && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(manta.Name)) &&
                            manta.CanBeCasted() && (e.Position.Distance2D(me.Position) <= me.GetAttackRange() + me.HullRadius)
                            && (E==null || !E.CanBeCasted() || !Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(E.Name))
                            && Utils.SleepCheck("manta"))
                        {
                            manta.UseAbility();
                            Utils.Sleep(150, "manta");
                        }
                        if ( // orchid
                            orchid != null
                            && orchid.CanBeCasted()
                            && me.CanCast()
                            && !e.IsLinkensProtected()
                            && !e.IsMagicImmune()
                            && me.Distance2D(e) <= me.GetAttackRange()
                            && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(orchid.Name)
                            && !stoneModif
                            && Utils.SleepCheck("orchid")
                            )
                        {
                            orchid.UseAbility(e);
                            Utils.Sleep(250, "orchid");
                        } // orchid Item end
                        if (ethereal != null
                            && ethereal.CanBeCasted()
                            && me.Distance2D(e) <= 700
                            && me.Distance2D(e) <= 400
                            && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(ethereal.Name)
                            && Utils.SleepCheck("ethereal"))
                        {
                            ethereal.UseAbility(e);
                            Utils.Sleep(100, "ethereal");
                        }
                        var q = (Q != null && Q.Cooldown <= 0 && Q.ManaCost < me.Mana);
                        var w = (W != null && W.Cooldown <= 0 && W.ManaCost < me.Mana);
                        var _e = (E != null && E.Cooldown <= 0 && E.ManaCost < me.Mana);
                        var r = (R != null && R.Cooldown <= 0 && R.ManaCost < me.Mana && R.Level <= 2);
                        var d = (dagon != null && dagon.Cooldown <= 0 && dagon.ManaCost < me.Mana);

                        if ( // SoulRing Item
                            soulring != null &&
                            me.Health >= (me.MaximumHealth * 0.3)
                            && (q || w || _e || d)
                            && soulring.CanBeCasted()
                            && Utils.SleepCheck("soulring"))
                        {
                            soulring.UseAbility();
                            Utils.Sleep(150, "soulring");
                        } // SoulRing Item end

                        if ( // Arcane Boots Item
                            arcane != null
                            && (q || w || _e || d)
                            && arcane.CanBeCasted()
                            && Utils.SleepCheck("arcane"))
                        {
                            arcane.UseAbility();
                            Utils.Sleep(150, "arcane");
                        } // Arcane Boots Item end

                        if ( // Shiva Item
                            shiva != null
                            && shiva.CanBeCasted()
                            && me.CanCast()
                            && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(shiva.Name)
                            && !e.IsMagicImmune()
                            && (shiva.CanBeCasted()
                                && Utils.SleepCheck("shiva")
                                && me.Distance2D(e) <= 600)
                            )
                        {
                            shiva.UseAbility();
                            Utils.Sleep(250, "shiva");
                        } // Shiva Item end
                        if (mail != null && mail.CanBeCasted() && (s.Count(x => x.Distance2D(me) <= 650) >=
                                                                   (Menu.Item("Heelm").GetValue<Slider>().Value)) &&
                            Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mail.Name) && Utils.SleepCheck("mail"))
                        {
                            mail.UseAbility();
                            Utils.Sleep(100, "mail");
                        }
                        if ( // Medall
                            medall != null
                            && medall.CanBeCasted()
                            && me.CanCast()
                            && !e.IsMagicImmune()
                            && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                            && Utils.SleepCheck("Medall")
                            && me.Distance2D(e) <= me.GetAttackRange() + me.HullRadius
                            )
                        {
                            medall.UseAbility(e);
                            Utils.Sleep(250, "Medall");
                        } // Medall Item end

                        if ( // MOM
                            mom != null
                            && mom.CanBeCasted()
                            && me.CanCast()
                            && Utils.SleepCheck("mom")
                            && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(mom.Name)
                            && me.Distance2D(e) <= me.GetAttackRange() + me.HullRadius
                            )
                        {
                            mom.UseAbility();
                            Utils.Sleep(250, "mom");
                        } // MOM Item end

                        if ( // Abyssal Blade
                            abyssal != null
                            && abyssal.CanBeCasted()
                            && me.CanCast()
                            && !linkens
                            && Utils.SleepCheck("abyssal")
                            && Menu.Item("Item").GetValue<AbilityToggler>().IsEnabled(abyssal.Name)
                            && me.Distance2D(e) <= 400
                            )
                        {
                            abyssal.UseAbility(e);
                            Utils.Sleep(250, "abyssal");
                        } // Abyssal Item end

                        if ( // Hellbard
                            halberd != null
                            && halberd.CanBeCasted()
                            && me.CanCast()
                            && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(halberd.Name)
                            && !e.IsMagicImmune()
                            && Utils.SleepCheck("halberd")
                            && me.Distance2D(e) <= 700
                            )
                        {
                            halberd.UseAbility(e);
                            Utils.Sleep(250, "halberd");
                        } // Hellbard Item end

                        if ( // Mjollnir
                            mjollnir != null
                            && mjollnir.CanBeCasted()
                            && me.CanCast()
                            && !e.IsMagicImmune()
                            && Utils.SleepCheck("mjollnir")
                            && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                            && me.Distance2D(e) <= 900
                            )
                        {
                            mjollnir.UseAbility(me);
                            Utils.Sleep(250, "mjollnir");
                        } // Mjollnir Item end

                        if ( // Satanic
                            satanic != null
                            && me.Health <= (me.MaximumHealth * 0.4)
                            && (!R.CanBeCasted() || me.IsSilenced()
                                || e.Health <= (e.MaximumHealth * 0.4))
                            && satanic.CanBeCasted()
                            && me.Distance2D(e) <= me.GetAttackRange() + me.HullRadius
                            && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                            && Utils.SleepCheck("Satanic")
                            )
                        {
                            satanic.UseAbility();
                            Utils.Sleep(350, "Satanic");
                        } // Satanic Item end
                        if ( // cheese
                            cheese != null
                            && cheese.CanBeCasted()
                            && me.Health <= (me.MaximumHealth * 0.3)
                            && (!R.CanBeCasted()
                                || !Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name))
                            && me.Distance2D(e) <= me.GetAttackRange() + me.HullRadius
                            && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(cheese.Name)
                            && Utils.SleepCheck("cheese")
                            )
                        {
                            cheese.UseAbility();
                            Utils.Sleep(200, "cheese");
                        } // cheese Item end
                        if (bkb != null && bkb.CanBeCasted() && (s.Count(x => x.Distance2D(me) <= 650) >=
                                                                 (Menu.Item("Heel").GetValue<Slider>().Value)) &&
                            Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(bkb.Name) && Utils.SleepCheck("bkb"))
                        {
                            bkb.UseAbility();
                            Utils.Sleep(100, "bkb");
                        }

                        if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900)
                        {
                            Orbwalking.Orbwalk(e, 0, 1600, true, true);
                        }
                    }
                    var illu = ObjectManager.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_Unit_Hero_Terrorblade && x.IsIllusion)
                                        && x.IsAlive && x.IsControllable).ToList();
                    if (illu.Count > 0)
                    {
                        foreach (var v in illu)
                        {
                            if (
                           v.Distance2D(e) <= v.GetAttackRange() + v.HullRadius + 24 && !e.IsAttackImmune()
                           && v.NetworkActivity != NetworkActivity.Attack && v.CanAttack() && Utils.SleepCheck(v.Handle.ToString())
                           )
                            {
                                v.Attack(e);
                                Utils.Sleep(270, v.Handle.ToString());
                            }
                            if (
                            (!v.CanAttack() || v.Distance2D(e) >= 0) && !v.IsAttacking()
                            && v.NetworkActivity != NetworkActivity.Attack &&
                            v.Distance2D(e) <= 1200 && Utils.SleepCheck(v.Handle.ToString())
                            )
                            {
                                v.Move(e.Predict(400));
                                Utils.Sleep(400, v.Handle.ToString());
                            }
                        }
                    }
                }
            }
            if (Menu.Item("ult").GetValue<bool>())
            {
                if (me == null || !me.IsAlive) return;
                if (R == null || !R.CanBeCasted()) return;
                var ult = ObjectManager.GetEntities<Hero>()
                    .Where(x => x.IsVisible
                    && x.IsAlive
                    && x.IsValid
                    && x.Team != me.Team
                    && !x.IsIllusion
                    && x.Distance2D(me) <= R.GetCastRange() + me.HullRadius + 24).ToList().OrderBy(x => ((double)x.MaximumHealth / x.Health)).FirstOrDefault();

                var illu = ObjectManager.GetEntities<Hero>()
                    .Where(x => x.IsVisible
                    && x.IsAlive
                    && x.IsValid
                    && x.IsIllusion
                    && x.Distance2D(me) <= R.GetCastRange() + me.HullRadius + 24).ToList().OrderBy(x => ((double)x.MaximumHealth / x.Health)).FirstOrDefault();

                var ally = ObjectManager.GetEntities<Hero>()
                    .Where(x =>
                    x.IsVisible
                    && x.IsAlive
                    && x.IsValid
                    && x.Team == me.Team
                    && !x.IsIllusion
                    && x.Distance2D(me) <= R.GetCastRange() + me.HullRadius + 24).ToList().OrderBy(x => ((double)x.MaximumHealth / x.Health)).FirstOrDefault();

                if (ult != null && Menu.Item("ultEnem").GetValue<bool>())
                {
                    var linkens = ult.IsLinkensProtected();
                    if (!linkens
                        && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                        && ult.Health > (ult.MaximumHealth / 100 * Menu.Item("heal").GetValue<Slider>().Value)
                        && me.Health < (me.MaximumHealth / 100 * Menu.Item("healme").GetValue<Slider>().Value) && Utils.SleepCheck("R"))
                    {
                        R.UseAbility(ult);
                        Utils.Sleep(500, "R");
                    }
                }
                if (ult == null || ult.Health < (ult.MaximumHealth / 100 * Menu.Item("heal").GetValue<Slider>().Value))
                {
                    if (illu != null && Menu.Item("ultIllu").GetValue<bool>())
                    {
                        if (Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                            && illu.Health > (illu.MaximumHealth / 100 * Menu.Item("heal").GetValue<Slider>().Value)
                            && me.Health < (me.MaximumHealth / 100 * Menu.Item("healme").GetValue<Slider>().Value) && Utils.SleepCheck("R"))
                        {
                            R.UseAbility(illu);
                            Utils.Sleep(500, "R");
                        }
                    }
                }
                if (ult == null || ult.Health < (ult.MaximumHealth / 100 * Menu.Item("heal").GetValue<Slider>().Value) || illu == null || illu.Health < (illu.MaximumHealth / 100 * Menu.Item("heal").GetValue<Slider>().Value))
                {
                    if (ally != null && Menu.Item("ultAlly").GetValue<bool>())
                    {
                        if (Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                            && ally.Health > (ally.MaximumHealth / 100 * Menu.Item("heal").GetValue<Slider>().Value)
                            && me.Health < (me.MaximumHealth / 100 * Menu.Item("healme").GetValue<Slider>().Value) && Utils.SleepCheck("R"))
                        {
                            R.UseAbility(ally);
                            Utils.Sleep(500, "R");
                        }
                    }
                }
            }
        }
        public void ChasingAll(EventArgs args)
        {
            e = Toolset.ClosestToMouse(me);
            if (e == null) return;
            if (Combokey  && e.IsAlive && !me.IsVisibleToEnemies)
            {

                if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900)
                {
                    Orbwalking.Orbwalk(e, 0, 1600, true, true);
                }
            }
            if (Combokey && e.IsAlive && me.IsVisibleToEnemies)
            {

                var Spiderlings = ObjectManager.GetEntities<Unit>().Where(spiderlings => spiderlings.ClassID == ClassID.CDOTA_Unit_Broodmother_Spiderling).ToList();
                var count = Spiderlings.Count();
                for (int s = 0; s < count; ++s)
                {
                    if (Spiderlings[s].Distance2D(e) <= 1500 && Utils.SleepCheck(Spiderlings[s].Handle + "Spiderlings"))
                    {
                        Spiderlings[s].Attack(e);
                        Utils.Sleep(500, Spiderlings[s].Handle + "Spiderlings");
                    }
                }
                for (int s = 0; s < count; ++s)
                {
                    if (Spiderlings[s].Distance2D(e) >= 1500 && Utils.SleepCheck(Spiderlings[s].Handle + "Spiderlings"))
                    {
                        Spiderlings[s].Move(Game.MousePosition);
                        Utils.Sleep(500, Spiderlings[s].Handle + "Spiderlings");
                    }
                }

                var linkens = e.IsLinkensProtected();
                if (e.IsAlive && !e.IsIllusion && me.Distance2D(e) <= 1000)
                {

                        Q = me.Spellbook.SpellQ;

                        W = me.Spellbook.SpellW;

                        R = me.Spellbook.SpellR;

                    // Item

                    sheep = e.ClassID == ClassID.CDOTA_Unit_Hero_Tidehunter ? null : me.FindItem("item_sheepstick");

                    cheese = me.FindItem("item_cheese");

                    orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");

                    Soul = me.FindItem("item_soul_ring");

                    shiva = me.FindItem("item_shivas_guard");

                    dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));

                    mom = me.FindItem("item_mask_of_madness");

                    abyssal = me.FindItem("item_abyssal_blade");

                    mjollnir = me.FindItem("item_mjollnir");

                    halberd = me.FindItem("item_heavens_halberd");

                    mail = me.FindItem("item_blade_mail");

                    bkb = me.FindItem("item_black_king_bar");

                    medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");

                    satanic = me.FindItem("item_satanic");

                    if ( // Q Skill
                           Q != null &&
                           Q.CanBeCasted() &&
                           me.CanCast()
                        && me.IsVisibleToEnemies &&
                           !e.IsMagicImmune()
                           && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                           && me.Distance2D(e) <= 600
                           && Utils.SleepCheck("Q")
                           )

                    {
                        Q.UseAbility(e);
                        Utils.Sleep(250, "Q");
                    } // Q Skill end

                    if (//R Skill
                        R != null &&
                        R.CanBeCasted() &&
                        me.CanCast() &&
                        me.Distance2D(e) <= 350
                        && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                        && Utils.SleepCheck("R")
                        )
                    {
                        R.UseAbility();
                        Utils.Sleep(250, "R");
                    } // R Skill end

                    if ( // orchid
                        orchid != null &&
                        orchid.CanBeCasted() &&
                        me.CanCast() &&
                        !e.IsMagicImmune() &&
                        !linkens &&
                        Utils.SleepCheck("orchid")
                        && me.IsVisibleToEnemies
                        && me.Distance2D(e) <= 1000
                        )
                    {
                        orchid.UseAbility(e);
                        Utils.Sleep(250, "orchid");
                    } // orchid Item end

                    if ( // sheep
                        sheep != null
                        && me.IsVisibleToEnemies &&
                        sheep.CanBeCasted() &&
                        me.CanCast() &&
                        !e.IsMagicImmune() &&
                        !linkens &&
                        Utils.SleepCheck("sheep") &&
                        me.Distance2D(e) <= 600
                        )
                    {
                        sheep.UseAbility(e);
                        Utils.Sleep(250, "sheep");
                    } // sheep Item end

                    if (// Soul Item
                        Soul != null
                        && Q!=null
                        && Q.CanBeCasted()
                        && me.Health >= (me.MaximumHealth * 0.6)
                        && me.Mana <= Q.ManaCost
                        && Soul.CanBeCasted())
                    {
                        Soul.UseAbility();
                    } // Soul Item end

                    if (// Shiva Item
                        shiva != null
                        && me.IsVisibleToEnemies &&
                        shiva.CanBeCasted() &&
                        me.CanCast() &&
                        !e.IsMagicImmune() &&
                        Utils.SleepCheck("shiva") &&
                        me.Distance2D(e) <= 600
                        )
                    {
                        shiva.UseAbility();
                        Utils.Sleep(250, "shiva");
                    } // Shiva Item end

                    if (// MOM
                        mom != null &&
                        mom.CanBeCasted() &&
                        me.CanCast() &&
                        Utils.SleepCheck("mom") &&
                        me.Distance2D(e) <= 700
                        )
                    {
                        mom.UseAbility();
                        Utils.Sleep(250, "mom");
                    } // MOM Item end

                    if ( // Medall
                        medall != null
                        && me.IsVisibleToEnemies &&
                        medall.CanBeCasted() &&

                        Utils.SleepCheck("Medall") &&
                        me.Distance2D(e) <= 500
                        )
                    {
                        medall.UseAbility(e);
                        Utils.Sleep(250, "Medall");
                    } // Medall Item end

                    if ( // Abyssal Blade
                        abyssal != null
                        && me.IsVisibleToEnemies &&
                        abyssal.CanBeCasted() &&
                        me.CanCast() &&
                        !e.IsMagicImmune() &&
                        Utils.SleepCheck("abyssal") &&
                        me.Distance2D(e) <= 400
                        )
                    {
                        abyssal.UseAbility(e);
                        Utils.Sleep(250, "abyssal");
                    } // Abyssal Item end

                    if ( // Hellbard
                        halberd != null
                        && me.IsVisibleToEnemies &&
                        halberd.CanBeCasted() &&
                        me.CanCast() &&
                        !e.IsMagicImmune() &&
                        Utils.SleepCheck("halberd") &&
                        me.Distance2D(e) <= 700
                        )
                    {
                        halberd.UseAbility(e);
                        Utils.Sleep(250, "halberd");
                    } // Hellbard Item end

                    if ( // Mjollnir
                        mjollnir != null
                        && me.IsVisibleToEnemies &&
                        mjollnir.CanBeCasted() &&
                        me.CanCast() &&
                        !e.IsMagicImmune() &&
                        Utils.SleepCheck("mjollnir") &&
                        me.Distance2D(e) <= 600
                       )
                    {
                        mjollnir.UseAbility(me);
                        Utils.Sleep(250, "mjollnir");
                    } // Mjollnir Item end
                    var v =
               ObjectManager.GetEntities<Hero>()
                   .Where(x => x.Team != me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion)
                   .ToList();
                    if (mail != null && mail.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                           (Menu.Item("Heelm").GetValue<Slider>().Value))
                    && Utils.SleepCheck("mail"))
                    {
                        mail.UseAbility();
                        Utils.Sleep(100, "mail");
                    }
                    if (bkb != null && bkb.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                             (Menu.Item("Heel").GetValue<Slider>().Value))
                        && Utils.SleepCheck("bkb"))
                    {
                        bkb.UseAbility();
                        Utils.Sleep(100, "bkb");
                    }
                    if (// Dagon
                        dagon != null &&
                        dagon.CanBeCasted() &&
                        me.CanCast() &&
                        !e.IsMagicImmune() &&
                        Utils.SleepCheck("dagon")
                       )
                    {
                        dagon.UseAbility(e);
                        Utils.Sleep(250, "dagon");
                    } // Dagon Item end

                    if (// Satanic
                        satanic != null
                        && me.Health <= (me.MaximumHealth * 0.3)
                        && satanic.CanBeCasted()
                        && me.Distance2D(e) <= 300
                        && Utils.SleepCheck("Satanic")
                        )
                    {
                        satanic.UseAbility();
                        Utils.Sleep(250, "Satanic");
                    } // Satanic Item end

                    if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900)
                    {
                        Orbwalking.Orbwalk(e, 0, 1600, true, true);
                    }

                    /***************************************WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW**********************************/

                    var Web =
                ObjectManager.GetEntities<Unit>().Where(unit => unit.Name == "npc_dota_broodmother_web").ToList();
                    var SpinWeb = GetClosestToWeb(Web, me);
                    if (W != null && W.CanBeCasted() && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name))
                    {
                        if ((me.Distance2D(SpinWeb) >= 900 && e.Distance2D(SpinWeb) >= 900) && me.Distance2D(e) <= 800 && Utils.SleepCheck(SpinWeb.Handle + "SpideWeb"))
                        {
                            W.UseAbility(e.Predict(1100));
                            Utils.Sleep(300, SpinWeb.Handle + "SpideWeb");
                        }
                    }
                }
                /***************************************WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW**********************************/
            }
        }
Пример #23
0
        //private int stage;
        public void Combo()
        {
            target = me.ClosestToMouseTarget(2000);

            if (!Game.IsInGame || Game.IsPaused || Game.IsWatchingGame || Game.IsChatOpen)
                return;

            if (me == null || target == null)
                return;
            // skills
                Q = me.Spellbook.SpellQ;
                W = me.Spellbook.SpellW;
                E = me.Spellbook.SpellE;
                D = me.Spellbook.SpellD;
                R = me.Spellbook.SpellR;
            // itens
            blink = me.FindItem("item_blink");
            dagon = me.Inventory.Items.FirstOrDefault(x => x.Name.Contains("item_dagon"));
            ethereal = me.FindItem("item_ethereal_blade");
            euls = me.FindItem("item_cyclone");
            Shiva = me.FindItem("item_shivas_guard");
            orchid = me.FindItem("item_orchid");
            vail = me.FindItem("item_veil_of_discord");
            forcestaff = me.FindItem("item_force_staff");
            sheep = me.FindItem("item_sheepstick");

            //Starting Combo

            var _Is_in_Advantage = (target.HasModifier("modifier_item_blade_mail_reflect") ||
                                    target.HasModifier("modifier_item_lotus_orb_active") ||
                                    target.HasModifier("modifier_nyx_assassin_spiked_carapace") ||
                                    target.HasModifier("modifier_templar_assassin_refraction_damage") ||
                                    target.HasModifier("modifier_ursa_enrage") ||
                                    target.HasModifier("modifier_abaddon_borrowed_time") ||
                                    (target.HasModifier("modifier_dazzle_shallow_grave")));
            if (Game.IsKeyDown(menu.Item("Full").GetValue<KeyBind>().Key) && Utils.SleepCheck("combo"))
            {
                if (me.CanCast() && !me.IsChanneling() && me.Distance2D(target) <= 1200 &&
                 target.IsVisible && target.IsAlive && !target.IsMagicImmune() &&
                 !_Is_in_Advantage)
                {
                    if (me.CanCast())
                    {
                        var v =
                      ObjectManager.GetEntities<Hero>()
                          .Where(x => x.Team != me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion && !x.IsMagicImmune())
                          .ToList();
                        var X = me.Position.X;
                        var Y = me.Position.Y;
                        var pos = new Vector3(X, Y, me.Position.Z);
                        if (me.Position.X < 0)
                        {
                            X = me.Position.X + 100;
                        }
                        else
                        {
                            X = me.Position.X - 100;
                        }
                        if (me.Position.Y < 0)
                        {
                            Y = me.Position.Y + 100;
                        }
                        else
                        {
                            Y = me.Position.Y - 100;
                        }
                        uint elsecount = 0;
                        if (blink != null
                            && blink.CanBeCasted()
                            && me.Distance2D(target.Position) > 300
                            && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name))
                        {
                            blink.UseAbility(target.Position);
                        }
                        elsecount++;
                        if ( // vail
                            vail != null
                            && vail.CanBeCasted()
                            && me.CanCast()
                            && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name)
                            && !target.IsMagicImmune()
                            && Utils.SleepCheck("vail")
                            && me.Distance2D(target) <= 1500
                            )
                        {
                            vail.UseAbility(target.Position);
                        }
                        else elsecount++;
                        if (orchid != null && orchid.CanBeCasted() &&
                                menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name))
                        {
                            orchid.UseAbility(target);
                        }
                        else elsecount++;
                        if (sheep != null && sheep.CanBeCasted() &&
                                      menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(sheep.Name))
                        {
                            sheep.UseAbility(target);
                        }
                        else elsecount++;
                        if (ethereal != null
                            && ethereal.CanBeCasted()
                            && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name))
                        {
                            ethereal.UseAbility(target);
                        }
                        else elsecount++;
                        if (Q != null
                            && Q.CanBeCasted()
                            && (blink == null
                            || !blink.CanBeCasted())
                            && me.Distance2D(target) < Q.CastRange
                            && menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name))
                        {
                            Q.UseAbility(pos);
                        }
                        else elsecount++;

                        if (W != null && W.CanBeCasted() && me.Distance2D(target) < 390 &&
                                menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name))
                        {
                            W.UseAbility();
                        }
                        else elsecount++;
                        if (// Dagon
                             elsecount == 7 &&
                                me.CanCast()
                                && dagon != null
                                && (ethereal == null
                                || (target.HasModifier("modifier_item_ethereal_blade_slow")
                                || ethereal.Cooldown < 17))
                                && !target.IsLinkensProtected()
                                && dagon.CanBeCasted()
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled("item_dagon")
                                && !target.IsMagicImmune()
                                && Utils.SleepCheck("dagon")
                                )
                        {
                            dagon.UseAbility(target);
                            Utils.Sleep(200, "dagon");
                        }
                        else elsecount++;  // Dagon Item end
                        if (elsecount == 8 && Shiva != null
                                && Shiva.CanBeCasted()
                                && me.Distance2D(target) <= 600
                                && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name))
                        {
                            Shiva.UseAbility();
                        }
                        else elsecount++;
                        if (elsecount == 9 && R != null && R.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                                 (menu.Item("Heel").GetValue<Slider>().Value)) &&
                            menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name) && Utils.SleepCheck("R"))
                        {
                            R.UseAbility(target.Position);
                            Utils.Sleep(100, "R");
                        }
                    }
                }
                Utils.Sleep(250, "combo");
            }
            //Escape-combo
            if (Game.IsKeyDown(menu.Item("Escape").GetValue<KeyBind>().Key) && me.Distance2D(target) <= 1200 &&
                target.IsVisible && target.IsAlive && !target.IsMagicImmune() &&
                Utils.SleepCheck("combo2"))
            {

                if (me.CanCast())
                {
                    var X = me.Position.X;
                    var Y = me.Position.Y;
                    var pos = new Vector3(X, Y, me.Position.Z);
                    if (me.Position.X < 0)
                    {
                        X = me.Position.X + 100;
                    }
                    else
                    {
                        X = me.Position.X - 100;
                    }
                    if (me.Position.Y < 0)
                    {
                        Y = me.Position.Y + 100;
                    }
                    else
                    {
                        Y = me.Position.Y - 100;
                    }
                    uint elsecount = 0;
                    if (blink != null
                        && blink.CanBeCasted()
                        && me.Distance2D(target.Position) > 300
                        && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name))
                    {
                        blink.UseAbility(target.Position);
                    }
                    elsecount++;
                    if ( // vail
                        vail != null
                        && vail.CanBeCasted()
                        && me.CanCast()
                        && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(vail.Name)
                        && !target.IsMagicImmune()
                        && Utils.SleepCheck("vail")
                        && me.Distance2D(target) <= 1500
                        )
                    {
                        vail.UseAbility(target.Position);
                    }
                    else elsecount++;
                    if (orchid != null && orchid.CanBeCasted() &&
                            menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name))
                    {
                        orchid.UseAbility(target);
                    }
                    else elsecount++;
                    if (sheep != null && sheep.CanBeCasted() &&
                                  menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(sheep.Name))
                    {
                        sheep.UseAbility(target);
                    }
                    else elsecount++;
                    if (ethereal != null
                        && ethereal.CanBeCasted()
                        && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name))
                    {
                        ethereal.UseAbility(target);
                    }
                    else elsecount++;
                        if (Q != null
                            && Q.CanBeCasted()
                            && ( blink == null
                            || !blink.CanBeCasted())
                            && me.Distance2D(target) < Q.CastRange
                            && menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name))
                        {
                            Q.UseAbility(pos);
                    }
                    else elsecount++;

                    if (W != null && W.CanBeCasted() && me.Distance2D(target) < 390 &&
                            menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name))
                        {
                            W.UseAbility();
                    }
                    else elsecount++;
                    if (// Dagon
                         elsecount == 7 &&
                            me.CanCast()
                            && dagon != null
                            && (ethereal == null
                            || (target.HasModifier("modifier_item_ethereal_blade_slow")
                            || ethereal.Cooldown < 17))
                            && !target.IsLinkensProtected()
                            && dagon.CanBeCasted()
                            && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled("item_dagon")
                            && !target.IsMagicImmune()
                            && Utils.SleepCheck("dagon")
                            )
                        {
                            dagon.UseAbility(target);
                            Utils.Sleep(200, "dagon");
                    }
                    else elsecount++;  // Dagon Item end
                    if (Shiva != null
                            && Shiva.CanBeCasted()
                            && me.Distance2D(target) <= 600
                            && menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name))
                        {
                            Shiva.UseAbility();
                    }
                    else elsecount++;
                    if (elsecount ==9 && E != null
                            && E.CanBeCasted()
                            && D != null
                            && D.CanBeCasted()
                            &&
                            ((sheep == null || !sheep.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(sheep.Name))
                             && (Shiva == null || !Shiva.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name))
                             && (dagon == null || !dagon.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled("item_dagon"))
                             && (ethereal == null || !ethereal.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name))
                             && (orchid == null || !orchid.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name))
                             && (blink == null || !blink.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name))
                             && (W == null || !W.CanBeCasted() || me.Distance2D(target) >= 400 || !menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name))
                            && Utils.SleepCheck("1")))
                    {
                        E.UseAbility();
                        Utils.Sleep(250, "1");
                    }
                    if (
                            D != null
                            && D.CanBeCasted()
                            && (sheep == null || !sheep.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(sheep.Name))
                            && (Shiva == null || !Shiva.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name))
                            && (dagon == null || !dagon.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled("item_dagon"))
                            && (ethereal == null || !ethereal.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name))
                            && (orchid == null || !orchid.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name))
                            && (blink == null || !blink.CanBeCasted() || !menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name))
                            && (W == null || !W.CanBeCasted() || me.Distance2D(target) >= 400 || !menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name))
                            && Utils.SleepCheck("12"))
                        {
                            var baseDota =
                                ObjectManager.GetEntities<Unit>()
                                    .Where(unit => unit.Name == "npc_dota_base" && unit.Team == me.Team)
                                    .ToList();

                            if (baseDota != null)
                            {
                                for (int i = 0; i < baseDota.Count(); ++i)
                                {
                                    if (baseDota[i].Distance2D(me) >= 1200)
                                    {
                                        D.UseAbility();
                                    }
                                }
                            }
                            Utils.Sleep(200, "12");
                    }
                }
                Utils.Sleep(300, "combo2");
            }
        }
        public void Combo()
        {
            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key);
            if (!Menu.Item("enabled").IsActive())
                return;
            Q = me.Spellbook.SpellQ;
            W = me.Spellbook.SpellW;
            R = me.Spellbook.SpellR;

            mom = me.FindItem("item_mask_of_madness");
            urn = me.FindItem("item_urn_of_shadows");
            dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));
            mjollnir = me.FindItem("item_mjollnir");
            abyssal = me.FindItem("item_abyssal_blade");
            mail = me.FindItem("item_blade_mail");
            armlet = me.FindItem("item_armlet");
            bkb = me.FindItem("item_black_king_bar");
            satanic = me.FindItem("item_satanic");
            blink = me.FindItem("item_blink");
            medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");
            Shiva = me.FindItem("item_shivas_guard");

            e = Toolset.ClosestToMouse(me);
            if (e == null) return;
            var ModifR = e.HasModifier("modifier_slardar_amplify_damage");
            var stoneModif = e.HasModifier("modifier_medusa_stone_gaze_stone");

            var v =
                ObjectManager.GetEntities<Hero>()
                    .Where(x => x.Team != me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion && !x.IsMagicImmune())
                    .ToList();

            if (Active && me.Distance2D(e) <= 2000 && e.IsAlive && !me.IsInvisible())
            {
                if (
                    blink != null
                    && me.CanCast()
                    && blink.CanBeCasted()
                    && ModifR
                    && me.Distance2D(e) < 1180
                    && me.Distance2D(e) > 400
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                    && Utils.SleepCheck("blink")
                    )
                {
                    blink.UseAbility(e.Position);
                    Utils.Sleep(250, "blink");
                }
                if ( // MOM
                    mom != null
                    && mom.CanBeCasted()
                    && me.CanCast()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                    && Utils.SleepCheck("mom")
                    && me.Distance2D(e) <= 700
                    )
                {
                    mom.UseAbility();
                    Utils.Sleep(250, "mom");
                }
                if (
                    Q != null && Q.CanBeCasted() && me.Distance2D(e) >= 700
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                    && Utils.SleepCheck("Q")
                    )
                {
                    Q.UseAbility();
                    Utils.Sleep(200, "Q");
                }
                if ( // Mjollnir
                    mjollnir != null
                    && mjollnir.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                    && Utils.SleepCheck("mjollnir")
                    && me.Distance2D(e) <= 900
                    )
                {
                    mjollnir.UseAbility(me);
                    Utils.Sleep(250, "mjollnir");
                } // Mjollnir Item end
                if ( // Medall
                    medall != null
                    && medall.CanBeCasted()
                    && Utils.SleepCheck("Medall")
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                    && me.Distance2D(e) <= 700
                    )
                {
                    medall.UseAbility(e);
                    Utils.Sleep(250, "Medall");
                } // Medall Item end
                else if (
                    R != null && R.CanBeCasted() && me.Distance2D(e) <= 900
                    && !ModifR
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                    && Utils.SleepCheck("R")
                    )
                {
                    R.UseAbility(e);
                    Utils.Sleep(200, "R");
                }
                if (
                    W != null
                    && W.CanBeCasted()
                    && (ModifR || R == null || !R.CanBeCasted() || !Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name))
                    && me.Distance2D(e) <= W.GetCastRange()+me.HullRadius+23
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                    && Utils.SleepCheck("W")
                    )
                {
                    W.UseAbility();
                    Utils.Sleep(200, "W");
                }
                if (W != null && W.IsInAbilityPhase && v.Count(x => x.Distance2D(me) <= W.GetCastRange() + me.HullRadius + 23) == 0 && Utils.SleepCheck("Phase"))
                {
                    me.Stop();
                    Utils.Sleep(100, "Phase");
                }
                if ( // Abyssal Blade
                    abyssal != null
                    && abyssal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsStunned()
                    && !e.IsHexed()
                    && Utils.SleepCheck("abyssal")
                    && me.Distance2D(e) <= 400
                    )
                {
                    abyssal.UseAbility(e);
                    Utils.Sleep(250, "abyssal");
                } // Abyssal Item end
                if (armlet != null && !armlet.IsToggled &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(armlet.Name) &&
                    Utils.SleepCheck("armlet"))
                {
                    armlet.ToggleAbility();
                    Utils.Sleep(300, "armlet");
                }

                if (Shiva != null && Shiva.CanBeCasted() && me.Distance2D(e) <= 600
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name)
                    && !e.IsMagicImmune() && Utils.SleepCheck("Shiva"))
                {
                    Shiva.UseAbility();
                    Utils.Sleep(100, "Shiva");
                }

                if ( // Dagon
                    me.CanCast()
                    && dagon != null
                    && !e.IsLinkensProtected()
                    && dagon.CanBeCasted()
                    && !e.IsMagicImmune()
                    && !stoneModif
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled("item_dagon")
                    && Utils.SleepCheck("dagon")
                    )
                {
                    dagon.UseAbility(e);
                    Utils.Sleep(200, "dagon");
                } // Dagon Item end

                if (urn != null && urn.CanBeCasted() && urn.CurrentCharges > 0 && me.Distance2D(e) <= 400
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(urn.Name) && Utils.SleepCheck("urn"))
                {
                    urn.UseAbility(e);
                    Utils.Sleep(240, "urn");
                }
                if ( // Satanic
                    satanic != null &&
                    me.Health <= (me.MaximumHealth * 0.3) &&
                    satanic.CanBeCasted() &&
                    me.Distance2D(e) <= me.AttackRange + 50
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                    && Utils.SleepCheck("satanic")
                    )
                {
                    satanic.UseAbility();
                    Utils.Sleep(240, "satanic");
                } // Satanic Item end
                if (mail != null && mail.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                           (Menu.Item("Heelm").GetValue<Slider>().Value)) &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mail.Name) && Utils.SleepCheck("mail"))
                {
                    mail.UseAbility();
                    Utils.Sleep(100, "mail");
                }
                if (bkb != null && bkb.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                         (Menu.Item("Heel").GetValue<Slider>().Value)) &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(bkb.Name) && Utils.SleepCheck("bkb"))
                {
                    bkb.UseAbility();
                    Utils.Sleep(100, "bkb");
                }
                if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900)
                {
                    Orbwalking.Orbwalk(e, 0, 1600, true, true);
                }
            }
        }
Пример #25
0
        public static void Game_OnUpdate(EventArgs args)
        {
            me = ObjectManager.LocalHero;
            if (!Game.IsInGame || me == null || me.ClassID != ClassID.CDOTA_Unit_Hero_BountyHunter) return;
            if (!Menu.Item("enabled").IsActive())
                return;

            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key);

            RActive = Menu.Item("KeyR").GetValue<KeyBind>().Active;
            Q = me.Spellbook.SpellQ;
            R = me.Spellbook.SpellR;

            var enemies = ObjectManager.GetEntities<Hero>()
                    .Where(x => x.Team != me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion && !x.IsMagicImmune())
                    .ToList();
            if (Active)
            {
                e = me.ClosestToMouseTarget(1800);
                if (e == null)
                    return;
                mom = me.FindItem("item_mask_of_madness");
                urn = me.FindItem("item_urn_of_shadows");
                dagon = me.Inventory.Items.FirstOrDefault(x => x.Name.Contains("item_dagon"));
                ethereal = me.FindItem("item_ethereal_blade");
                halberd = me.FindItem("item_heavens_halberd");
                mjollnir = me.FindItem("item_mjollnir");
                orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");
                abyssal = me.FindItem("item_abyssal_blade");
                mail = me.FindItem("item_blade_mail");
                bkb = me.FindItem("item_black_king_bar");
                satanic = me.FindItem("item_satanic");
                medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");
                Shiva = me.FindItem("item_shivas_guard");

                if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900)
                {
                    Orbwalking.Orbwalk(e, 0, 1600, true, true);
                }
                if (Active && me.Distance2D(e) <= 1400 && e != null && e.IsAlive && !me.IsInvisible())
                {
                    if (
                        Q != null && Q.CanBeCasted() && me.Distance2D(e) <= 1500
                        && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                        && Utils.SleepCheck("Q")
                        )
                    {
                        Q.UseAbility(e);
                        Utils.Sleep(200, "Q");
                    }
                    if (
                        R != null && R.CanBeCasted() && me.Distance2D(e) <= 1500
                        && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(R.Name)
                        && !me.HasModifier("modifier_bounty_hunter_wind_walk")
                        && !me.IsChanneling()
                        && Utils.SleepCheck("R")
                        )
                    {
                        R.UseAbility(e);
                        Utils.Sleep(200, "R");
                    }

                    if ( // MOM
                        mom != null
                        && mom.CanBeCasted()
                        && me.CanCast()
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mom.Name)
                        && Utils.SleepCheck("mom")
                        && me.Distance2D(e) <= 700
                        )
                    {
                        mom.UseAbility();
                        Utils.Sleep(250, "mom");
                    }
                    if ( // Mjollnir
                        mjollnir != null
                        && mjollnir.CanBeCasted()
                        && me.CanCast()
                        && !e.IsMagicImmune()
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                        && Utils.SleepCheck("mjollnir")
                        && me.Distance2D(e) <= 900
                        )
                    {
                        mjollnir.UseAbility(me);
                        Utils.Sleep(250, "mjollnir");
                    } // Mjollnir Item end
                    if ( // Medall
                        medall != null
                        && medall.CanBeCasted()
                        && Utils.SleepCheck("Medall")
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                        && me.Distance2D(e) <= 700
                        )
                    {
                        medall.UseAbility(e);
                        Utils.Sleep(250, "Medall");
                    } // Medall Item end
                    if ( // Hellbard
                        halberd != null
                        && halberd.CanBeCasted()
                        && me.CanCast()
                        && !e.IsMagicImmune()
                        && (e.NetworkActivity == NetworkActivity.Attack
                            || e.NetworkActivity == NetworkActivity.Crit
                            || e.NetworkActivity == NetworkActivity.Attack2)
                        && Utils.SleepCheck("halberd")
                        && me.Distance2D(e) <= 700
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(halberd.Name)
                        )
                    {
                        halberd.UseAbility(e);
                        Utils.Sleep(250, "halberd");
                    }
                    if (orchid != null && orchid.CanBeCasted() && me.Distance2D(e) <= 900 &&
                        Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name) && Utils.SleepCheck("orchid"))
                    {
                        orchid.UseAbility(e);
                        Utils.Sleep(100, "orchid");
                    }

                    if (Shiva != null && Shiva.CanBeCasted() && me.Distance2D(e) <= 600
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name)
                        && !e.IsMagicImmune() && Utils.SleepCheck("Shiva"))
                    {
                        Shiva.UseAbility();
                        Utils.Sleep(100, "Shiva");
                    }

                    if (ethereal != null && ethereal.CanBeCasted()
                        && me.Distance2D(e) <= 700 && me.Distance2D(e) <= 400
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name) &&
                        Utils.SleepCheck("ethereal"))
                    {
                        ethereal.UseAbility(e);
                        Utils.Sleep(100, "ethereal");
                    }

                    if (dagon != null
                        && dagon.CanBeCasted()
                        && me.Distance2D(e) <= 500
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled("item_dagon")
                        && Utils.SleepCheck("dagon"))
                    {
                        dagon.UseAbility(e);
                        Utils.Sleep(100, "dagon");
                    }
                    if ( // Abyssal Blade
                        abyssal != null
                        && abyssal.CanBeCasted()
                        && me.CanCast()
                        && !e.IsStunned()
                        && !e.IsHexed()
                        && Utils.SleepCheck("abyssal")
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(abyssal.Name)
                        && me.Distance2D(e) <= 400
                        )
                    {
                        abyssal.UseAbility(e);
                        Utils.Sleep(250, "abyssal");
                    } // Abyssal Item end
                    if (urn != null && urn.CanBeCasted() && urn.CurrentCharges > 0 && me.Distance2D(e) <= 400
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(urn.Name) && Utils.SleepCheck("urn"))
                    {
                        urn.UseAbility(e);
                        Utils.Sleep(240, "urn");
                    }
                    if ( // Satanic
                        satanic != null &&
                        me.Health <= (me.MaximumHealth * 0.3) &&
                        satanic.CanBeCasted() &&
                        me.Distance2D(e) <= me.AttackRange + 50
                        && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                        && Utils.SleepCheck("satanic")
                        )
                    {
                        satanic.UseAbility();
                        Utils.Sleep(240, "satanic");
                    } // Satanic Item end
                    if (mail != null && mail.CanBeCasted() && (enemies.Count(x => x.Distance2D(me) <= 650) >=
                                                               (Menu.Item("Heelm").GetValue<Slider>().Value)) &&
                        Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mail.Name) && Utils.SleepCheck("mail"))
                    {
                        mail.UseAbility();
                        Utils.Sleep(100, "mail");
                    }
                    if (bkb != null && bkb.CanBeCasted() && (enemies.Count(x => x.Distance2D(me) <= 650) >=
                                                             (Menu.Item("Heel").GetValue<Slider>().Value)) &&
                        Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(bkb.Name) && Utils.SleepCheck("bkb"))
                    {
                        bkb.UseAbility();
                        Utils.Sleep(100, "bkb");
                    }
                }
            }

            if (RActive && me.IsAlive && R != null && R.CanBeCasted())
                if (!me.HasModifier("modifier_bounty_hunter_wind_walk")|| me.IsVisibleToEnemies)
                    foreach (var v in enemies)
                    {
                        var CheckMod = v.Modifiers.Where(y => y.Name == "modifier_bounty_hunter_track").DefaultIfEmpty(null).FirstOrDefault();
                        var invItem = v.FindItem("item_glimmer_cape")?? v.FindItem("item_invis_sword") ?? v.FindItem("item_silver_edge") ?? v.FindItem("item_glimmer_cape");
                        if (
                            (( v.ClassID == ClassID.CDOTA_Unit_Hero_Riki     || v.ClassID == ClassID.CDOTA_Unit_Hero_Broodmother
                            || v.ClassID == ClassID.CDOTA_Unit_Hero_Clinkz   || v.ClassID == ClassID.CDOTA_Unit_Hero_Invoker
                            || v.ClassID == ClassID.CDOTA_Unit_Hero_SandKing || v.ClassID == ClassID.CDOTA_Unit_Hero_TemplarAssassin
                            || v.ClassID == ClassID.CDOTA_Unit_Hero_Treant   || v.ClassID == ClassID.CDOTA_Unit_Hero_PhantomLancer
                            )
                            || (
                                v.Modifiers.Any(x =>
                                (x.Name == "modifier_riki_permanent_invisibility"
                                || x.Name == "modifier_mirana_moonlight_shadow"
                                || x.Name == "modifier_treant_natures_guise"
                                || x.Name == "modifier_weaver_shukuchi"
                                || x.Name == "modifier_broodmother_spin_web_invisible_applier"
                                || x.Name == "modifier_item_invisibility_edge_windwalk"
                                || x.Name == "modifier_rune_invis"
                                || x.Name == "modifier_clinkz_wind_walk"
                                || x.Name == "modifier_item_shadow_amulet_fade"
                                || x.Name == "modifier_item_silver_edge_windwalk"
                                || x.Name == "modifier_item_edge_windwalk"
                                || x.Name == "modifier_nyx_assassin_vendetta"
                                || x.Name == "modifier_invisible"
                                || x.Name == "modifier_invoker_ghost_walk_enemy")))
                            ||(invItem!=null && invItem.Cooldown<=0)
                            || v.Health <= (v.MaximumHealth * 0.5))
                            && me.Distance2D(v) <= R.GetCastRange()+me.HullRadius
                            && (!v.HasModifier("modifier_bounty_hunter_track") || CheckMod != null && CheckMod.RemainingTime <= 2)
                            && Utils.SleepCheck("R"))
                        {
                            R.UseAbility(v);
                            Utils.Sleep(300, "R");
                        }
                    }
        }
Пример #26
0
        private static void Game_OnUpdate(EventArgs args)
        {
            if (sleeper.Sleeping)
            {
                return;
            }

            dagon = hero.GetDagon();

            if (dagon == null || Game.IsPaused || !Menu.Item("key").GetValue<KeyBind>().Active || hero.IsChanneling()
                || (hero.IsInvisible() && !hero.IsVisibleToEnemies))
            {
                sleeper.Sleep(200);
                return;
            }

            if (hero.ClassID == ClassID.CDOTA_Unit_Hero_ArcWarden)
            {
                heroClone =
                    ObjectManager.GetEntities<Hero>()
                        .FirstOrDefault(
                            x =>
                            x.IsAlive && x.Team == hero.Team
                            && x.HasModifier("modifier_arc_warden_tempest_double"));

                if (heroClone != null)
                {
                    dagonClone = heroClone.GetDagon();
                }
            }

            var target = ObjectManager.GetEntities<Hero>().FirstOrDefault(x => CheckTarget(x));

            if (target != null)
            {
                if (hero.CanUseItems() && dagon.CanBeCasted())
                {
                    dagon.UseAbility(target);
                }
                else if (heroClone != null && dagonClone.CanBeCasted() && heroClone.CanUseItems())
                {
                    dagonClone.UseAbility(target);
                }
            }
            else if (heroClone != null)
            {
                if (dagonClone.CanBeCasted() && heroClone.CanUseItems() && dagon.CanBeCasted() && hero.CanUseItems())
                {
                    target = ObjectManager.GetEntities<Hero>().FirstOrDefault(x => CheckTarget(x, true));
                    if (target != null)
                    {
                        dagon.UseAbility(target);
                        dagonClone.UseAbility(target);
                    }
                }
            }

            sleeper.Sleep(200);
        }
Пример #27
0
        private static void Game_OnUpdate(EventArgs args)
        {
            if (!loaded)
            {
                me = ObjectMgr.LocalHero;


                if (!Game.IsInGame || Game.IsWatchingGame || me == null || Game.IsChatOpen)
                {
                    return;
                }
                loaded = true;
            }

            if (me == null || !me.IsValid)
            {
                loaded = false;
                me = ObjectMgr.LocalHero;
                supportActive = false;
                includeSaveSelf = false;
                shouldCastLotusOrb = false;
                shouldCastGlimmerCape = false;
                return;
            }

            if (Game.IsPaused)
            {
                return;
            }

            Urn = me.FindItem("item_urn_of_shadows");
            Meka = me.FindItem("item_mekansm");
            Guardian = me.FindItem("item_guardian_greaves");
            Arcane = me.FindItem("item_arcane_boots");
            LotusOrb = me.FindItem("item_lotus_orb");
            Medallion = me.FindItem("item_medallion_of_courage");
            SolarCrest = me.FindItem("item_solar_crest");
            GlimmerCape = me.FindItem("item_glimmer_cape");
            Pipe = me.FindItem("item_pipe");
            CrimsonGuard = me.FindItem("item_crimson_guard");

            needMana = null;
            needMeka = null;
            shouldCastLotusOrb = false;
            shouldCastGlimmerCape = false;

            if (!Game.IsChatOpen)
            {
                if (Game.IsKeyDown(toggleKey) && Utils.SleepCheck("togglingoption"))
                {
                    if (!supportActive)
                    {
                        supportActive = true;
                    }
                    else
                    {
                        supportActive = false;
                    }
                    Utils.Sleep(100 + Game.Ping, "togglingoption");
                }

                if (Game.IsKeyDown(saveSelfKey) && Utils.SleepCheck("togglingoption"))
                {
                    if (!includeSaveSelf)
                    {
                        includeSaveSelf = true;
                    }
                    else
                    {
                        includeSaveSelf = false;
                    }
                    Utils.Sleep(100 + Game.Ping, "togglingoption");
                }
            }

            if (supportActive)
            {
                var allies =
                    ObjectMgr.GetEntities<Hero>()
                        .Where(
                            ally =>
                                ally.Team == me.Team && ally.IsAlive && !ally.IsIllusion && me.Distance2D(ally) <= 1500)
                        .ToList();
                fountain =
                    ObjectMgr.GetEntities<Entity>()
                        .First(entity => entity.ClassID == ClassID.CDOTA_Unit_Fountain && entity.Team == me.Team);


                if (allies.Any())
                {
                    foreach (var ally in allies)
                    {
                        if (!ally.IsIllusion() && ally.IsAlive && ally.Health > 0 && me.IsAlive && !me.IsChanneling() &&
                            me.Distance2D(fountain) > 2000 &&
                            !me.IsInvisible())
                        {
                            if ((ally.MaximumHealth - ally.Health) > (450 + ally.HealthRegeneration*10) &&
                                me.Distance2D(ally) <= 2000 &&
                                (me.Mana >= 225 || Guardian != null))
                            {
                                if (needMeka == null || (needMeka != null && me.Distance2D(needMeka) <= 750))
                                {
                                    needMeka = ally;
                                }
                            }

                            var enemyTowers =
                                ObjectMgr.GetEntities<Entity>()
                                    .Any(
                                        x =>
                                            x.ClassID == ClassID.CDOTA_BaseNPC_Tower && x.Team != me.Team &&
                                            x.IsAlive && ally.Distance2D(x) <= 750);

                            if (me.CanUseItems())
                            {
                                if (Urn != null && Urn.CanBeCasted() && Urn.CurrentCharges > 0 &&
                                    !ally.Modifiers.Any(x => x.Name == "modifier_item_urn_heal") && !enemyTowers)
                                {
                                    if (me.Distance2D(ally) <= 950 && !IsInDanger(ally) && Utils.SleepCheck("Urn") &&
                                        ally.Health <= (ally.MaximumHealth*0.7))
                                    {
                                        Urn.UseAbility(ally);
                                        Utils.Sleep(100 + Game.Ping, "Urn");
                                    }
                                    if (ally.Modifiers.Any(x => x.Name == "modifier_wisp_tether") &&
                                        (ally.MaximumHealth - ally.Health) >= 600 && Utils.SleepCheck("Urn"))
                                    {
                                        Urn.UseAbility(me);
                                        Utils.Sleep(100 + Game.Ping, "Urn");
                                    }
                                }

                                if (Arcane != null && Arcane.Cooldown == 0)
                                {
                                    if ((ally.MaximumMana - ally.Mana) >= 135 && me.Distance2D(ally) < 2000 &&
                                        me.Mana >= 35)
                                    {
                                        if (needMana == null || (needMana != null && me.Distance2D(needMana) <= 600))
                                        {
                                            needMana = ally;
                                        }
                                    }
                                }

                                /*Pipe and Crimson Guard*/
                                if (((Pipe != null && Pipe.CanBeCasted()) ||
                                     (CrimsonGuard != null && CrimsonGuard.CanBeCasted())) && me.CanUseItems())
                                {
                                    var enemiesInRadius =
                                        ObjectMgr.GetEntities<Hero>()
                                            .Where(
                                                x =>
                                                    x.Team != me.Team && x.IsAlive && me.Distance2D(x) <= 1500 &&
                                                    !x.IsIllusion).ToList();
                                    var alliesInRadius =
                                        ObjectMgr.GetEntities<Hero>()
                                            .Where(
                                                x =>
                                                    x.Team == me.Team && x.IsAlive && me.Distance2D(x) <= 900 &&
                                                    !x.IsIllusion).ToList();

                                    if (enemiesInRadius.Any() && alliesInRadius.Any())
                                    {
                                        if (enemiesInRadius.Count >= 2 && alliesInRadius.Count >= 2)
                                        {
                                            if (Pipe != null && Pipe.CanBeCasted() && Utils.SleepCheck("Pipe"))
                                            {
                                                Pipe.UseAbility();
                                                Utils.Sleep(100 + Game.Ping, "Pipe");
                                            }

                                            if (CrimsonGuard != null && CrimsonGuard.CanBeCasted() &&
                                                Utils.SleepCheck("CrimsonGuard"))
                                            {
                                                CrimsonGuard.UseAbility();
                                                Utils.Sleep(100 + Game.Ping, "CrimsonGuard");
                                            }
                                        }
                                    }
                                }

                                var enemyList =
                                    ObjectMgr.GetEntities<Hero>()
                                        .Where(
                                            x =>
                                                x.Team != me.Team && !x.IsIllusion && x.IsAlive && x.CanCast() &&
                                                ally.Distance2D(x) <= 1000)
                                        .ToList();

                                if (enemyList.Any())
                                {
                                    foreach (var enemy in enemyList)
                                    {
                                        var targettedSpell =
                                            enemy.Spellbook.Spells.Any(
                                                x =>
                                                    x.TargetTeamType == TargetTeamType.Enemy &&
                                                    x.AbilityState == AbilityState.Ready &&
                                                    ally.Distance2D(enemy) <= x.CastRange + 50 &&
                                                    x.AbilityBehavior == AbilityBehavior.UnitTarget);

                                        var targettedItem =
                                            enemy.Inventory.Items.Any(
                                                x =>
                                                    x.TargetTeamType == TargetTeamType.Enemy &&
                                                    x.AbilityState == AbilityState.Ready &&
                                                    x.AbilityBehavior == AbilityBehavior.UnitTarget &&
                                                    ally.Distance2D(enemy) <= x.CastRange + 50);

                                        var enemySkill =
                                            enemy.Spellbook.Spells.Any(
                                                x =>
                                                    x.DamageType == DamageType.Magical &&
                                                    x.TargetTeamType == TargetTeamType.Enemy &&
                                                    x.AbilityState == AbilityState.Ready &&
                                                    ally.Distance2D(enemy) <= x.CastRange + 50);

                                        if (enemySkill)
                                        {
                                            shouldCastGlimmerCape = true;
                                        }

                                        if (targettedSpell || targettedItem)
                                        {
                                            shouldCastLotusOrb = true;
                                        }
                                    }
                                }

                                if (LotusOrb != null && LotusOrb.Cooldown == 0 && Utils.SleepCheck("LotusOrb") &&
                                    me.Distance2D(ally) <= LotusOrb.CastRange + 50 &&
                                    (shouldCastLotusOrb || IsInDanger(ally)))
                                {
                                    LotusOrb.UseAbility(ally);
                                    Utils.Sleep(100 + Game.Ping, "LotusOrb");
                                }

                                if (Medallion != null && Medallion.Cooldown == 0 &&
                                    me.Distance2D(ally) <= Medallion.CastRange + 50 && Utils.SleepCheck("Medallion") &&
                                    ally != me && IsInDanger(ally))
                                {
                                    Medallion.UseAbility(ally);
                                    Utils.Sleep(100 + Game.Ping, "Medallion");
                                }

                                if (SolarCrest != null && SolarCrest.Cooldown == 0 &&
                                    me.Distance2D(ally) <= SolarCrest.CastRange + 50 && Utils.SleepCheck("SolarCrest") &&
                                    ally != me && IsInDanger(ally))
                                {
                                    SolarCrest.UseAbility(ally);
                                    Utils.Sleep(100 + Game.Ping, "SolarCrest");
                                }

                                if (GlimmerCape != null && GlimmerCape.Cooldown == 0 &&
                                    me.Distance2D(ally) <= GlimmerCape.CastRange + 50 && Utils.SleepCheck("GlimmerCape") &&
                                    (shouldCastGlimmerCape || IsInDanger(ally)))
                                {
                                    GlimmerCape.UseAbility(ally);
                                    Utils.Sleep(100 + Game.Ping, "GlimmerCape");
                                }
                            }
                        }
                    }
                }

                if (needMeka != null &&
                    ((Guardian != null && Guardian.CanBeCasted()) || (Meka != null && Meka.CanBeCasted())) &&
                    me.Distance2D(needMeka) <= 750)
                {
                    if (Meka != null)
                    {
                        Meka.UseAbility();
                    }
                    else
                    {
                        Guardian.UseAbility();
                    }
                }
                if (needMana != null && Arcane != null && Arcane.CanBeCasted() && me.Distance2D(needMana) <= 600)
                {
                    Arcane.UseAbility();
                }


                if (Support(me.ClassID))
                {
                    switch (me.ClassID)
                    {
                        case ClassID.CDOTA_Unit_Hero_Abaddon:
                            Save(me, me.Spellbook.SpellW, 1000, me.Spellbook.SpellW.CastRange);
                            Heal(me, me.Spellbook.SpellQ, new float[] {100, 150, 200, 250},
                                800,
                                1, false);
                            break;
                        case ClassID.CDOTA_Unit_Hero_Chen:
                            Save(me, me.Spellbook.SpellE, 1000, me.Spellbook.SpellE.CastRange);
                            Heal(me, me.Spellbook.SpellR, new float[] {200, 300, 400},
                                2200000, 2);
                            break;
                        case ClassID.CDOTA_Unit_Hero_Dazzle:
                            Save(me, me.Spellbook.SpellW, 300, me.Spellbook.SpellW.CastRange);
                            Heal(me, me.Spellbook.SpellE, new float[] {80, 100, 120, 140},
                                750,
                                1);
                            break;
                        case ClassID.CDOTA_Unit_Hero_Enchantress:
                            Heal(me, me.Spellbook.SpellE, new float[] {400, 600, 800, 1000},
                                275, 2);
                            break;
                        case ClassID.CDOTA_Unit_Hero_Legion_Commander:
                            Heal(me, me.Spellbook.SpellW, new float[] {150, 200, 250, 300},
                                800,
                                1);
                            break;
                        case ClassID.CDOTA_Unit_Hero_Necrolyte:
                            Heal(me, me.Spellbook.SpellQ, new float[] {70, 90, 110, 130},
                                475,
                                2);
                            break;
                        case ClassID.CDOTA_Unit_Hero_Omniknight:
                            Heal(me, me.Spellbook.SpellQ, new float[] {90, 180, 270, 360},
                                950,
                                1);
                            Save(me, me.Spellbook.SpellW, 1570, me.Spellbook.SpellW.CastRange);
                            break;
                        case ClassID.CDOTA_Unit_Hero_Oracle:
                            Save(me, me.Spellbook.SpellR, 1270, me.Spellbook.SpellR.CastRange);
                            Heal(me, me.Spellbook.SpellE, new float[] {99, 198, 297, 396},
                                750,
                                1);
                            break;
                        case ClassID.CDOTA_Unit_Hero_Shadow_Demon:
                            Save(me, me.Spellbook.SpellQ, 900,
                                me.Spellbook.SpellQ.CastRange);
                            break;
                        case ClassID.CDOTA_Unit_Hero_Treant:
                            Heal(me, me.Spellbook.SpellE, new float[] {60, 105, 150, 195},
                                2200000, 1);
                            break;
                        case ClassID.CDOTA_Unit_Hero_Undying:
                            var unitsAround =
                                ObjectMgr.GetEntities<Entity>()
                                    .Where(entity => entity.IsAlive && me.Distance2D(entity) <= 1300).ToList();

                            if (unitsAround.Any())
                            {
                                var unitCount = unitsAround.Count;
                                var healperUnit = new[] {18, 22, 36, 30};

                                Heal(me, me.Spellbook.SpellW,
                                    new float[]
                                    {
                                        unitCount*healperUnit[me.Spellbook.SpellW.Level - 1],
                                        unitCount*healperUnit[me.Spellbook.SpellW.Level - 1],
                                        unitCount*healperUnit[me.Spellbook.SpellW.Level - 1],
                                        unitCount*healperUnit[me.Spellbook.SpellW.Level - 1]
                                    },
                                    750, 1);
                            }
                            break;
                        case ClassID.CDOTA_Unit_Hero_Warlock:
                            Heal(me, me.Spellbook.SpellW, new float[] {165, 275, 385, 495},
                                me.Spellbook.SpellW.CastRange, 1);
                            break;
                        case ClassID.CDOTA_Unit_Hero_Winter_Wyvern:
                            Save(me, me.Spellbook.SpellE, 930, me.Spellbook.SpellE.CastRange);
                            break;
                        case ClassID.CDOTA_Unit_Hero_WitchDoctor:
                            Heal(me, me.Spellbook.SpellW, new float[] {16, 24, 32, 40}, 500,
                                3);
                            break;
                    }
                }
            }

            if (Game.IsKeyDown(orbwalkKey))
            {
                if (target != null && (!target.IsValid || !target.IsVisible || !target.IsAlive || target.Health <= 0))
                {
                    target = null;
                }
                var canCancel = Orbwalking.CanCancelAnimation();
                if (canCancel)
                {
                    if (target != null && !target.IsVisible && !Orbwalking.AttackOnCooldown(target))
                    {
                        target = me.ClosestToMouseTarget();
                    }
                    else if (target == null || !Orbwalking.AttackOnCooldown(target))
                    {
                        var bestAa = me.BestAATarget();
                        if (bestAa != null)
                        {
                            target = me.BestAATarget();
                        }
                    }
                }

                Orbwalking.Orbwalk(target, Game.Ping, attackmodifiers: true);
            }
        }
        public void Combo()
        {
            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key);

            Q = me.Spellbook.SpellQ;
            W = me.FindSpell("drow_ranger_silence");

            mom = me.FindItem("item_mask_of_madness");
            urn = me.FindItem("item_urn_of_shadows");
            dagon = me.Inventory.Items.FirstOrDefault(x => x.Name.Contains("item_dagon"));
            ethereal = me.FindItem("item_ethereal_blade");
            halberd = me.FindItem("item_heavens_halberd");
            mjollnir = me.FindItem("item_mjollnir");
            armlet = me.FindItem("item_armlet");
            abyssal = me.FindItem("item_abyssal_blade");
            mail = me.FindItem("item_blade_mail");
            bkb = me.FindItem("item_black_king_bar");
            satanic = me.FindItem("item_satanic");
            medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");
            Shiva = me.FindItem("item_shivas_guard");
            var v =
                ObjectManager.GetEntities<Hero>()
                    .Where(x => x.Team != me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion && !x.IsMagicImmune())
                    .ToList();
            e = Toolset.ClosestToMouse(me);
            if (e == null)
                return;
            if (Active)
            {
                if ((!Q.CanBeCasted() || !Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)))
                {
                    if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900)
                    {
                        Orbwalking.Orbwalk(e, 0, 1600, false, true);
                    }
                }
            }
            if (Active && me.Distance2D(e) <= 1400 && e != null && e.IsAlive && !Toolset.invUnit(me))
            {
                if (
                    W != null && W.CanBeCasted() && me.Distance2D(e) <= W.GetCastRange()
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                    && me.NetworkActivity != NetworkActivity.Attack
                    && Utils.SleepCheck("W")
                    )
                {
                    W.UseAbility(e.Position);
                    Utils.Sleep(200, "W");
                }
                if (
                    Q != null && Q.CanBeCasted()
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                    )
                {
                    if (Menu.Item("orbwalk").GetValue<bool>() && me.Distance2D(e) <= 1900)
                    {
                        Orbwalking.Orbwalk(e, 0, 1600, true, true);
                    }
                }
                if ( // MOM
                    mom != null
                    && mom.CanBeCasted()
                    && me.CanCast()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mom.Name)
                    && Utils.SleepCheck("mom")
                    && me.Distance2D(e) <= 700
                    )
                {
                    mom.UseAbility();
                    Utils.Sleep(250, "mom");
                }
                if ( // Mjollnir
                    mjollnir != null
                    && mjollnir.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                    && Utils.SleepCheck("mjollnir")
                    && me.Distance2D(e) <= 900
                    )
                {
                    mjollnir.UseAbility(me);
                    Utils.Sleep(250, "mjollnir");
                } // Mjollnir Item end
                if ( // Medall
                    medall != null
                    && medall.CanBeCasted()
                    && Utils.SleepCheck("Medall")
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                    && me.Distance2D(e) <= 700
                    )
                {
                    medall.UseAbility(e);
                    Utils.Sleep(250, "Medall");
                } // Medall Item end
                if (armlet != null && !armlet.IsToggled &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(armlet.Name) &&
                    Utils.SleepCheck("armlet"))
                {
                    armlet.ToggleAbility();
                    Utils.Sleep(300, "armlet");
                }

                if (Shiva != null && Shiva.CanBeCasted() && me.Distance2D(e) <= 600
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name)
                    && !e.IsMagicImmune() && Utils.SleepCheck("Shiva"))
                {
                    Shiva.UseAbility();
                    Utils.Sleep(100, "Shiva");
                }

                if (ethereal != null && ethereal.CanBeCasted()
                    && me.Distance2D(e) <= 700 && me.Distance2D(e) <= 400
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name) &&
                    Utils.SleepCheck("ethereal"))
                {
                    ethereal.UseAbility(e);
                    Utils.Sleep(100, "ethereal");
                }

                if (dagon != null
                    && dagon.CanBeCasted()
                    && me.Distance2D(e) <= 500
                    && Utils.SleepCheck("dagon"))
                {
                    dagon.UseAbility(e);
                    Utils.Sleep(100, "dagon");
                }
                if ( // Abyssal Blade
                    abyssal != null
                    && abyssal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsStunned()
                    && !e.IsHexed()
                    && Utils.SleepCheck("abyssal")
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(abyssal.Name)
                    && me.Distance2D(e) <= 400
                    )
                {
                    abyssal.UseAbility(e);
                    Utils.Sleep(250, "abyssal");
                } // Abyssal Item end
                if (urn != null && urn.CanBeCasted() && urn.CurrentCharges > 0 && me.Distance2D(e) <= 700
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(urn.Name) && Utils.SleepCheck("urn"))
                {
                    urn.UseAbility(e);
                    Utils.Sleep(240, "urn");
                }
                if ( // Hellbard
                    halberd != null
                    && halberd.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && (e.NetworkActivity == NetworkActivity.Attack
                        || e.NetworkActivity == NetworkActivity.Crit
                        || e.NetworkActivity == NetworkActivity.Attack2)
                    && Utils.SleepCheck("halberd")
                    && me.Distance2D(e) <= 700
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(halberd.Name)
                    )
                {
                    halberd.UseAbility(e);
                    Utils.Sleep(250, "halberd");
                }
                if ( // Satanic
                    satanic != null &&
                    me.Health <= (me.MaximumHealth * 0.3) &&
                    satanic.CanBeCasted() &&
                    me.Distance2D(e) <= me.AttackRange + 100
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                    && Utils.SleepCheck("satanic")
                    )
                {
                    satanic.UseAbility();
                    Utils.Sleep(240, "satanic");
                } // Satanic Item end
                if (mail != null && mail.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                           (Menu.Item("Heelm").GetValue<Slider>().Value)) &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mail.Name) && Utils.SleepCheck("mail"))
                {
                    mail.UseAbility();
                    Utils.Sleep(100, "mail");
                }
                if (bkb != null && bkb.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                         (Menu.Item("Heel").GetValue<Slider>().Value)) &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(bkb.Name) && Utils.SleepCheck("bkb"))
                {
                    bkb.UseAbility();
                    Utils.Sleep(100, "bkb");
                }
            }
        }
        public void Combo()
        {
            if (!Menu.Item("enabled").GetValue<bool>()) return;

            Active = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key);

            Q = me.Spellbook.SpellQ;
            R = me.Spellbook.SpellR;
            W = me.Spellbook.SpellW;

            mom = me.FindItem("item_mask_of_madness");
            urn = me.FindItem("item_urn_of_shadows");
            dagon = me.Inventory.Items.FirstOrDefault(x => x.Name.Contains("item_dagon"));
            ethereal = me.FindItem("item_ethereal_blade");
            halberd = me.FindItem("item_heavens_halberd");
            mjollnir = me.FindItem("item_mjollnir");
            blink = me.FindItem("item_blink");
            orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");
            abyssal = me.FindItem("item_abyssal_blade");
            mail = me.FindItem("item_blade_mail");
            bkb = me.FindItem("item_black_king_bar");
            satanic = me.FindItem("item_satanic");
            medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");
            Shiva = me.FindItem("item_shivas_guard");
            var v =
                ObjectManager.GetEntities<Hero>()
                    .Where(x => x.Team != me.Team && x.IsAlive && x.IsVisible && !x.IsIllusion && !x.IsMagicImmune())
                    .ToList();
            e = Toolset.ClosestToMouse(me);
            if (e == null) return;

            if (Active && me.IsInvisible())
            {
                if (me.Distance2D(e) <= 150 && Utils.SleepCheck("Attack") && me.NetworkActivity != NetworkActivity.Attack)
                {
                    me.Attack(e);
                    Utils.Sleep(150, "Attack");
                }
                else if (me.Distance2D(e) <= 2400 && me.Distance2D(e) >= 130 && me.NetworkActivity != NetworkActivity.Attack && Utils.SleepCheck("Move"))
                {
                    me.Move(e.Position);
                    Utils.Sleep(150, "Move");
                }
            }
            else if (Active && me.Distance2D(e) <= 1400 && e.IsAlive && !me.IsInvisible())
            {
                if (me.Distance2D(e) >= 400)
                {
                    if (
                        W != null && W.CanBeCasted() && me.Distance2D(e) <= 1100
                        && me.CanAttack()
                        && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(W.Name)
                        && Utils.SleepCheck("W")
                        )
                    {
                        W.UseAbility();
                        Utils.Sleep(100, "W");
                    }
                }
                if (W != null && W.IsInAbilityPhase || me.HasModifier("modifier_weaver_shukuchi")) return;

                if (Menu.Item("orbwalk").GetValue<bool>())
                {
                    Orbwalking.Orbwalk(e, 0, 1600, true, true);
                }
                if (
                    blink != null
                    && me.CanCast()
                    && blink.CanBeCasted()
                    && me.Distance2D(e) < 1190
                    && me.Distance2D(e) > me.AttackRange - 50
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(blink.Name)
                    && Utils.SleepCheck("blink")
                    )
                {
                    blink.UseAbility(e.Position);
                    Utils.Sleep(250, "blink");
                }
                if (
                    Q != null && Q.CanBeCasted() && me.Distance2D(e) <= me.AttackRange + 300
                    && me.CanAttack()
                    && Menu.Item("Skills").GetValue<AbilityToggler>().IsEnabled(Q.Name)
                    && Utils.SleepCheck("Q")
                    )
                {
                    Q.UseAbility(e.Position);
                    Utils.Sleep(100, "Q");
                }
                if ( // MOM
                mom != null
                && mom.CanBeCasted()
                && me.CanCast()
                && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mom.Name)
                && Utils.SleepCheck("mom")
                && me.Distance2D(e) <= 700
                )
                {
                    mom.UseAbility();
                    Utils.Sleep(250, "mom");
                }
                if ( // Mjollnir
                    mjollnir != null
                    && mjollnir.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mjollnir.Name)
                    && Utils.SleepCheck("mjollnir")
                    && me.Distance2D(e) <= 900
                    )
                {
                    mjollnir.UseAbility(me);
                    Utils.Sleep(250, "mjollnir");
                } // Mjollnir Item end
                if ( // Medall
                    medall != null
                    && medall.CanBeCasted()
                    && Utils.SleepCheck("Medall")
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(medall.Name)
                    && me.Distance2D(e) <= 700
                    )
                {
                    medall.UseAbility(e);
                    Utils.Sleep(250, "Medall");
                } // Medall Item end
                if ( // orchid
                    orchid != null
                    && orchid.CanBeCasted()
                    && me.CanCast()
                    && !e.IsLinkensProtected()
                    && !e.IsMagicImmune()
                    && me.Distance2D(e) <= me.AttackRange + 40
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(orchid.Name)
                    && Utils.SleepCheck("orchid")
                    )
                {
                    orchid.UseAbility(e);
                    Utils.Sleep(250, "orchid");
                } // orchid Item end

                if (Shiva != null && Shiva.CanBeCasted() && me.Distance2D(e) <= 600
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(Shiva.Name)
                    && !e.IsMagicImmune() && Utils.SleepCheck("Shiva"))
                {
                    Shiva.UseAbility();
                    Utils.Sleep(100, "Shiva");
                }

                if (ethereal != null && ethereal.CanBeCasted()
                    && me.Distance2D(e) <= 700 && me.Distance2D(e) <= 400
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(ethereal.Name) &&
                    Utils.SleepCheck("ethereal"))
                {
                    ethereal.UseAbility(e);
                    Utils.Sleep(100, "ethereal");
                }

                if (dagon != null
                    && dagon.CanBeCasted()
                    && me.Distance2D(e) <= 500
                    && Utils.SleepCheck("dagon"))
                {
                    dagon.UseAbility(e);
                    Utils.Sleep(100, "dagon");
                }
                if ( // Abyssal Blade
                    abyssal != null
                    && abyssal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsStunned()
                    && !e.IsHexed()
                    && Utils.SleepCheck("abyssal")
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(abyssal.Name)
                    && me.Distance2D(e) <= 400
                    )
                {
                    abyssal.UseAbility(e);
                    Utils.Sleep(250, "abyssal");
                } // Abyssal Item end
                if (urn != null && urn.CanBeCasted() && urn.CurrentCharges > 0 && me.Distance2D(e) <= 400
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(urn.Name) && Utils.SleepCheck("urn"))
                {
                    urn.UseAbility(e);
                    Utils.Sleep(240, "urn");
                }
                if ( // Hellbard
                    halberd != null
                    && halberd.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && (e.NetworkActivity == NetworkActivity.Attack
                        || e.NetworkActivity == NetworkActivity.Crit
                        || e.NetworkActivity == NetworkActivity.Attack2)
                    && Utils.SleepCheck("halberd")
                    && me.Distance2D(e) <= 700
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(halberd.Name)
                    )
                {
                    halberd.UseAbility(e);
                    Utils.Sleep(250, "halberd");
                }
                if ( // Satanic
                    satanic != null &&
                    me.Health <= (me.MaximumHealth * 0.3) &&
                    satanic.CanBeCasted() &&
                    me.Distance2D(e) <= me.AttackRange + 50
                    && Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(satanic.Name)
                    && Utils.SleepCheck("satanic")
                    )
                {
                    satanic.UseAbility();
                    Utils.Sleep(240, "satanic");
                } // Satanic Item end
                if (mail != null && mail.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                           (Menu.Item("Heelm").GetValue<Slider>().Value)) &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(mail.Name) && Utils.SleepCheck("mail"))
                {
                    mail.UseAbility();
                    Utils.Sleep(100, "mail");
                }
                if (bkb != null && bkb.CanBeCasted() && (v.Count(x => x.Distance2D(me) <= 650) >=
                                                         (Menu.Item("Heel").GetValue<Slider>().Value)) &&
                    Menu.Item("Items").GetValue<AbilityToggler>().IsEnabled(bkb.Name) && Utils.SleepCheck("bkb"))
                {
                    bkb.UseAbility();
                    Utils.Sleep(100, "bkb");
                }
            }
            OnTimedEvent();
        }
		//public readonly Menu farm = new Menu("FarmMode", "FarmMode");
		

		public void Combo()
		{
			if (me == null || me.ClassID != ClassID.CDOTA_Unit_Hero_Meepo || !Game.IsInGame) return;
            if(!me.IsAlive) return;

            activated = Game.IsKeyDown(Menu.Item("keyBind").GetValue<KeyBind>().Key);
            PoofKey = Game.IsKeyDown(Menu.Item("poofKey").GetValue<KeyBind>().Key);
            PoofAutoMode = Menu.Item("poofAutoMod").GetValue<KeyBind>().Active;
            SafePoof = Menu.Item("poofSafe").IsActive();
            dodge = Menu.Item("Dodge").GetValue<KeyBind>().Active;
            var checkObj = ObjectManager.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_BaseNPC_Creep_Lane
                        || x.ClassID == ClassID.CDOTA_BaseNPC_Creep_Siege
                        || x.ClassID == ClassID.CDOTA_BaseNPC_Creep
                        || x.ClassID == ClassID.CDOTA_BaseNPC_Creep_Neutral
                        || x.HasInventory
                        || x.ClassID == ClassID.CDOTA_Unit_SpiritBear) && x.IsAlive && x.Team != me.Team && x.IsValid).ToList();
            var meepos = ObjectManager.GetEntities<Hero>().Where(x => x.IsControllable && x.IsAlive && x.ClassID == ClassID.CDOTA_Unit_Hero_Meepo).ToList();





            List<Unit> fount = ObjectManager.GetEntities<Unit>().Where(x => x.Team == me.Team && x.ClassID == ClassID.CDOTA_Unit_Fountain).ToList();
            //blink = me.FindItem("item_blink");



            e = ObjectManager.GetEntities<Hero>()
                        .Where(x => x.IsAlive && x.Team != me.Team && !x.IsIllusion)
                        .OrderBy(x => GetDistance2D(x.Position, meepos.OrderBy(y => GetDistance2D(x.Position, y.Position)).FirstOrDefault().Position))
                        .FirstOrDefault();


            /**************************************************DODGE*************************************************************/

            var f = ObjectManager.GetEntities<Hero>()
                        .Where(x => x.IsAlive && x.Team == me.Team && !x.IsIllusion && x.IsControllable && x.ClassID == ClassID.CDOTA_Unit_Hero_Meepo)
                        .OrderBy(x => GetDistance2D(x.Position, fount.OrderBy(y => GetDistance2D(x.Position, y.Position)).FirstOrDefault().Position))
                        .FirstOrDefault();
		    var meeposCount = meepos.Count();
            Ability[] q = new Ability[meeposCount];
            for (int i = 0; i < meeposCount; ++i) q[i] = meepos[i].Spellbook.SpellQ;
            Ability[] w = new Ability[meeposCount];
            for (int i = 0; i < meeposCount; ++i) w[i] = meepos[i].Spellbook.SpellW;
            if (dodge && me.IsAlive)
            {
                var baseDota =
                  ObjectManager.GetEntities<Unit>().Where(unit => unit.Name == "npc_dota_base" && unit.Team != me.Team).ToList();
                if (baseDota != null)
                {
                    for (int t = 0; t < baseDota.Count(); ++t)
                    {
                        for (int i = 0; i < meeposCount; ++i)
                        {
                            float angle = meepos[i].FindAngleBetween(baseDota[t].Position, true);
                            Vector3 pos = new Vector3((float)(baseDota[t].Position.X - 710 * Math.Cos(angle)), (float)(baseDota[t].Position.Y - 710 * Math.Sin(angle)), 0);
                            if (meepos[i].Distance2D(baseDota[t]) <= 700 && !meepos[i].HasModifier("modifier_bloodseeker_rupture") && Utils.SleepCheck(meepos[i].Handle + "MoveDodge"))
                            {
                                meepos[i].Move(pos);
                                Utils.Sleep(120, meepos[i].Handle + "MoveDodge");
                                //	Console.WriteLine("Name: " + baseDota[t].Name);
                                //	Console.WriteLine("Speed: " + baseDota[t].Speed);
                                //	Console.WriteLine("ClassID: " + baseDota[t].ClassID);
                                //	Console.WriteLine("Handle: " + baseDota[t].Handle);
                                //	Console.WriteLine("UnitState: " + baseDota[t].UnitState);
                            }
                        }
                    }
                }

                var thinker =
                   ObjectManager.GetEntities<Unit>().Where(unit => unit.Name == "npc_dota_thinker" && unit.Team != me.Team).ToList();
                if (thinker != null)
                {
                    for (int i = 0; i < thinker.Count(); ++i)
                    {
                        for (int j = 0; j < meeposCount; ++j)
                        {
                            float angle = meepos[j].FindAngleBetween(thinker[i].Position, true);
                            Vector3 pos = new Vector3((float)(thinker[i].Position.X - 360 * Math.Cos(angle)), (float)(thinker[i].Position.Y - 360 * Math.Sin(angle)), 0);
                            if (meepos[j].Distance2D(thinker[i]) <= 350 && !meepos[j].HasModifier("modifier_bloodseeker_rupture"))
                            {

                                if (Utils.SleepCheck(meepos[j].Handle + "MoveDodge"))
                                {
                                    meepos[j].Move(pos);
                                    Utils.Sleep(350, meepos[j].Handle + "MoveDodge");
                                }

                            }
                        }
                    }
                }
                foreach (var v in meepos)
                {
                    if (Utils.SleepCheck(v.Handle + "_move") && v.Health <= v.MaximumHealth / 100 * Menu.Item("healh").GetValue<Slider>().Value
                        && !v.HasModifier("modifier_bloodseeker_rupture")
                        && v.Distance2D(fount.First().Position) >= 1000
                        )
                    {
                        v.Move(fount.First().Position);
                        Utils.Sleep(300, v.Handle + "_move");
                    }
                    if (activated)
                    {
                        float angle = v.FindAngleBetween(fount.First().Position, true);
                        Vector3 pos = new Vector3((float)(fount.First().Position.X - 500 * Math.Cos(angle)), (float)(fount.First().Position.Y - 500 * Math.Sin(angle)), 0);

                        if (
                            v.Health >= v.MaximumHealth * 0.58
                            && v.Distance2D(fount.First()) <= 400
                            && me.Team == Team.Radiant
                            && Utils.SleepCheck(v.Handle + "RadMove")
                            )
                        {
                            v.Move(pos);
                            Utils.Sleep(400, v.Handle + "RadMove");
                        }
                        if (
                            v.Health >= v.MaximumHealth * 0.58
                            && v.Distance2D(fount.First()) <= 400
                            && me.Team == Team.Dire
                            && Utils.SleepCheck(v.Handle + "DireMove")
                            )
                        {
                            v.Move(pos);
                            Utils.Sleep(400, v.Handle + "DireMove");
                        }
                    }
                }

                for (int i = 0; i < meeposCount; ++i)
                {
                    travel = meepos[i].FindItem("item_travel_boots") ?? meepos[i].FindItem("item_travel_boots_2");
                    if (w[i] != null
                        && w[i].CanBeCasted()
                        && meepos[i].Health <= meepos[i].MaximumHealth
                        / 100 * Menu.Item("healh").GetValue<Slider>().Value
                        && meepos[i].Handle != f.Handle
                        && meepos[i].Distance2D(f) >= 700
                        && e == null
                        && meepos[i].Distance2D(fount.First().Position) >= 1500
                        && Utils.SleepCheck(meepos[i].Handle + "W"))
                    {
                        w[i].UseAbility(f);
                        Utils.Sleep(1000, meepos[i].Handle + "W");
                    }
                    else if (
                        travel != null
                        && travel.CanBeCasted()
                        && meepos[i].Health <= meepos[i].MaximumHealth
                        / 100 * Menu.Item("healh").GetValue<Slider>().Value
                       && (!w[i].CanBeCasted()
                       || meepos[i].Position.Distance2D(f) >= 1000
                       || (w[i].CanBeCasted()
                       && f.Distance2D(fount.First()) >= 1500))
                       || (meepos[i].IsSilenced()
                       || meepos[i].MovementSpeed <= 280)
                       && meepos[i].Distance2D(fount.First().Position) >= 1500
                       && e == null
                       && Utils.SleepCheck(meepos[i].Handle + "travel"))
                    {
                        travel.UseAbility(fount.First().Position);
                        Utils.Sleep(1000, meepos[i].Handle + "travel");
                    }
                    if (meepos[i].HasModifier("modifier_bloodseeker_rupture"))
                    {

                        if (w[i] != null
                            && w[i].CanBeCasted()
                            && meepos[i].Handle != f.Handle
                            && Utils.SleepCheck(meepos[i].Handle + "W"))
                        {
                            w[i].UseAbility(f);
                            Utils.Sleep(500, meepos[i].Handle + "W");
                        }
                        else if (travel != null && travel.CanBeCasted()
                                 && !w[i].CanBeCasted()
                                 && meepos[i].Distance2D(fount.First().Position) >= 1200
                                 && Utils.SleepCheck(meepos[i].Handle + "travel"))
                        {
                            travel.UseAbility(fount.First().Position);
                            Utils.Sleep(1000, meepos[i].Handle + "travel");
                        }
                    }
                    if (e != null
                        && q[i] != null
                        && meepos[i].Health <= meepos[i].MaximumHealth
                        / 100 * Menu.Item("healh").GetValue<Slider>().Value
                        && q[i].CanBeCasted()
                        && e.Modifiers.Any(y => y.Name != "modifier_meepo_earthbind")
                        && !e.IsMagicImmune()
                        && meepos[i].Distance2D(e) <= q[i].GetCastRange() - 50
                        && Utils.SleepCheck(meepos[i].Handle + "_net_casting"))
                    {
                        q[i].CastSkillShot(e);
                        Utils.Sleep(q[i].GetCastDelay(meepos[i], e, true) + 500, meepos[i].Handle + "_net_casting");
                    }
                    else if (!q[i].CanBeCasted() && meepos[i].Health <= meepos[i].MaximumHealth / 100 * Menu.Item("healh").GetValue<Slider>().Value)
                    {
                        for (var j = 0; j < meeposCount; ++j)
                        {
                            if (e != null
                                && q[j] != null
                                && meepos[i].Handle != meepos[j].Handle
                                && meepos[j].Position.Distance2D(e) < q[i].GetCastRange()
                                && e.Modifiers.Any(y => y.Name != "modifier_meepo_earthbind")
                                && meepos[j].Position.Distance2D(meepos[i]) < q[j].GetCastRange()
                                && !e.IsMagicImmune()
                                && Utils.SleepCheck(meepos[i].Handle + "_net_casting"))
                            {
                                q[j].CastSkillShot(e);
                                Utils.Sleep(q[j].GetCastDelay(meepos[j], e, true) + 1500, meepos[i].Handle + "_net_casting");
                                break;
                            }
                        }
                    }
                    if (e != null
                        && w[i] != null
                        && w[i].CanBeCasted()
                        && meepos[i].Health <= meepos[i].MaximumHealth
                        / 100 * Menu.Item("healh").GetValue<Slider>().Value
                        && meepos[i].Handle != f.Handle && meepos[i].Distance2D(f) >= 700
                        && (meepos[i].Distance2D(e) >= (e.AttackRange + 60)
                        || meepos[i].MovementSpeed <= 290)
                        && (q == null || (!q[i].CanBeCasted()
                        || e.HasModifier("modifier_meepo_earthbind")
                        || !e.IsMagicImmune()) || meepos[i].Distance2D(e) >= 1000)
                        && meepos[i].Distance2D(fount.First().Position) >= 1100
                        && Utils.SleepCheck(meepos[i].Handle + "W"))
                    {
                        w[i].UseAbility(f);
                        Utils.Sleep(1000, meepos[i].Handle + "W");
                    }
                    else if (
                            e != null
                            && travel != null
                            && travel.CanBeCasted()
                            && meepos[i].Health <= meepos[i].MaximumHealth
                            / 100 * Menu.Item("healh").GetValue<Slider>().Value
                            && (!w[i].CanBeCasted()
                            || meepos[i].Position.Distance2D(f) >= 1000
                            || (w[i].CanBeCasted()
                            && f.Distance2D(fount.First()) >= 2000))
                            && (meepos[i].Distance2D(e) >= (e.AttackRange + 60)
                            || (meepos[i].IsSilenced()
                            || meepos[i].MovementSpeed <= 290))
                            && meepos[i].Distance2D(fount.First().Position) >= 1100
                            && Utils.SleepCheck(meepos[i].Handle + "travel"))
                    {
                        travel.UseAbility(fount.First().Position);
                        Utils.Sleep(1000, meepos[i].Handle + "travel");
                    }
                }
            }
            /**************************************************DODGE*************************************************************/
            /***************************************************POOF*************************************************************/
            if (PoofKey)
            {
                for (int i = 0; i < meeposCount; ++i)
                {
                    for (int j = 0; j < checkObj.Count(); ++j)
                    {
                        if (w[i] != null
                            && ((meepos[i].Distance2D(checkObj[j]) <= 365
                            && SafePoof)
                            || (!SafePoof))
                            && w[i].CanBeCasted()
                            && (meepos[i].Health >= meepos[i].MaximumHealth
                            / 100 * Menu.Item("healh").GetValue<Slider>().Value
                            || !dodge)
                            && Utils.SleepCheck(meepos[i].Handle + "Wpos"))
                        {
                            w[i].UseAbility(meepos[i]);
                            Utils.Sleep(250, meepos[i].Handle + "Wpos");
                        }
                    }
                }
            }



            if (PoofAutoMode)
            {
                for (int i = 0; i < meeposCount; i++)
                {
                    var nCreeps = ObjectManager.GetEntities<Unit>().Where(x => (x.ClassID == ClassID.CDOTA_BaseNPC_Creep_Lane
                        || x.ClassID == ClassID.CDOTA_BaseNPC_Creep_Siege
                        || x.ClassID == ClassID.CDOTA_BaseNPC_Creep
                        || x.ClassID == ClassID.CDOTA_BaseNPC_Creep_Neutral) && x.Team != me.Team && x.IsSpawned && x.IsAlive).Where(x => x.Distance2D(meepos[i]) <= 345).ToList().Count();

                    SliderCountUnit = nCreeps >= (skills.Item("poofCount").GetValue<Slider>().Value);

                    if (SliderCountUnit
                        && w[i] != null
                        && w[i].CanBeCasted()
                        && meepos[i].CanCast()
                        && meepos[i].Health >= meepos[i].MaximumHealth
                        / 100 * Menu.Item("healh").GetValue<Slider>().Value - 0.05
                        && meepos[i].Mana >= (meepos[i].MaximumMana
                        / 100 * Menu.Item("mana").GetValue<Slider>().Value)
                        && Utils.SleepCheck(meepos[i].Handle + "Wpos"))
                    {
                        w[i].UseAbility(meepos[i]);
                        Utils.Sleep(250, meepos[i].Handle + "Wpos");
                    }
                }
            }
            /***************************************************POOF*************************************************************/
            /**************************************************COMBO*************************************************************/
            if (activated)
            {
                for (int i = 0; i < meeposCount; ++i)
                {
                    e = ClosestToMouse(meepos[i]);

                    if (e == null) return;
                    initMeepo = GetClosestToTarget(meepos, e);


                    if (
                    w[i] != null
                    && meepos[i].CanCast()
                    && (
                        meepos[i].Handle != f.Handle && f.HasModifier("modifier_fountain_aura_buff")
                        || meepos[i].Handle == f.Handle && !f.HasModifier("modifier_fountain_aura_buff")
                        )
                    && meepos.Count(x => x.Distance2D(meepos[i]) <= 1000) > 1
                    && meepos[i].Health >= meepos[i].MaximumHealth * 0.8
                    && w[i].CanBeCasted()
                    && initMeepo.Distance2D(e) <= 350
                    && Utils.SleepCheck(meepos[i].Handle + "poof")
                    )
                    {
                        w[i].UseAbility(e.Position);
                        Utils.Sleep(250, meepos[i].Handle + "poof");
                    }

                    if (me.HasModifier("modifier_fountain_aura_buff"))
                    {
                        if (
                            me.Spellbook.SpellW != null
                            && me.Spellbook.SpellW.CanBeCasted()
                            && me.Health >= me.MaximumHealth * 0.8
                            && meepos.Count(x => x.Distance2D(me) <= 1000) > 1
                            && initMeepo.Distance2D(e) <= 350
                            && Utils.SleepCheck(me.Handle + "pooff")
                            )
                        {
                            me.Spellbook.SpellW.UseAbility(e.Position);
                            Utils.Sleep(250, me.Handle + "pooff");
                        }
                    }
                    //	
                    /*int[] cool;
					var core = me.FindItem("item_octarine_core");
					if (core !=null)
						cool = new int[4] { 20, 16, 12, 8 };
					else
						cool = new int[4] { 15, 12, 9, 6 };*/

                    orchid = me.FindItem("item_orchid") ?? me.FindItem("item_bloodthorn");
                    blink = meepos[i].FindItem("item_blink");
                    sheep = e.ClassID == ClassID.CDOTA_Unit_Hero_Tidehunter ? null : me.FindItem("item_sheepstick");


                    if ( // sheep
                    sheep != null
                    && sheep.CanBeCasted()
                    && me.CanCast()
                    && !e.IsLinkensProtected()
                    && !e.IsMagicImmune()
                    && me.Distance2D(e) <= 900
                    && meepos[i].Distance2D(e) <= 350
                    && Utils.SleepCheck("sheep")
                    )
                    {
                        sheep.UseAbility(e);
                        Utils.Sleep(250, "sheep");
                    } // sheep Item end

                    if ( // Medall
                    medall != null
                    && medall.CanBeCasted()
                    && Utils.SleepCheck("Medall")
                    && meepos[i].Distance2D(e) <= 300
                    && me.Distance2D(e) <= 700
                    )
                    {
                        medall.UseAbility(e);
                        Utils.Sleep(250, "Medall");
                    } // Medall Item end
                    if ( // orchid
                        orchid != null
                        && orchid.CanBeCasted()
                        && me.CanCast()
                        && !e.IsLinkensProtected()
                        && !e.IsMagicImmune()
                        && meepos[i].Distance2D(e) <= 300
                        && me.Distance2D(e) <= 900
                        && Utils.SleepCheck("orchid")
                        )
                    {
                        orchid.UseAbility(e);
                        Utils.Sleep(250, "orchid");
                    } // orchid Item end
                    if (Utils.SleepCheck("Q")
                        && !e.HasModifier("modifier_meepo_earthbind")
                        && (((!blink.CanBeCasted()
                        || blink == null)
                        && meepos[i].Distance2D(e) <= q[i].GetCastRange())
                        || (blink.CanBeCasted()
                        && meepos[i].Distance2D(e) <= 350))
                        )
                    {
                        if (q[i] != null
                            && (meepos[i].Health >= meepos[i].MaximumHealth
                            / 100 * Menu.Item("healh").GetValue<Slider>().Value
                            || !dodge)
                            && q[i].CanBeCasted()
                            && !e.IsMagicImmune()
                             && !meepos[i].IsChanneling()
                             && meepos[i].Distance2D(e) <= q[i].GetCastRange()
                             && Utils.SleepCheck(meepos[i].Handle + "_net_casting"))
                        {
                            q[i].CastSkillShot(e);
                            Utils.Sleep(q[i].GetCastDelay(meepos[i], e, true) + 1500, meepos[i].Handle + "_net_casting");
                            Utils.Sleep(1500, "Q");
                        }
                    }

                    if (
                        blink != null
                        && me.CanCast()
                        && blink.CanBeCasted()
                        && me.Distance2D(e) >= 350
                        && me.Distance2D(e) <= 1150
                        )
                    {
                        if (blink.CanBeCasted()
                               && !Menu.Item("blinkDelay").IsActive()
                               && meepos[i].Health >= meepos[i].MaximumHealth / 100 * Menu.Item("healh").GetValue<Slider>().Value
                               && Utils.SleepCheck("13"))
                        {
                            blink.UseAbility(e.Position);
                            Utils.Sleep(200, "13");
                        }

                        Task.Delay(1340 - (int)Game.Ping).ContinueWith(_ =>
                        {
                            if (blink.CanBeCasted()
                            && Menu.Item("blinkDelay").IsActive()
                            && Utils.SleepCheck("12"))
                            {
                                blink.UseAbility(e.Position);
                                Utils.Sleep(200, "12");
                            }
                        });
                        for (int j = 0; j < meeposCount; ++j)
                        {
                            if (
                            w[j] != null
                            && meepos[j].Handle != me.Handle
                            && meepos[j].CanCast()
                            && ((f.Handle != meepos[j].Handle && f.HasModifier("modifier_fountain_aura_buff")
                            || !f.HasModifier("modifier_fountain_aura_buff"))
                            )
                            && meepos[j].Health >= meepos[j].MaximumHealth / 100 * Menu.Item("healh").GetValue<Slider>().Value
                            && !e.IsMagicImmune()
                            && w[j].CanBeCasted()
                            && Utils.SleepCheck(meepos[j].Handle + "poof")
                            )
                            {
                                w[j].UseAbility(e.Position);
                                Utils.Sleep(250, meepos[j].Handle + "poof");
                            }
                        }
                    }
                    if (
                       meepos[i].Distance2D(e) <= 200 && (!meepos[i].IsAttackImmune() || !e.IsAttackImmune())
                       && meepos[i].NetworkActivity != NetworkActivity.Attack && meepos[i].CanAttack()
                       && meepos[i].Health >= meepos[i].MaximumHealth / 100 * Menu.Item("healh").GetValue<Slider>().Value
                       && !meepos[i].IsChanneling() 
                       && Utils.SleepCheck(meepos[i].Handle + "Attack")
                       )
                    {
                        meepos[i].Attack(e);
                        Utils.Sleep(180, meepos[i].Handle + "Attack");
                    }
                    else if (((
                       (!meepos[i].CanAttack()
                       || meepos[i].Distance2D(e) >= 0)
                       && meepos[i].NetworkActivity != NetworkActivity.Attack
                       && meepos[i].Distance2D(e) <= 1000))
                       && ((meepos[i].Handle != me.Handle
                       && (blink != null && blink.CanBeCasted()
                       && me.Distance2D(e) <= 350)
                       || (meepos[i].Handle == me.Handle
                       && !blink.CanBeCasted()))
                       || blink == null)
                       && meepos[i].Health >= meepos[i].MaximumHealth / 100 * Menu.Item("healh").GetValue<Slider>().Value
                       && !meepos[i].IsChanneling()
                       && Utils.SleepCheck(meepos[i].Handle + "Move"))
                    {
                        meepos[i].Move(e.Predict(450));
                        Utils.Sleep(250, meepos[i].Handle + "Move");
                    }


                }

                vail = me.FindItem("item_veil_of_discord");
                shiva = me.FindItem("item_shivas_guard");
                medall = me.FindItem("item_medallion_of_courage") ?? me.FindItem("item_solar_crest");
                atos = me.FindItem("item_rod_of_atos");
                cheese = me.FindItem("item_cheese");
                abyssal = me.FindItem("item_abyssal_blade");
                dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));
                ethereal = me.FindItem("item_ethereal_blade");

                e = Toolset.ClosestToMouse(me);
                if (e == null) return;
                if ( // ethereal
                    ethereal != null
                    && ethereal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsLinkensProtected()
                    && !e.IsMagicImmune()
                    && Utils.SleepCheck("ethereal")
                    )
                {
                    ethereal.UseAbility(e);
                    Utils.Sleep(200, "ethereal");
                } // ethereal Item end
                if (// Dagon
                    me.CanCast()
                    && dagon != null
                    && (ethereal == null
                    || (e.HasModifier("modifier_item_ethereal_blade_slow")
                    || ethereal.Cooldown < 17))
                    && !e.IsLinkensProtected()
                    && dagon.CanBeCasted()
                    && !e.IsMagicImmune()
                    && Utils.SleepCheck("dagon")
                    )
                {
                    dagon.UseAbility(e);
                    Utils.Sleep(200, "dagon");
                } // Dagon Item end
                if ( // vail
                    vail != null
                    && vail.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && me.Distance2D(e) <= 1100
                    && Utils.SleepCheck("vail")
                    )
                {
                    vail.UseAbility(e.Position);
                    Utils.Sleep(250, "vail");
                } // orchid Item end
                if (// Shiva Item
                    shiva != null
                    && shiva.CanBeCasted()
                    && me.CanCast()
                    && !e.IsMagicImmune()
                    && Utils.SleepCheck("shiva")
                    && me.Distance2D(e) <= 600
                    )
                {
                    shiva.UseAbility();
                    Utils.Sleep(250, "shiva");
                } // Shiva Item end
                if (
                    // cheese
                    cheese != null
                    && cheese.CanBeCasted()
                    && me.Health <= (me.MaximumHealth * 0.3)
                    && me.Distance2D(e) <= 700
                    && Utils.SleepCheck("cheese")
                    )
                {
                    cheese.UseAbility();
                    Utils.Sleep(200, "cheese");
                } // cheese Item end

                if ( // atos Blade
                    atos != null
                    && atos.CanBeCasted()
                    && me.CanCast()
                    && !e.IsLinkensProtected()
                    && !e.IsMagicImmune()
                    && me.Distance2D(e) <= 2000
                    && Utils.SleepCheck("atos")
                    )
                {
                    atos.UseAbility(e);
                    Utils.Sleep(250, "atos");
                } // atos Item end
                if ( // Abyssal Blade
                    abyssal != null
                    && abyssal.CanBeCasted()
                    && me.CanCast()
                    && !e.IsStunned()
                    && !e.IsHexed()
                    && Utils.SleepCheck("abyssal")
                    && me.Distance2D(e) <= 300
                    )
                {
                    abyssal.UseAbility(e);
                    Utils.Sleep(250, "abyssal");
                } // Abyssal Item end
            }
        }