Beispiel #1
0
 private void Fight(string mode)
 {
     if (GetValue <bool>(mode, "P") && HaveP && Orbwalk.GetBestHeroTarget != null && Orbwalk.CanAttack)
     {
         return;
     }
     if (GetValue <bool>(mode, "Q") && Q.IsReady())
     {
         if (IsQ)
         {
             var target = Q.GetTarget();
             if (target != null)
             {
                 var pred = Q.GetPrediction(target);
                 if (pred.Hitchance >= HitChance.High && Q.Cast(pred.CastPosition, PacketCast))
                 {
                     return;
                 }
                 if (GetValue <bool>(mode, "QCol") && pred.Hitchance == HitChance.Collision &&
                     pred.CollisionObjects.Count(IsMinion) == 1 && CastSmite(pred.CollisionObjects.First()) &&
                     Q.Cast(pred.CastPosition, PacketCast))
                 {
                     return;
                 }
             }
         }
         else
         {
             var target = Q2.GetTarget(0, HeroManager.Enemies.Where(i => !HaveQ(i)));
             if (target != null &&
                 (QAgain(target) ||
                  ((target.HasBuffOfType(BuffType.Knockback) || target.HasBuffOfType(BuffType.Knockup)) &&
                   Player.Distance(target) > 300 && !R.IsReady()) || Q.IsKillable(target, 1) ||
                  !Orbwalk.InAutoAttackRange(target, 100) || !HaveP) && Q2.Cast(PacketCast))
             {
                 return;
             }
             if (target == null)
             {
                 var sub = Q2.GetTarget();
                 if (sub != null && ObjHaveQ.Any(i => i.Distance(sub) < Player.Distance(sub)) &&
                     Q2.Cast(PacketCast))
                 {
                     return;
                 }
             }
         }
     }
     if (GetValue <bool>(mode, "E") && E.IsReady())
     {
         if (IsE)
         {
             if (E.GetTarget() != null && E.Cast(PacketCast))
             {
                 return;
             }
         }
         else if (
             HeroManager.Enemies.Where(i => i.IsValidTarget(E2.Range) && HaveE(i))
             .Any(i => EAgain(i) || !Orbwalk.InAutoAttackRange(i, 50) || !HaveP) && E2.Cast(PacketCast))
         {
             return;
         }
     }
     if (GetValue <bool>(mode, "R") && R.IsReady() && GetValue <bool>(mode, "Q") && Q.IsReady() && !IsQ)
     {
         var target = R.GetTarget(0, HeroManager.Enemies.Where(i => !HaveQ(i)));
         if (target != null && CanKill(target, GetQ2Dmg(target, R.GetDamage(target))) &&
             R.CastOnUnit(target, PacketCast))
         {
             return;
         }
     }
     if (GetValue <bool>(mode, "W") && W.IsReady() && Orbwalk.GetBestHeroTarget != null)
     {
         if (IsW)
         {
             if (!HaveP && !Q.IsReady() && !E.IsReady() && Player.HealthPercent < 50)
             {
                 W.Cast(PacketCast);
             }
         }
         else if (!Player.HasBuff("BlindMonkSafeguard") &&
                  (Player.HealthPercent < GetValue <Slider>(mode, "WHpU").Value || !HaveP))
         {
             W2.Cast(PacketCast);
         }
     }
 }
Beispiel #2
0
        protected override void Farming()
        {
            bool useQ = RootMenu["farming"]["lane"]["useQ"].Enabled;
            bool useW = RootMenu["farming"]["lane"]["useE"].Enabled;

            if (useQ)
            {
                if (Q.Ready)
                {
                    foreach (var minion in Bases.Extensions.GetEnemyLaneMinionsTargetsInRange(Q.Range))
                    {
                        if (minion.IsValidTarget(Q.Range) && minion != null)
                        {
                            if (!Player.HasBuff("RekSaiW"))
                            {
                                if (GameObjects.EnemyMinions.Count(h => h.IsValidTarget(Q.Range, false, false,
                                                                                        Player.ServerPosition)) >= RootMenu["farming"]["lane"]["hitQ"]
                                    .As <MenuSlider>().Value)
                                {
                                    Q.Cast();
                                }
                            }
                        }
                    }
                }
            }
            if (useW)
            {
                if (E.Ready)
                {
                    if (RootMenu["farming"]["lane"]["lastE"].Enabled)
                    {
                        foreach (var minion in Bases.Extensions.GetEnemyLaneMinionsTargetsInRange(E.Range))
                        {
                            if (minion.IsValidTarget(E.Range) && minion != null)
                            {
                                if (!Player.HasBuff("RekSaiW"))
                                {
                                    if (Player.GetSpellDamage(minion, SpellSlot.E) >= minion.Health)
                                    {
                                        E.Cast(minion);
                                    }
                                }
                            }
                        }
                    }
                    if (!RootMenu["farming"]["lane"]["lastE"].Enabled)
                    {
                        foreach (var minion in Bases.Extensions.GetEnemyLaneMinionsTargetsInRange(E.Range))
                        {
                            if (minion.IsValidTarget(E.Range) && minion != null)
                            {
                                if (!Player.HasBuff("RekSaiW"))
                                {
                                    E.Cast(minion);
                                }
                            }
                        }
                    }
                }
            }


            foreach (var jungleTarget in Bases.GameObjects.JungleLarge.Where(m => m.IsValidTarget(Q2.Range))
                     .ToList())
            {
                if (!jungleTarget.IsValidTarget() || jungleTarget.UnitSkinName.Contains("Plant"))
                {
                    return;
                }

                bool useQs = RootMenu["farming"]["jungle"]["useQ"].Enabled;
                bool useWs = RootMenu["farming"]["jungle"]["useW"].Enabled;
                bool useEs = RootMenu["farming"]["jungle"]["useE"].Enabled;



                if (Player.HasBuff("RekSaiW"))
                {
                    if (useQs && Q2.Ready && jungleTarget.IsValidTarget(Q2.Range))
                    {
                        Q2.Cast(jungleTarget);
                    }
                    if (useWs && W2.Ready && jungleTarget.IsValidTarget(W2.Range))
                    {
                        W2.Cast();
                    }
                }
                if (!Player.HasBuff("RekSaiW"))
                {
                    if (useQs && Q.Ready && jungleTarget.IsValidTarget(Q.Range))
                    {
                        Q.Cast();
                    }
                    if (useEs && E.Ready && jungleTarget.IsValidTarget(E.Range))
                    {
                        E.Cast(jungleTarget);
                    }
                    if (useWs && W.Ready && jungleTarget.IsValidTarget(W.Range) &&
                        !jungleTarget.HasBuff("RekSaiKnockupImmune"))
                    {
                        if (!Orbwalker.Implementation.IsWindingUp)
                        {
                            W.Cast();
                        }
                    }
                }
            }

            foreach (var jungleTarget in Bases.GameObjects.Jungle.Where(m => m.IsValidTarget(Q2.Range)).ToList())
            {
                if (!jungleTarget.IsValidTarget() || jungleTarget.UnitSkinName.Contains("Plant"))
                {
                    return;
                }

                bool useQs = RootMenu["farming"]["jungle"]["useQ"].Enabled;
                bool useWs = RootMenu["farming"]["jungle"]["useW"].Enabled;
                bool useEs = RootMenu["farming"]["jungle"]["useE"].Enabled;



                if (Player.HasBuff("RekSaiW"))
                {
                    if (useQs && Q2.Ready && jungleTarget.IsValidTarget(Q2.Range))
                    {
                        Q2.Cast(jungleTarget);
                    }
                    if (useWs && W2.Ready && jungleTarget.IsValidTarget(W2.Range))
                    {
                        W2.Cast();
                    }
                }
                if (!Player.HasBuff("RekSaiW"))
                {
                    if (useQs && Q.Ready && jungleTarget.IsValidTarget(Q.Range))
                    {
                        Q.Cast();
                    }
                    if (useEs && E.Ready && jungleTarget.IsValidTarget(E.Range))
                    {
                        E.Cast(jungleTarget);
                    }
                    if (useWs && W.Ready && jungleTarget.IsValidTarget(W.Range) &&
                        !jungleTarget.HasBuff("RekSaiKnockupImmune") && !Player.HasBuff("RekSaiQ"))
                    {
                        W.Cast();
                    }
                }
            }
        }
Beispiel #3
0
        static void JungleClear()
        {
            var JungleMinions = MinionManager.GetMinions(Player.ServerPosition, W.Range, MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth);

            if (JungleMinions.Count >= 1)
            {
                foreach (var Mob in JungleMinions)
                {
                    if (Human())
                    {
                        if (Option_Item("Jungle R") && R.IsReady())
                        {
                            if (!Q.IsReady() && !W.IsReady())
                            {
                                if ((_spideQcd == 0 && _spideWcd <= 1.8f) || _humaQcd >= 1.2f)
                                {
                                    R.Cast(true);
                                }
                            }
                        }

                        if (Player.ManaPercent >= Option.Item("JMana").GetValue <Slider>().Value)
                        {
                            if (Option_Item("Human Jungle W") && W.IsReady())
                            {
                                MinionManager.FarmLocation Mobs = W.GetCircularFarmLocation(JungleMinions);
                                if (JungleMinions.Count == 4)
                                {
                                    if (Mobs.MinionsHit >= 3)
                                    {
                                        W.Cast(Mobs.Position, true);
                                    }
                                }
                                if (JungleMinions.Count == 3)
                                {
                                    if (Mobs.MinionsHit >= 2)
                                    {
                                        W.Cast(Mobs.Position, true);
                                    }
                                }
                                ;
                                if (JungleMinions.Count <= 2)
                                {
                                    W.Cast(Mob.Position, true);
                                }

                                if (JungleMinions.Count == 0)
                                {
                                    return;
                                }
                            }

                            if (Option_Item("Human Jungle Q") && Q.IsReady())
                            {
                                Q.CastOnUnit(Mob, true);
                            }
                        }
                    }

                    if (Spider())
                    {
                        if (Option_Item("Jungle R") && R.IsReady())
                        {
                            if (!Q2.IsReady() && !W2.IsReady() && !Player.HasBuff("EliseSpiderW") && Player.ManaPercent >= Option.Item("JMana").GetValue <Slider>().Value)
                            {
                                if ((_humaQcd == 0 && _humaWcd <= 1.5f) && (_spideQcd >= 1.4f || _spideWcd >= 1.8f) && (JungleMinions.Count == 1 && Mob.Health >= Q.GetDamage(Mob) || Mob.Health >= W.GetDamage(Mob)))
                                {
                                    R.Cast(true);
                                }
                            }
                        }

                        if (Option_Item("Spider Jungle Q") && Q.IsReady())
                        {
                            Q.CastOnUnit(Mob, true);
                        }

                        if (Option_Item("Spider Jugnle W") && W2.IsReady())
                        {
                            var JungleMinion = MinionManager.GetMinions(Player.ServerPosition, 150, MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth);
                            if (!Orbwalking.CanAttack() && Orbwalking.CanMove(10))
                            {
                                if (JungleMinion != null)
                                {
                                    W2.Cast(true);
                                }
                            }
                        }
                    }
                }
            }

            if (JungleMinions == null)
            {
                return;
            }
        }
Beispiel #4
0
        /// <summary>
        /// Put in here what you want to do when the mode is running
        /// </summary>
        public static void Execute()

        {
            var minion = EntityManager.MinionsAndMonsters.GetJungleMonsters(null, Q.Range).FirstOrDefault();

            if (minion == null)
            {
                return;
            }

            if (JungleClearMenu.GetCheckBoxValue("Jpassive"))
            {
                if (PassiveStacks > 0 || LastSpell + 400 > Environment.TickCount)
                {
                    return;
                }
            }

            if (E.IsReady() && JungleClearMenu.GetCheckBoxValue("eUse"))
            {
                if (EState && E.IsInRange(minion))
                {
                    E.Cast();
                    LastSpell = Environment.TickCount;
                }

                if (!EState && E.IsInRange(minion) && LastE + 400 < Environment.TickCount)
                {
                    E.Cast();
                    LastSpell = Environment.TickCount;
                }
            }

            if (Q.IsReady() && JungleClearMenu.GetCheckBoxValue("qUse"))
            {
                Q.Cast(minion);
                LastSpell = Environment.TickCount;

                foreach (var jungleMobs in ObjectManager.Get <Obj_AI_Minion>().Where(o => o.IsValidTarget(Q.Range) && o.Team == GameObjectTeam.Neutral && o.IsVisible && !o.IsDead))
                {
                    if (EntityManager.MinionsAndMonsters.GetJungleMonsters(null, Q.Range).Any())
                    {
                        if (jungleMobs.HasQBuff())
                        {
                            Q2.Cast();
                            LastSpell = Environment.TickCount;
                        }
                    }
                }
            }

            if (W.IsReady() && JungleClearMenu.GetCheckBoxValue("wUse"))
            {
                if (WState)
                {
                    myHero.GetAutoAttackRange();
                    W.Cast(myHero);
                    LastSpell = Environment.TickCount;
                }

                if (WState)
                {
                    return;
                }

                W2.Cast();
                LastSpell = Environment.TickCount;
                return;
            }
        }
Beispiel #5
0
        private static void LaneClear()
        {
            var Minions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, W.Range, MinionTypes.All,
                                                   MinionTeam.NotAlly);

            if (Minions != null)
            {
                if (Human() && (Player.ManaPercent >= Option.Item("LMana").GetValue <Slider>().Value))
                {
                    if (Option_Item("Human Lane W") && W.IsReady())
                    {
                        var farmLocation = W.GetLineFarmLocation(Minions);
                        if (farmLocation.MinionsHit >= 3)
                        {
                            W.Cast(farmLocation.Position, true);
                        }
                    }

                    if (Option_Item("Human Lane Q") && Q.IsReady())
                    {
                        var Minion = MinionManager.GetMinions(Q.Range, MinionTypes.All, MinionTeam.NotAlly)
                                     .Where(x => x.Health < W.GetDamage(x))
                                     .OrderByDescending(x => x.MaxHealth)
                                     .ThenByDescending(x => x.Distance(Player))
                                     .FirstOrDefault();
                        if (Minion != null)
                        {
                            Q.Cast(Minion, true);
                        }
                    }
                }
                if (Spider())
                {
                    if (Option_Item("Spider Lane Q") && Q2.IsReady())
                    {
                        var Minion = MinionManager.GetMinions(Q2.Range, MinionTypes.All, MinionTeam.NotAlly)
                                     .Where(x => x.Health < W.GetDamage(x))
                                     .OrderByDescending(x => x.MaxHealth)
                                     .ThenByDescending(x => x.Distance(Player))
                                     .FirstOrDefault();
                        if (Minion != null)
                        {
                            Q2.Cast(Minion, true);
                        }
                    }

                    if (Option_Item("Spider Lane W") && W2.IsReady())
                    {
                        var Minion = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, 150, MinionTypes.All,
                                                              MinionTeam.NotAlly);
                        if (!Orbwalking.CanAttack() && Orbwalking.CanMove(10) && (Minion != null))
                        {
                            W2.Cast(true);
                        }
                    }
                }
            }
            if (Minions == null)
            {
                return;
            }
        }
Beispiel #6
0
        private void JungleClear()
        {
            if (!ManaManager.HasMana("JungleClear"))
            {
                return;
            }

            var mobs = MinionManager.GetMinions(Player.Position, 800, MinionTypes.All, MinionTeam.Neutral,
                                                MinionOrderTypes.MaxHealth);

            if (mobs.Any())
            {
                var mob = mobs.FirstOrDefault();

                if (!IsMelee)
                {
                    if (Menu.Item("UseEJungle", true).GetValue <bool>() && E.IsReady() &&
                        Menu.Item("UseQJungle", true).GetValue <bool>() && Q.IsReady())
                    {
                        var gateVector = Player.ServerPosition +
                                         Vector3.Normalize(Game.CursorPos - Player.ServerPosition) * 50;

                        if (mob != null && mob.IsValidTarget(QExtend.Range))
                        {
                            E.Cast(gateVector);
                            QExtend.Cast(mob.Position);
                        }
                    }

                    if (Menu.Item("UseQJungle", true).GetValue <bool>() && Q.IsReady())
                    {
                        var qFarm = MinionManager.GetBestLineFarmLocation(mobs.Select(x => x.Position.To2D()).ToList(),
                                                                          Q.Width, Q.Range);

                        if (qFarm.MinionsHit >= 1)
                        {
                            Q.Cast(qFarm.Position);
                        }
                    }

                    if (Menu.Item("UseWJungle", true).GetValue <bool>() && W.IsReady())
                    {
                        if (mob.Distance(Player) <= 550)
                        {
                            W.Cast();
                        }
                    }

                    if (Menu.Item("UseRJungle", true).GetValue <bool>() && R.IsReady())
                    {
                        if (Qcd != 0 && Wcd != 0 && Ecd != 0)
                        {
                            R.Cast();
                        }
                    }
                }
                else
                {
                    if (Menu.Item("UseWJungleHam", true).GetValue <bool>() && W2.IsReady() && mob.IsValidTarget(300))
                    {
                        W2.Cast();
                    }

                    if (Menu.Item("UseQJungleHam", true).GetValue <bool>() && Q2.IsReady() && mob.IsValidTarget(Q2.Range))
                    {
                        Q2.CastOnUnit(mob);
                    }

                    if (Menu.Item("UseEJungleHam", true).GetValue <bool>() && E2.IsReady() && mob.IsValidTarget(E2.Range))
                    {
                        E2.CastOnUnit(mob);
                    }

                    if (Menu.Item("UseRJungle", true).GetValue <bool>() && R.IsReady())
                    {
                        if (Q1Cd != 0 && W1Cd != 0 && E1Cd != 0)
                        {
                            R.Cast();
                        }
                    }
                }
            }
        }
Beispiel #7
0
        private static void OnAction(object sender, OrbwalkerActionArgs Args)
        {
            if (Args.Type != OrbwalkerType.AfterAttack)
            {
                return;
            }

            havePassive = false;

            if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() || Args.Target.Health <= 0)
            {
                return;
            }

            switch (Args.Target.Type)
            {
            case GameObjectType.AIHeroClient:
            {
                if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
                {
                    var target = Args.Target as AIHeroClient;

                    if (target != null && target.IsValidTarget())
                    {
                        if (ComboOption.GetBool("ComboEReset").Enabled&& E.IsReady())
                        {
                            ResetELogic(target);
                        }
                        else if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                        {
                            Q.CastOnUnit(target);
                        }
                        else if (ComboOption.UseW && W.IsReady())
                        {
                            if (ComboOption.GetBool("ComboWLogic").Enabled)
                            {
                                W2.Cast(target.PreviousPosition);
                            }
                            else
                            {
                                var wPred = W.GetPrediction(target);

                                if (wPred.Hitchance >= HitChance.High)
                                {
                                    W.Cast(wPred.UnitPosition);
                                }
                            }
                        }
                    }
                }
            }
            break;

            case GameObjectType.AIMinionClient:
            {
                if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
                {
                    var mob = (AIMinionClient)Args.Target;
                    if (mob != null && mob.IsValidTarget() && mob.GetJungleType() != JungleType.Unknown && MyManaManager.SpellFarm && JungleClearOption.HasEnouguMana())
                    {
                        if (JungleClearOption.UseE && E.IsReady())
                        {
                            E.Cast(Me.PreviousPosition.Extend(Game.CursorPos, 130));
                        }
                        else if (JungleClearOption.UseQ && Q.IsReady())
                        {
                            Q.CastOnUnit(mob);
                        }
                        else if (JungleClearOption.UseW && W.IsReady())
                        {
                            W2.Cast(mob.PreviousPosition);
                        }
                    }
                }
            }
            break;

            case GameObjectType.AITurretClient:
            case GameObjectType.HQClient:
            case GameObjectType.Barracks:
            case GameObjectType.BarracksDampenerClient:
            case GameObjectType.BuildingClient:
            {
                if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellFarm && LaneClearOption.HasEnouguMana(true))
                {
                    if (Me.CountEnemyHeroesInRange(800) == 0)
                    {
                        if (LaneClearOption.UseE && E.IsReady())
                        {
                            E.Cast(Me.PreviousPosition.Extend(Game.CursorPos, 130));
                        }
                        else if (LaneClearOption.UseW && W.IsReady())
                        {
                            W.Cast(Game.CursorPos);
                        }
                    }
                }
            }
            break;
            }
        }
Beispiel #8
0
        private static void PostAttack(object sender, PostAttackEventArgs Args)
        {
            havePassive = false;

            if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() || Args.Target.Health <= 0)
            {
                return;
            }

            switch (Args.Target.Type)
            {
            case GameObjectType.obj_AI_Hero:
            {
                if (Orbwalker.Mode == OrbwalkingMode.Combo)
                {
                    var target = Args.Target as Obj_AI_Hero;

                    if (target != null && target.IsValidTarget())
                    {
                        if (ComboOption.GetBool("ComboEReset").Enabled&& E.Ready)
                        {
                            ResetELogic(target);
                        }
                        else if (ComboOption.UseQ && Q.Ready && target.IsValidTarget(Q.Range))
                        {
                            Q.CastOnUnit(target);
                        }
                        else if (ComboOption.UseW && W.Ready)
                        {
                            if (ComboOption.GetBool("ComboWLogic").Enabled)
                            {
                                W2.Cast(target.ServerPosition);
                            }
                            else
                            {
                                var wPred = W.GetPrediction(target);

                                if (wPred.HitChance >= HitChance.High)
                                {
                                    W.Cast(wPred.UnitPosition);
                                }
                            }
                        }
                    }
                }
            }
            break;

            case GameObjectType.obj_AI_Minion:
            {
                if (Orbwalker.Mode == OrbwalkingMode.Laneclear)
                {
                    if (Args.Target.IsMob() && MyManaManager.SpellFarm && JungleClearOption.HasEnouguMana())
                    {
                        var mob = Args.Target as Obj_AI_Minion;

                        if (mob != null && mob.IsValidTarget())
                        {
                            if (JungleClearOption.UseE && E.Ready)
                            {
                                E.Cast(Me.ServerPosition.Extend(Game.CursorPos, 130));
                            }
                            else if (JungleClearOption.UseQ && Q.Ready)
                            {
                                Q.CastOnUnit(mob);
                            }
                            else if (JungleClearOption.UseW && W.Ready)
                            {
                                W2.Cast(mob.ServerPosition);
                            }
                        }
                    }
                }
            }
            break;

            case GameObjectType.obj_AI_Turret:
            case GameObjectType.obj_HQ:
            case GameObjectType.obj_Barracks:
            case GameObjectType.obj_BarracksDampener:
            case GameObjectType.obj_Building:
            {
                if (Orbwalker.Mode == OrbwalkingMode.Laneclear && MyManaManager.SpellFarm && LaneClearOption.HasEnouguMana(true))
                {
                    if (Me.CountEnemyHeroesInRange(800) == 0)
                    {
                        if (LaneClearOption.UseE && E.Ready)
                        {
                            E.Cast(Me.ServerPosition.Extend(Game.CursorPos, 130));
                        }
                        else if (LaneClearOption.UseW && W.Ready)
                        {
                            W.Cast(Game.CursorPos);
                        }
                    }
                }
            }
            break;
            }
        }
Beispiel #9
0
        public override void OnJungleClear()
        {
            var minions = EntityManager.MinionsAndMonsters.Monsters.Where(t => t.IsValidTarget(spiderForm ? E2.Range : E1.Range));

            var jungleclear = Features.Find(f => f.NameFeature == "Jungle Clear");

            if (minions == null || !minions.Any(t => t.IsValidTarget(spiderForm ? E2.Range : E1.Range)) || jungleclear.SliderValue("jungleclear.mana") > Player.Instance.ManaPercent)
            {
                return;
            }

            var target = minions.Aggregate((curMax, x) => ((curMax == null && x.IsValid) || x.MaxHealth > curMax.MaxHealth ? x : curMax));

            if (!target.IsValidTarget(spiderForm ? E2.Range : E1.Range))
            {
                target = minions.FirstOrDefault();
            }

            if (spiderForm)
            {
                if (R.IsReady() && jungleclear.IsChecked("jungleclear.r"))
                {
                    if (W1.IsReady() && Q1.IsReady())
                    {
                        R.Cast();
                    }
                }

                if (Q2.IsReady() && jungleclear.IsChecked("jungleclear.q2") && Q2.IsInRange(target))
                {
                    Q2.Cast(target);
                }

                if (W2.IsReady() && jungleclear.IsChecked("jungleclear.w2") && Player.Instance.IsInAutoAttackRange(target))
                {
                    W2.Cast();
                }
            }
            else
            {
                if (R.IsReady() && jungleclear.IsChecked("jungleclear.r"))
                {
                    if (!Q1.IsReady() && !W1.IsReady())
                    {
                        if (W1.IsReady() && jungleclear.IsChecked("jungleclear.w") && W1.IsInRange(target))
                        {
                            W1.Cast(target.Position);
                            EloBuddy.SDK.Core.DelayAction(() => R.Cast(), 250);
                        }
                        else
                        {
                            R.Cast();
                        }
                    }
                }

                if (Q1.IsReady() && jungleclear.IsChecked("jungleclear.q") && Q1.IsInRange(target))
                {
                    Q1.Cast(target);
                }

                if (W1.IsReady() && jungleclear.IsChecked("jungleclear.w") && W1.IsInRange(target))
                {
                    W1.Cast(target.Position);
                }
            }
        }
Beispiel #10
0
        /// <summary>
        /// Put in here what you want to do when the mode is running
        /// </summary>
        public static void Execute()
        {
            var target = TargetSelector.GetTarget(1100, DamageType.Magical);

            // SPIDER COMBO
            if (SpellsManager.IsSpider)
            {
                if (ComboMenu.GetCheckBoxValue("q2Use") && Q2.IsReady() && target.IsValidTarget(SpellsManager.Q2.Range))
                {
                    Q2.Cast(target);
                }
                if (ComboMenu.GetCheckBoxValue("w2Use") && W2.IsReady())
                {
                    W2.Cast();
                }
                if (ComboMenu.GetCheckBoxValue("e2Use") && E2.IsReady() && target.IsValidTarget(E2.Range))
                {
                    E2.Cast(target);
                }
                if (ComboMenu.GetCheckBoxValue("rUse") && R.IsReady() && E.IsReady() && W.IsReady())
                {
                    R.Cast();
                }
            }
            else
            { //HUMAN
                if (ComboMenu.GetCheckBoxValue("eUse") && E.IsReady() && target.IsValidTarget(SpellsManager.E.Range) && E.GetPrediction(target).HitChance >= HitChance.Medium)
                {
                    E.Cast(target);
                }
                if (ComboMenu.GetCheckBoxValue("qUse") && Q.IsReady() && target.IsValidTarget(SpellsManager.Q.Range))
                {
                    Q.Cast(target);
                }
                if (ComboMenu.GetCheckBoxValue("WUse") && W.IsReady() && target.IsValidTarget(W.Range))
                {
                    W.Cast(target);
                }
                if (ComboMenu.GetCheckBoxValue("rUse") && R.IsReady())
                {
                    R.Cast();
                }
            }


            if (ComboMenu.GetKeyBindValue("gankcombokey"))
            {
                if (ComboMenu.GetCheckBoxValue("eUse") && E.IsReady() && target.IsValidTarget(SpellsManager.E.Range) && E.GetPrediction(target).HitChance >= HitChance.Medium)
                {
                    E.Cast(target);
                }
                if (ComboMenu.GetCheckBoxValue("qUse") && Q.IsReady() && target.IsValidTarget(SpellsManager.Q.Range))
                {
                    Q.Cast(target);
                }
                if (ComboMenu.GetCheckBoxValue("WUse") && W.IsReady() && target.IsValidTarget(W.Range))
                {
                    W.Cast(target);
                }
                if (ComboMenu.GetCheckBoxValue("rUse") && R.IsReady() && Q2.IsReady())
                {
                    R.Cast();
                }

                else if (SpellsManager.IsSpider)
                {
                    if (ComboMenu.GetCheckBoxValue("q2Use") && Q2.IsReady() && target.IsValidTarget(SpellsManager.Q2.Range))
                    {
                        Q2.Cast(target);
                    }
                    if (ComboMenu.GetCheckBoxValue("w2Use") && W2.IsReady())
                    {
                        W2.Cast();
                    }
                    if (ComboMenu.GetCheckBoxValue("e2Use") && E2.IsReady() && target.IsValidTarget(E2.Range))
                    {
                        E2.Cast(target);
                    }
                    if (ComboMenu.GetCheckBoxValue("rUse") && R.IsReady() && E.IsReady() && W.IsReady())
                    {
                        R.Cast();
                    }
                }
            }
        }
Beispiel #11
0
        public override void OnHarass()
        {
            var target = TargetSelector.GetTarget(spiderForm ? E2.Range : E1.Range, DamageType.Magical);

            var harass = Features.Find(f => f.NameFeature == "Harass");

            if (target == null || !target.IsValidTarget(1000) || harass.SliderValue("harass.mana") > Player.Instance.ManaPercent)
            {
                return;
            }

            if (spiderForm)
            {
                if (R.IsReady() && harass.IsChecked("harass.r"))
                {
                    if (!W2.IsReady() && !Q2.IsReady() && !Player.Instance.IsInAutoAttackRange(target))
                    {
                        R.Cast();
                    }
                }

                if (Q2.IsReady() && harass.IsChecked("harass.q2") && Q2.IsInRange(target))
                {
                    Q2.Cast(target);
                }

                if (E2.IsReady() && harass.IsChecked("harass.e2") && E2.IsInRange(target) && !Q2.IsInRange(target))
                {
                    E2.Cast(target);
                }

                if (W2.IsReady() && harass.IsChecked("harass.w2") && Player.Instance.IsInAutoAttackRange(target))
                {
                    W2.Cast();
                }
            }
            else
            {
                if (R.IsReady() && harass.IsChecked("harass.r"))
                {
                    if (!Q1.IsReady() && !E1.IsReady())
                    {
                        if (W1.IsReady() && harass.IsChecked("harass.w") && W1.IsInRange(target))
                        {
                            W1.Cast(W1.GetPrediction(target).CastPosition);
                            EloBuddy.SDK.Core.DelayAction(() => R.Cast(), 250);
                        }
                        else
                        {
                            R.Cast();
                        }
                    }
                }

                if (E1.IsReady() && harass.IsChecked("harass.e") && E1.IsInRange(target))
                {
                    SpellsUtil.HitChanceCast(E1, target);
                }

                if (Q1.IsReady() && harass.IsChecked("harass.q") && Q1.IsInRange(target))
                {
                    Q1.Cast(target);
                }

                if (W1.IsReady() && harass.IsChecked("harass.w") && W1.IsInRange(target))
                {
                    W1.Cast(W1.GetPrediction(target).CastPosition);
                }
            }
        }
Beispiel #12
0
        public override void OnCombo()
        {
            var target = TargetSelector.GetTarget(spiderForm ? E2.Range : E1.Range, DamageType.Magical);

            if (target == null || !target.IsValidTarget())
            {
                return;
            }

            var combo = Features.Find(f => f.NameFeature == "Combo");

            if (spiderForm)
            {
                if (R.IsReady() && combo.IsChecked("combo.r"))
                {
                    if (W1.IsReady() && Q1.IsReady() && E1.IsReady())
                    {
                        R.Cast();
                    }
                }

                if (Q2.IsReady() && combo.IsChecked("combo.q2") && Q2.IsInRange(target))
                {
                    Q2.Cast(target);
                }

                if (E2.IsReady() && combo.IsChecked("combo.e2") && E2.IsInRange(target) && !Q2.IsInRange(target))
                {
                    E2.Cast(target);
                }

                if (W2.IsReady() && combo.IsChecked("combo.w2") && Player.Instance.IsInAutoAttackRange(target))
                {
                    W2.Cast();
                }
            }
            else
            {
                if (R.IsReady() && combo.IsChecked("combo.r"))
                {
                    if (!Q1.IsReady())
                    {
                        if (W1.IsReady() && combo.IsChecked("combo.w") && W1.IsInRange(target))
                        {
                            W1.Cast(W1.GetPrediction(target).CastPosition);
                            EloBuddy.SDK.Core.DelayAction(() => R.Cast(), 250);
                        }
                        else
                        {
                            R.Cast();
                        }
                    }
                }

                if (E1.IsReady() && combo.IsChecked("combo.e") && E1.IsInRange(target))
                {
                    SpellsUtil.HitChanceCast(E1, target);
                }

                if (Q1.IsReady() && combo.IsChecked("combo.q") && Q1.IsInRange(target))
                {
                    Q1.Cast(target);
                }
            }
        }
Beispiel #13
0
        private static void JungleClear()
        {
            var minion = EntityManager.MinionsAndMonsters.GetJungleMonsters(null, Q.Range).FirstOrDefault();

            if (minion == null)
            {
                return;
            }

            if (junglePassive)
            {
                if (PassiveStacks > 0 || LastSpell + 400 > Environment.TickCount)
                {
                    return;
                }
            }

            if (E.IsReady() && ElLeeSinJungleE)
            {
                if (EState && E.IsInRange(minion))
                {
                    E.Cast();
                    LastSpell = Environment.TickCount;
                }

                if (!EState && E.IsInRange(minion) && LastE + 400 < Environment.TickCount)
                {
                    E.Cast();
                    LastSpell = Environment.TickCount;
                }
            }

            if (Q.IsReady() && ElLeeSinJungleQ)
            {
                Q.Cast(minion);
                LastSpell = Environment.TickCount;

                foreach (var jungleMobs in ObjectManager.Get <Obj_AI_Minion>().Where(o => o.IsValidTarget(Program.Q.Range) && o.Team == GameObjectTeam.Neutral && o.IsVisible && !o.IsDead))
                {
                    if (EntityManager.MinionsAndMonsters.GetJungleMonsters(null, Q.Range).Any())
                    {
                        if (jungleMobs.HasQBuff())
                        {
                            Q2.Cast();
                            LastSpell = Environment.TickCount;
                        }
                    }
                }
            }

            if (W.IsReady() && ElLeeSinJungleW)
            {
                if (WState)
                {
                    W.Cast(myHero);
                    LastSpell = Environment.TickCount;
                }

                if (WState)
                {
                    return;
                }

                W2.Cast();
                LastSpell = Environment.TickCount;
                return;
            }
        }
Beispiel #14
0
        private void OnHarass()
        {
            var target = GetBestEnemyHeroTargetInRange(Q.Range);

            if (!target.IsValidTarget())
            {
                return;
            }

            bool  useQ  = Menu["harass"]["useq"].Enabled;
            float manaQ = Menu["harass"]["manaq"].As <MenuSlider>().Value;

            if (Q.Ready && useQ)
            {
                switch (Player.SpellBook.GetSpell(SpellSlot.Q).ToggleState)
                {
                case 1:
                    if (target.IsValidTarget(Q.Range) && Player.ManaPercent() >= manaQ && Player.SpellBook.GetSpell(SpellSlot.Q).ToggleState == 1)
                    {
                        Q.Cast(target);
                    }
                    break;

                case 2:
                    if (missiles != null && target.IsValidTarget(200f, false, false, missiles.Position) &&
                        Player.SpellBook.GetSpell(SpellSlot.Q).ToggleState == 2)
                    {
                        Q.Cast();
                    }
                    break;
                }
            }

            bool AA = Menu["misc"]["aa2"].Enabled;

            if (AA && target.IsValidAutoRange())
            {
                if (Player.SpellBook.GetSpell(SpellSlot.W).ToggleState == 2)
                {
                    Orbwalker.AttackingEnabled = false;
                }
                if (Player.SpellBook.GetSpell(SpellSlot.W).ToggleState == 0)
                {
                    Orbwalker.AttackingEnabled = true;
                }
            }

            bool  useW  = Menu["harass"]["usew"].Enabled;
            float manaW = Menu["harass"]["manaw"].As <MenuSlider>().Value;

            if (W.Ready && useW)
            {
                switch (Player.SpellBook.GetSpell(SpellSlot.W).ToggleState)
                {
                case 0:
                    if (target.IsValidTarget(W2.Range) && Player.ManaPercent() >= manaW && Player.SpellBook.GetSpell(SpellSlot.W).ToggleState == 0)
                    {
                        W2.Cast();
                    }
                    break;

                case 2:
                    if (target.IsValidTarget(W.Range) || !target.IsValidTarget(W2.Range) || Player.ManaPercent() < manaW && Player.SpellBook.GetSpell(SpellSlot.W).ToggleState == 2)
                    {
                        W.Cast();
                    }
                    break;
                }
            }
        }
Beispiel #15
0
        private void OnCombo()
        {
            var target = GetBestEnemyHeroTargetInRange(R.Range);

            if (!target.IsValidTarget())
            {
                return;
            }

            bool useQ = Menu["combo"]["useq"].Enabled;

            if (Q.Ready && useQ)
            {
                switch (Player.SpellBook.GetSpell(SpellSlot.Q).ToggleState)
                {
                case 1:
                    if (target.IsValidTarget(Q.Range) && Player.SpellBook.GetSpell(SpellSlot.Q).ToggleState == 1)
                    {
                        Q.Cast(target);
                    }
                    break;

                case 2:
                    if (missiles != null && target.IsValidTarget(200f, false, false, missiles.Position) &&
                        Player.SpellBook.GetSpell(SpellSlot.Q).ToggleState == 2)
                    {
                        Q.Cast();
                    }
                    break;
                }
            }

            bool AA = Menu["misc"]["aa"].Enabled;

            if (AA && target.IsValidAutoRange())
            {
                if (Player.SpellBook.GetSpell(SpellSlot.W).ToggleState == 2)
                {
                    Orbwalker.AttackingEnabled = false;
                }
                if (Player.SpellBook.GetSpell(SpellSlot.W).ToggleState == 0)
                {
                    Orbwalker.AttackingEnabled = true;
                }
            }

            bool useW = Menu["combo"]["usew"].Enabled;

            if (W.Ready && useW)
            {
                switch (Player.SpellBook.GetSpell(SpellSlot.W).ToggleState)
                {
                case 0:
                    if (target.IsValidTarget(W2.Range) && Player.SpellBook.GetSpell(SpellSlot.W).ToggleState == 0)
                    {
                        W2.Cast();
                    }
                    break;

                case 2:
                    if (target.IsValidTarget(W.Range) && Player.SpellBook.GetSpell(SpellSlot.W).ToggleState == 2)
                    {
                        W.Cast();
                    }
                    break;
                }
            }

            bool useR = Menu["combo"]["user"].Enabled;

            if (R.Ready && target.IsValidTarget(R.Range) && useR && R.CastIfWillHit(target, Menu["combo"]["hitr"].As <MenuSlider>().Value - 1))
            {
                R.Cast(target);
            }
        }