Example #1
0
        public static void Execute()
        {
            var target = TargetSelector.GetTarget(Q2.Range, DamageType.Mixed);

            if (target == null)
            {
                return;
            }

            var targetW  = TargetSelector.GetTarget(Player.Instance.BoundingRadius + 175, DamageType.Physical);
            var targetQ2 = TargetSelector.GetTarget(850, DamageType.Magical);
            var predq2   = Q2.GetPrediction(targetQ2).HitChance >= Hitch.hitchance(Q2, FirstMenu);
            var targetE  = TargetSelector.GetTarget(550, DamageType.Physical);
            var targetE2 = TargetSelector.GetTarget(E2.Range, DamageType.Physical);

            if (HarassMenu.GetCheckBoxValue("qUse") && Q.IsReady() && targetE.IsValidTarget(100))
            {
                Q.Cast();
            }

            if (HarassMenu.GetCheckBoxValue("eUse") && E.IsReady())
            {
                E.Cast(targetE);
            }

            if (HarassMenu.GetCheckBoxValue("q2Use") && Q2.IsReady() && predq2)
            {
                var predQ2 = SpellsManager.Q2.GetPrediction(targetQ2);
                Q2.Cast(predQ2.CastPosition);
            }
        }
Example #2
0
        public static void Execute()
        {
            var etarget = TargetSelector.GetTarget(E.Range, DamageType.Magical);

            if (W.IsReady() && Q.IsReady())
            {
                Q.Cast();
                W.Cast();
            }
            if (E.IsReady() && E.GetPrediction(etarget).HitChance >= Hitch.hitchance(E, FirstMenu))
            {
                E.Cast(etarget.Position);
            }
        }
Example #3
0
        public static void Execute()
        {
            var qtarget = EntityManager.MinionsAndMonsters.EnemyMinions.FirstOrDefault(x => !x.IsDead && Q.IsInRange(x));
            var wtarget = EntityManager.MinionsAndMonsters.EnemyMinions.FirstOrDefault(x => !x.IsDead && W.IsInRange(x));
            var etarget = EntityManager.MinionsAndMonsters.EnemyMinions.FirstOrDefault(x => !x.IsDead && E.IsInRange(x));

            if (_player.Mana <= 1 - 4)
            {
                if (LaneClearMenu.GetCheckBoxValue("qUse") && Q.IsReady())
                {
                    Program.Items();
                    Q.Cast();
                    Orbwalker.ForcedTarget = qtarget;
                }

                if (LaneClearMenu.GetCheckBoxValue("wUse") && W.IsReady())
                {
                    W.Cast();
                }
                if (LaneClearMenu.GetCheckBoxValue("eUse") && E.IsReady() && E.GetPrediction(etarget).HitChance >= Hitch.hitchance(E, FirstMenu))
                {
                    E.Cast(etarget);
                }
            }

            if (_player.Mana <= 5 && LaneClearMenu.GetCheckBoxValue("wUse") && W.IsReady() && LaneClearMenu.GetCheckBoxValue("WClearHeal"))
            {
                W.Cast();
            }
        }
Example #4
0
        public static void Execute()
        {
            //////////////////// KS Q2
            if (KillStealMenu.GetCheckBoxValue("qUse"))
            {
                var q2target = TargetSelector.GetTarget(Q2.Range, DamageType.Magical);

                if (q2target == null)
                {
                    return;
                }

                if (Q.IsReady())
                {
                    var q2Damage = q2target.GetDamage(SpellSlot.Q);

                    var predictedHealth = Prediction.Health.GetPrediction(q2target, Q2.CastDelay + Game.Ping);

                    if (predictedHealth <= q2Damage && Q2.GetPrediction(q2target).HitChance >= Hitch.hitchance(Q2, FirstMenu))
                    {
                        var rangi = TargetSelector.GetTarget(Program._player.GetAutoAttackRange(), DamageType.Physical);
                        if (q2target.IsValidTarget(Q2.Range))
                        {
                            Q2.Cast(q2target);
                        }
                    }
                }
            }            //////////////////// END KS Q2

            //////////////////// KS E2
            if (KillStealMenu.GetCheckBoxValue("eUse"))
            {
                var e2target = TargetSelector.GetTarget(E2.Range, DamageType.Magical);

                if (e2target == null)
                {
                    return;
                }

                if (E2.IsReady())
                {
                    var e2Damage = e2target.GetDamage(SpellSlot.E);

                    var predictedHealth = Prediction.Health.GetPrediction(e2target, E2.CastDelay + Game.Ping);

                    if (predictedHealth <= e2Damage && E2.GetPrediction(e2target).HitChance >= Hitch.hitchance(E2, FirstMenu))
                    {
                        var rangi = TargetSelector.GetTarget(Program._player.GetAutoAttackRange(), DamageType.Physical);
                        if (e2target.IsValidTarget(E2.Range))
                        {
                            E2.Cast(e2target);
                        }
                    }
                }
            }       //////////////////// END KS E2

            //////////////////// KS Q2
            var targetKSQ2 = TargetSelector.GetTarget(SpellsManager.Q2.Range, DamageType.Magical);

            if (targetKSQ2 != null && Program.burrowed && KillStealMenu.GetCheckBoxValue("qUse") && SpellsManager.Q2.IsReady())
            {
                var predQ2 = SpellsManager.Q2.GetPrediction(targetKSQ2);
                if (predQ2.HitChance >= HitChance.High && targetKSQ2.Health < Player.Instance.GetSpellDamage(targetKSQ2, SpellSlot.Q))
                {
                    SpellsManager.Q2.Cast(predQ2.CastPosition);
                    return;
                }
            }//////////////////// END KS Q2
        }
Example #5
0
        public static void Execute()
        {
            //W autodisable thanks to Sunnyline2
            if (MiscMenu.GetCheckBoxValue("smartW") && Program.WStatus())
            {
                int monsters = EntityManager.MinionsAndMonsters.CombinedAttackable.Where(monster => monster.IsValidTarget(W.Range * 2)).Count();
                int enemies  = EntityManager.Heroes.Enemies.Where(enemy => enemy.IsValidTarget(W.Range * 2)).Count();
                if (monsters == 0 && enemies == 0)
                {
                    Program.WDisable();
                }
            }
            //// Sunnyline2


            //////////////////// KS Q
            var targetKSQ = TargetSelector.GetTarget(SpellsManager.Q.Range, DamageType.Magical);

            if (targetKSQ != null && KillStealMenu.GetCheckBoxValue("qUse") && SpellsManager.Q.IsReady())
            {
                var predQ2 = SpellsManager.Q.GetPrediction(targetKSQ);
                if (predQ2.HitChance >= HitChance.High && targetKSQ.Health < Player.Instance.GetSpellDamage(targetKSQ, SpellSlot.Q))
                {
                    SpellsManager.Q.Cast(predQ2.CastPosition);
                    return;
                }
            }//////////////////// END KS Q


            //////////////////// KS Q Logic #2
            if (KillStealMenu.GetCheckBoxValue("qUse"))
            {
                var qtarget = TargetSelector.GetTarget(Q.Range, DamageType.Magical);

                if (qtarget == null)
                {
                    return;
                }

                if (Q.IsReady())
                {
                    var qDamage = qtarget.GetDamage(SpellSlot.Q);

                    var predictedHealth = Prediction.Health.GetPrediction(qtarget, Q.CastDelay + Game.Ping);

                    if (predictedHealth <= qDamage && Q.GetPrediction(qtarget).HitChance >= Hitch.hitchance(Q, FirstMenu))
                    {
                        var rangi = TargetSelector.GetTarget(Program._player.GetAutoAttackRange(), DamageType.Physical);
                        if (qtarget.IsValidTarget(Q.Range))
                        {
                            Q.Cast(qtarget);
                        }
                    }
                }
            }            //////////////////// END Logic #2
        }
Example #6
0
        public static void Execute()
        {
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            var qtarget = TargetSelector.GetTarget(Q.Range, DamageType.Magical);
            var wtarget = TargetSelector.GetTarget(W.Range, DamageType.Magical);
            var etarget = TargetSelector.GetTarget(E.Range, DamageType.Magical);
            var rtarget = TargetSelector.GetTarget(3400, DamageType.Mixed);
            var target  = TargetSelector.GetTarget(E.Range + 200, DamageType.Magical);
            var enemies = EntityManager.Heroes.Enemies.OrderByDescending(a => a.HealthPercent).Where(a => !a.IsMe && a.IsValidTarget() && a.Distance(_Player) <= R.Range);
            var predq   = Q.GetPrediction(qtarget);

            if (target == null || target.IsInvulnerable || target.MagicImmune)
            {
                return;
            }
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


            // COMBO 1
            if (ComboMenu["Comba"].Cast <ComboBox>().CurrentValue == 0)
            {
                Core.DelayAction(delegate
                {
                    if (ComboMenu.GetCheckBoxValue("qUse") && Q.IsReady() && qtarget.IsValidTarget(Q.Range) && Q.GetPrediction(qtarget).HitChance >= Hitch.hitchance(Q, FirstMenu))
                    {
                        Q.Cast(predq.CastPosition);
                    }
                }, Qdelay);

                if (target.HasBuffOfType(BuffType.Snare) || target.HasBuffOfType(BuffType.Stun))
                {
                    Core.DelayAction(delegate
                    {
                        if (ComboMenu.GetCheckBoxValue("eUse") && E.IsReady() && etarget.IsValidTarget(E.Range) && E.GetPrediction(etarget).HitChance >= Hitch.hitchance(E, FirstMenu))
                        {
                            E.Cast(etarget);
                        }
                    }, Edelay);

                    if (_Player.HasBuff("LuxEEnd"))
                    {
                        Core.DelayAction(delegate
                        {
                            E.Cast();
                        }, Edelay);
                    }

                    if (ComboMenu.GetCheckBoxValue("rUse") && R.IsReady() && rtarget.IsValidTarget(R.Range))
                    {
                        foreach (var ultenemies in enemies)
                        {
                            var useR            = ComboMenu["r.ult" + ultenemies.ChampionName].Cast <CheckBox>().CurrentValue;
                            var predictedHealth = Prediction.Health.GetPrediction(target, R.CastDelay + Game.Ping);
                            var passiveDamage   = target.HasPassive() ? target.GetPassiveDamage() : 0f;
                            var rDamage         = target.GetDamage(SpellSlot.R) + passiveDamage;
                            {
                                if ((useR) && (predictedHealth <= rDamage))
                                {
                                    R.Cast(ultenemies);
                                }
                                else if (R.IsReady())
                                {
                                    var totalDamage = target.GetDamage(SpellSlot.E) + target.GetDamage(SpellSlot.R) + passiveDamage;


                                    if (predictedHealth <= totalDamage)
                                    {
                                        R.Cast(ultenemies);
                                    }
                                }
                            }
                        }
                    }


                    if (ComboMenu.GetCheckBoxValue("wUse") && W.IsReady() && Player.Instance.HealthPercent <= ComboMenu.GetSliderValue("hpW"))
                    {
                        W.Cast(wtarget.Position);
                    }
                }            // COMBO 1 END
            }


            // COMBO 2 / 3
            if (ComboMenu["Comba"].Cast <ComboBox>().CurrentValue == 1)
            {
                Core.DelayAction(delegate
                {
                    if (ComboMenu.GetCheckBoxValue("qUse") && Q.IsReady() && qtarget.IsValidTarget(Q.Range) && Q.GetPrediction(qtarget).HitChance >= Hitch.hitchance(Q, FirstMenu))
                    {
                        Q.Cast(predq.CastPosition);
                    }
                }, Qdelay);
                Core.DelayAction(delegate
                {
                    if (ComboMenu.GetCheckBoxValue("eUse") && E.IsReady() && etarget.IsValidTarget(E.Range) && E.GetPrediction(etarget).HitChance >= Hitch.hitchance(E, FirstMenu))
                    {
                        E.Cast(etarget);
                    }
                }, Edelay);

                if (Player.HasBuff("LuxEEnd"))
                {
                    Core.DelayAction(delegate
                    {
                        E.Cast();
                    }, Edelay);
                }

                if (ComboMenu.GetCheckBoxValue("rUse") && R.IsReady() && rtarget.IsValidTarget(R.Range))
                {
                    foreach (var ultenemies in enemies)
                    {
                        var useR            = ComboMenu["r.ult" + ultenemies.ChampionName].Cast <CheckBox>().CurrentValue;
                        var predictedHealth = Prediction.Health.GetPrediction(target, R.CastDelay + Game.Ping);
                        var passiveDamage   = target.HasPassive() ? target.GetPassiveDamage() : 0f;
                        var rDamage         = target.GetDamage(SpellSlot.R) + passiveDamage;
                        {
                            if ((useR) && (predictedHealth <= rDamage))
                            {
                                R.Cast(ultenemies);
                            }
                            else if (R.IsReady())
                            {
                                var totalDamage = target.GetDamage(SpellSlot.E) + target.GetDamage(SpellSlot.R) + passiveDamage;


                                if (predictedHealth <= totalDamage)
                                {
                                    R.Cast(ultenemies);
                                }
                            }
                        }
                    }
                }
                if (ComboMenu.GetCheckBoxValue("wUse") && W.IsReady() && Player.Instance.HealthPercent <= ComboMenu.GetSliderValue("hpW"))
                {
                    W.Cast(wtarget.Position);
                }
            }            // COMBO 2 / 3 END
        }
Example #7
0
        public static void Execute()
        {
            ///////////////////////////////////////////////////////////////////////
            var Target     = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
            var useW       = ComboMenu.GetCheckBoxValue("wUse");
            var useE       = ComboMenu.GetCheckBoxValue("eUse");
            var useR       = ComboMenu.GetCheckBoxValue("rUse");
            var ultEnemies = ComboMenu.GetSliderValue("combo.REnemies");

            if (Target == null || Target.IsInvulnerable || Target.MagicImmune)
            {
                return;
            }
            ///////////////////////////////////////////////////////////////////////

            if (useE && E.IsReady() && E.GetPrediction(Target).HitChance >= Hitch.hitchance(E, FirstMenu))
            {
                E.Cast(Target.ServerPosition);
            }

            if (Q.IsReady() && Q.GetPrediction(Target).HitChance >= Hitch.hitchance(Q, FirstMenu))
            {
                if (Target.IsUnderHisturret())
                {
                    return;
                }
                if (ComboMenu.GetSliderValue("Q1") > 0)
                {
                    switch (ComboMenu.GetSliderValue("Q1"))
                    {
                    case 1:
                        Q.Cast(Target.ServerPosition);
                        break;

                    case 2:
                        foreach (var h in EntityManager.Heroes.Enemies.Where(h => h.IsValidTarget()))
                        {
                            Q.Cast(h.ServerPosition);
                        }
                        break;
                    }
                }
            }

            if (W.IsReady() && useW)
            {
                if (_player.HealthPercent < ComboMenu.GetSliderValue("combo.minw"))
                {
                    if (_player.Spellbook.GetSpell(SpellSlot.W).ToggleState == 2)
                    {
                        W.Cast();
                    }
                }

                if (_player.HealthPercent > ComboMenu.GetSliderValue("combo.maxw"))
                {
                    if (_player.Spellbook.GetSpell(SpellSlot.W).ToggleState == 1)
                    {
                        W.Cast();
                    }
                }
            }

            if (ComboMenu["RS"].Cast <ComboBox>().CurrentValue == 0 && useR && R.IsReady() && _player.ServerPosition.CountEnemiesInRange(500f) <= ultEnemies)
            {
                R.Cast();
            }

            else if (ComboMenu["RS"].Cast <ComboBox>().CurrentValue == 1 && useR && R.IsReady() && Player.Instance.IsFacing(Target) && _player.ServerPosition.CountEnemiesInRange(500f) <= ultEnemies)
            {
                R.Cast();
            }

            else if (ComboMenu["RS"].Cast <ComboBox>().CurrentValue == 2 && useR && R.IsReady() && Program._player.HealthPercent <= 25 && _player.ServerPosition.CountEnemiesInRange(500f) <= ultEnemies)
            {
                R.Cast();
            }
        }
Example #8
0
        public static void Execute()
        {
            var target  = TargetSelector.GetTarget(2000, DamageType.Physical);
            var rtarget = TargetSelector.GetTarget(R.Range, DamageType.Magical);
            var useQ    = ComboMenu.GetCheckBoxValue("qUse");
            var useW    = ComboMenu.GetCheckBoxValue("wUse");
            var useE    = ComboMenu.GetCheckBoxValue("eUse");
            var useR    = ComboMenu.GetCheckBoxValue("rUse");
            var useEE   = ComboMenu.GetCheckBoxValue("UseEEC");
            var tqq     = TargetSelector.GetTarget(Q.Range, DamageType.Physical);

            if (useR)
            {
                Program.ItemsYuno();
                R.Cast();
            }

            if (_player.Mana <= 4)

            {
                var tqqq = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
                if (tqqq.IsValidTarget(Q.Range) && Q.IsReady() && useQ)
                {
                    Q.Cast();
                    Program.Items();
                }

                var tww = TargetSelector.GetTarget(W.Range, DamageType.Magical);
                if (tww.IsValidTarget(250) && W.IsReady() && !_player.HasBuff("rengarpassivebuff") && useW)
                {
                    W.Cast();
                }


                var tee   = TargetSelector.GetTarget(E.Range, DamageType.Physical);
                var predE = E.GetPrediction(tee);
                if (!_player.HasBuff("rengarpassivebuff") && tee.IsValidTarget(E.Range) && E.IsReady() && E.GetPrediction(tee).HitChance >= Hitch.hitchance(E, FirstMenu) && useE)
                {
                    E.Cast(tee);
                }
            }

            if (_player.Mana <= 5)
            {
                var tq = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
                var tw = TargetSelector.GetTarget(W.Range, DamageType.Magical);
                var te = TargetSelector.GetTarget(E.Range, DamageType.Physical);

                if (useQ && (FirstMenu.GetComboBoxValue("ComboPrio") == 0 && tq.IsValidTarget(Q.Range) && Q.IsReady()) ||
                    (FirstMenu.GetComboBoxValue("ComboPrio") == 2))
                {
                    Q.Cast();
                }

                if (useW && FirstMenu.GetComboBoxValue("ComboPrio") == 1 && tw.IsValidTarget(250) && W.IsReady() && !_player.HasBuff("rengarpassivebuff"))
                {
                    W.Cast();
                }

                if (useE && FirstMenu.GetComboBoxValue("ComboPrio") == 2 && (te.IsValidTarget(E.Range) && E.IsReady() && !_player.HasBuff("rengarpassivebuff") && E.GetPrediction(te).HitChance >= Hitch.hitchance(E, FirstMenu)))
                {
                    E.Cast(te);
                }

                if (useEE && !_player.HasBuff("RengarR") && te.IsValidTarget(E.Range) && E.IsReady() && E.GetPrediction(te).HitChance >= Hitch.hitchance(E, FirstMenu) && (FirstMenu.GetComboBoxValue("ComboPrio") == 2 ||
                                                                                                                                                                           FirstMenu.GetComboBoxValue("ComboPrio") == 0))
                {
                    if (_player.Distance(te) > E.Range + 100f)
                    {
                        E.Cast(te);
                    }
                }
            }

            if (MiscMenu.GetCheckBoxValue("AutoW"))
            {
                var HealthW = MiscMenu["AutoWHP"].Cast <Slider>().CurrentValue;

                if (W.IsReady() && _player.HealthPercent != HealthW && Player.Instance.Mana == 5)
                {
                    W.Cast();
                }
            }
        }
Example #9
0
        public static void Execute()
        {
            var t          = TargetSelector.GetTarget(Q2.Range, DamageType.Physical);
            var reksaifury = Equals(Program._player.Mana, Program._player.MaxMana);

            if (Program.burrowed)
            {
                var targetW  = TargetSelector.GetTarget(Player.Instance.BoundingRadius + 175, DamageType.Physical);
                var targetQ2 = TargetSelector.GetTarget(850, DamageType.Magical);

                var targetE  = TargetSelector.GetTarget(550, DamageType.Physical);
                var targetE2 = TargetSelector.GetTarget(E2.Range, DamageType.Physical);
                var predE2   = E2.GetPrediction(targetE2);
                var predq2   = Q2.GetPrediction(targetQ2).HitChance >= Hitch.hitchance(Q2, FirstMenu);

                //if (Program.getCheckBoxItem(ComboMenu, "UseQBCombo"))
                //{
                //    var tbq = TargetSelector.GetTarget(Q2.Range, DamageType.Magical);
                //    var predqq = Q2.GetPrediction(tbq).HitChance >= Hitch.hitchance(Q2, FirstMenu);
                //    if (Q2.IsReady() && predqq && t.IsValidTarget(Q2.Range)) Q2.Cast(tbq);
                //}

                if (ComboMenu.GetCheckBoxValue("UseQBCombo") && Q2.IsReady() && predq2)
                {
                    var predQ2 = SpellsManager.Q2.GetPrediction(targetQ2);
                    Q2.Cast(predQ2.CastPosition);
                }

                if (ComboMenu.GetCheckBoxValue("UseWCombo") && W.IsReady())
                {
                    if (targetW != null && targetW.IsValidTarget())
                    {
                        W.Cast();
                        return;
                    }
                }


                //var predq = Q2.GetPrediction(targetQ2).HitChance >= Hitch.hitchance(Q2, FirstMenu);
                //if (ComboMenu.GetCheckBoxValue("UseQBCombo") && Q2.IsReady() && predq)
                //    {

                //        if (targetQ2 != null && targetQ2.IsValidTarget())
                //        {
                //            var predictionQ2 = Q2.GetPrediction(targetQ2);
                //            if (predictionQ2.HitChance >= HitChance.Medium)
                //            {
                //                Q2.Cast(predictionQ2.CastPosition);
                //                return;
                //            }
                //        }
                //    }

                // if (Program.getCheckBoxItem(ComboMenu, "UseEBCombo"))
                //{
                //    var te = TargetSelector.GetTarget(E2.Range + W.Range, DamageType.Physical);
                //     if (E2.IsReady() && te.IsValidTarget(E2.Range + W.Range) && Program._player.Distance(te) > Q.Range)
                //     {
                //         var predE22 = SpellsManager.E2.GetPrediction(te);
                //         E2.Cast(predE22.CastPosition);
                //     }
                // }
            }

            if (!Program.burrowed)
            {
                var targetE    = TargetSelector.GetTarget(E.Range, DamageType.Physical);
                var lastTarget = Orbwalker.LastTarget;
                var target     = TargetSelector.GetTarget(300, DamageType.Physical);

                if (ComboMenu.GetCheckBoxValue("UseQCombo") && Program._player.IsInAutoAttackRange(target))
                {
                    Q.Cast();
                }

                if (ComboMenu.GetCheckBoxValue("UseECombo") && E.IsReady())
                {
                    if (targetE != null && targetE.IsValidTarget())
                    {
                        E.Cast(targetE);
                        return;
                    }
                }

                if (ComboMenu.GetCheckBoxValue("UseWCombo") && W.IsReady())
                {
                    if (Player.Instance.CountEnemiesInRange(400) == 0)
                    {
                        W.Cast();
                        return;
                    }
                }

                if (ComboMenu.GetCheckBoxValue("UseEBCombo"))
                {
                    var te = TargetSelector.GetTarget(E2.Range + 150, DamageType.Physical);
                    if (E2.IsReady() && te.IsValidTarget(E2.Range + 150))
                    {
                        var predE22 = SpellsManager.E2.GetPrediction(te);
                        E2.Cast(predE22.CastPosition);
                    }
                }

                if (ComboMenu.GetCheckBoxValue("UseWCombo") && W.IsReady())
                {
                    if (lastTarget.IsValidTarget(Player.Instance.BoundingRadius + 250) && !target.HasBuff("reksaiknockupimmune"))
                    {
                        W.Cast();
                        return;
                    }
                }
            }
        }
Example #10
0
        public static void Execute()
        {
            var Target = TargetSelector.GetTarget(E.Range, DamageType.Physical);
            var ttarget = TargetSelector.GetTarget(Q.Range, DamageType.Physical);

            if (Target == null || Target.IsInvulnerable || Target.MagicImmune)
            {
                return;
            }
            var useE = Eclipse.Menus.HarassMenu.GetCheckBoxValue("eUse");

            if (Q.IsReady() && Eclipse.Menus.HarassMenu.GetCheckBoxValue("qUse") && ttarget.IsValidTarget(Q.Range -20) && Q.GetPrediction(ttarget).HitChance >= Hitch.hitchance(Q, FirstMenu))
            {
                Q.Cast(ttarget.Position);
            }

            if (useE && E.IsReady() && Target.IsValidTarget(E.Range - 20) && E.GetPrediction(Target).HitChance >= Hitch.hitchance(E, FirstMenu))
            {
                E.Cast(Target.Position);
            }


        }
Example #11
0
        public static void Execute()
        {
            var qtarget  = TargetSelector.GetTarget(Q.Range, DamageType.Magical);
            var wtarget  = TargetSelector.GetTarget(W.Range, DamageType.Magical);
            var etarget  = TargetSelector.GetTarget(E.Range, DamageType.Magical);
            var rtarget  = TargetSelector.GetTarget(R.Range, DamageType.Magical);
            var enemiese = EntityManager.Heroes.Enemies.OrderByDescending
                               (a => a.HealthPercent).Where(a => !a.IsMe && a.IsValidTarget() && a.Distance(Player) <= R.Range);

            if (qtarget.IsValidTarget())
            {
                if (qtarget != null)
                {
                    if (ComboMenu.GetCheckBoxValue("qUse") && qtarget.IsValidTarget(SpellsManager.Q.Range) && Q.IsReady() && Q.GetPrediction(qtarget).HitChance >= Hitch.hitchance(Q, ComboMenu) && Q.Name == "VelkozQ")
                    {
                        Q.Cast(qtarget);
                    }
                }
            }

            if (ComboMenu.GetCheckBoxValue("eUse") && E.IsReady() && etarget.IsValidTarget(SpellsManager.E.Range) && E.GetPrediction(qtarget).HitChance >= HitChance.High && E.GetPrediction(etarget).HitChance >= Hitch.hitchance(E, ComboMenu))
            {
                E.Cast(etarget);
            }

            if (ComboMenu.GetCheckBoxValue("wUse") && W.IsReady() && wtarget.IsValidTarget(SpellsManager.W.Range) && W.GetPrediction(wtarget).HitChance >= Hitch.hitchance(W, ComboMenu) && !Program.Champion.HasBuff("VelkozR"))
            {
                W.Cast(wtarget);
            }

            if (ComboMenu.GetCheckBoxValue("rUse") && R.IsReady())
            {
                foreach (var ultenemies in enemiese)
                {
                    var useR = ComboMenu["r.ult" + ultenemies.ChampionName].Cast <CheckBox>().CurrentValue;
                    {
                        if (useR)
                        {
                            R.Cast(ultenemies.Position);
                            Program.UltFollowMode();
                        }
                    }
                }
            }
        }
Example #12
0
        public static void Execute()
        {
            var target = EntityManager.MinionsAndMonsters.GetJungleMonsters().OrderByDescending(a => a.MaxHealth).FirstOrDefault(a => a.IsValidTarget(900));

            if (JungleClearMenu.GetCheckBoxValue("qUse") && Q.IsReady())
            {
                Program.Items();
                Q.Cast();
                Orbwalker.ForcedTarget = target;
            }
            if (JungleClearMenu.GetCheckBoxValue("wUse") && W.IsReady())
            {
                W.Cast();
            }
            if (JungleClearMenu.GetCheckBoxValue("eUse") && E.IsReady() && E.GetPrediction(target).HitChance >= Hitch.hitchance(E, FirstMenu))
            {
                E.Cast(target);
            }

            var save = JungleClearMenu.GetCheckBoxValue("JungleSave");

            if (_player.Mana != 5 || save)
            {
                return;
            }

            if (target.IsValidTarget(Q.Range) && Q.IsReady() &&
                FirstMenu.GetComboBoxValue("JunglePrio") == 0 && JungleClearMenu.GetCheckBoxValue("qUse"))
            {
                Q.Cast();
            }

            if (target.IsValidTarget(W.Range) && W.IsReady() &&
                FirstMenu.GetComboBoxValue("JunglePrio") == 1 && JungleClearMenu.GetCheckBoxValue("wUse") &&
                !_player.HasBuff("rengarpassivebuff"))
            {
                W.Cast();
            }

            Program.Items();

            if (target.IsValidTarget(E.Range) && E.IsReady() &&
                FirstMenu.GetComboBoxValue("JunglePrio") == 2 && JungleClearMenu.GetCheckBoxValue("eUse"))
            {
                E.Cast(target.ServerPosition);
            }
        }
Example #13
0
        public static void Execute()
        {
            var target   = TargetSelector.GetTarget(1500, DamageType.Magical);
            var etarget  = TargetSelector.GetTarget(E.Range, DamageType.Magical);
            var enemiese = EntityManager.Heroes.Enemies.OrderByDescending
                               (a => a.HealthPercent).Where(a => !a.IsMe && a.IsValidTarget() && a.Distance(Player) <= E.Range);

            if (ComboMenu.GetCheckBoxValue("eUse") && etarget.IsValidTarget(SpellsManager.E.Range) && E.IsReady() && E.GetPrediction(etarget).HitChance >= Hitch.hitchance(E, FirstMenu))
            {
                foreach (var eenemies in enemiese)
                {
                    var predE = E.GetPrediction(eenemies);
                    {
                        E.Cast(predE.CastPosition);
                    }
                }
            }

            if (ComboMenu.GetCheckBoxValue("qUse") && target.IsValidTarget(SpellsManager.Q.Range) && Q.IsReady())
            {
                Q.Cast();
            }

            if (ComboMenu.GetCheckBoxValue("wUse") && W.IsReady())
            {
                W.Cast();
            }

            if (ComboMenu.GetCheckBoxValue("wrUse") && W.IsReady() && target.IsValidTarget(SpellsManager.W.Range))
            {
                W.Cast();
            }

            var enemies = EntityManager.Heroes.Enemies.OrderByDescending(a => a.HealthPercent).Where(a => !a.IsMe && a.IsValidTarget() && a.Distance(_Player) <= R.Range);

            if (ComboMenu.GetCheckBoxValue("rUse") && ComboMenu.GetCheckBoxValue("manu.ult"))
            {
                return;
            }

            else if (ComboMenu.GetCheckBoxValue("rUse") && target.IsValidTarget(SpellsManager.R.Range) && R.IsReady())
            {
                foreach (var ultenemies in enemies)
                {
                    var useR = ComboMenu["r.ult" + ultenemies.ChampionName].Cast <CheckBox>().CurrentValue;
                    {
                        if (useR)
                        {
                            R.Cast(ultenemies);
                        }
                    }
                }
            }


            if (ComboMenu["gankc"].Cast <KeyBind>().CurrentValue)
            {
                if (W.IsReady())
                {
                    W.Cast();
                }

                if (ComboMenu.GetCheckBoxValue("eUse") && etarget.IsValidTarget(SpellsManager.E.Range) && E.IsReady() && E.GetPrediction(etarget).HitChance >= HitChance.High)
                {
                    E.Cast(etarget);
                }

                if (ComboMenu.GetCheckBoxValue("rUse") && target.IsValidTarget(SpellsManager.R.Range) && R.IsReady())
                {
                    foreach (var ultenemies in enemies)
                    {
                        var useR = ComboMenu["r.ult" + ultenemies.ChampionName].Cast <CheckBox>().CurrentValue;
                        {
                            if (useR)
                            {
                                R.Cast(ultenemies);
                            }
                        }
                    }
                }

                if (ComboMenu.GetCheckBoxValue("qUse") && target.IsValidTarget(SpellsManager.Q.Range) && Q.IsReady())
                {
                    Q.Cast();
                }
            }
        }
Example #14
0
        public static void Execute()
        {
            var ttarget = TargetSelector.GetTarget(1000, DamageType.Physical);

            if (E.IsReady() && Player.Instance.Mana == 5 && MiscMenu.GetCheckBoxValue("eflee") && E.GetPrediction(ttarget).HitChance >= Hitch.hitchance(E, FirstMenu))
            {
                var target = TargetSelector.GetTarget(1000, DamageType.Physical);
                E.Cast(target);
            }

            else if (E.IsReady() && MiscMenu.GetCheckBoxValue("eflee"))
            {
                var target = TargetSelector.GetTarget(1000, DamageType.Physical);
                E.Cast(target);
            }
        }
Example #15
0
        public static void Execute()
        {
            var enemiese = EntityManager.Heroes.Enemies.OrderByDescending
                               (a => a.HealthPercent).Where(a => !a.IsMe && a.IsValidTarget() && a.Distance(Player) <= E.Range);
            var target  = TargetSelector.GetTarget(1500, DamageType.Magical);
            var etarget = TargetSelector.GetTarget(E.Range, DamageType.Magical);

            if (HarassMenu.GetCheckBoxValue("eUse") && etarget.IsValidTarget(SpellsManager.E.Range) && E.IsReady() && E.GetPrediction(etarget).HitChance >= Hitch.hitchance(E, FirstMenu))
            {
                foreach (var eenemies in enemiese)
                {
                    var predE = E.GetPrediction(eenemies);
                    {
                        E.Cast(predE.CastPosition);
                    }
                }
            }
        }
Example #16
0
        public static void Execute()
        {
            //////////////////////////////////////////////////////////////////////////////////////////////////////////
            var target  = TargetSelector.GetTarget(1000, DamageType.Magical, Player.Instance.Position);
            var qtarget = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
            var wtarget = TargetSelector.GetTarget(W.Range, DamageType.Physical);
            var etarget = TargetSelector.GetTarget(E.Range, DamageType.Physical);
            var rtarget = TargetSelector.GetTarget(R.Range, DamageType.Physical);
            var targetW = TargetSelector.GetTarget(Player.Instance.BoundingRadius + 175, DamageType.Physical);
            //////////////////////////////////////////////////////////////////////////////////////////////////////////
            var quse = ComboMenu.GetCheckBoxValue("qUse");
            var wuse = ComboMenu.GetCheckBoxValue("wUse");
            var euse = ComboMenu.GetCheckBoxValue("eUse");
            var ruse = ComboMenu.GetCheckBoxValue("rUse");

            //////////////////////////////////////////////////////////////////////////////////////////////////////////
            if (ComboMenu.GetCheckBoxValue("cOne"))
            {
                if (target.IsValidTarget(1000) && quse && target.IsEnemy && Q.GetPrediction(target).HitChance >= Hitch.hitchance(Q, FirstMenu))
                {
                    Q.Cast(target.Position);
                }

                if (R.IsLearned && R.IsReady() && ruse && rtarget.IsStunned || rtarget.IsRooted || rtarget.IsTaunted || rtarget.IsCharmed || rtarget.Spellbook.IsChanneling ||
                    rtarget.HasBuffOfType(BuffType.Charm) || rtarget.HasBuffOfType(BuffType.Knockback) || rtarget.HasBuffOfType(BuffType.Knockup) ||
                    rtarget.HasBuffOfType(BuffType.Snare) || rtarget.HasBuffOfType(BuffType.Stun) || rtarget.HasBuffOfType(BuffType.Suppression) || // Credits Kappa the Kappa Def. not Kappa ^)
                    rtarget.HasBuffOfType(BuffType.Taunt))
                {
                    R.Cast();
                }

                if (W.IsLearned && W.IsReady() && wtarget.IsValidTarget(W.Range * 2) && wuse)
                {
                    Program.WEnable();
                }

                if (etarget.IsValidTarget(E.Range) && euse && E.IsReady())
                {
                    E.Cast();
                }
            }
            //////////////////////////////////////////////////////////////////////////////////////////////////////////
            if (ComboMenu.GetCheckBoxValue("cTwo"))
            {
                if (target.IsValidTarget(1000) && quse && target.IsEnemy && Q.GetPrediction(target).HitChance >= Hitch.hitchance(Q, FirstMenu))
                {
                    Q.Cast(target.Position);
                }

                if (R.IsLearned && R.IsReady() && ruse)
                {
                    if (Player.Instance.CountEnemiesInRange(R.Range) >= ComboMenu.GetSliderValue("enemyr"))
                    {
                        R.Cast();
                    }
                }

                if (W.IsLearned && W.IsReady() && wtarget.IsValidTarget(W.Range * 2) && wuse)
                {
                    Program.WEnable();
                }

                if (etarget.IsValidTarget(E.Range) && euse && E.IsReady())
                {
                    E.Cast();
                }
            }
            //////////////////////////////////////////////////////////////////////////////////////////////////////////
        }
Example #17
0
        public static void Execute()
        {
            var target  = TargetSelector.GetTarget(2000, DamageType.Physical);
            var rtarget = TargetSelector.GetTarget(R.Range, DamageType.Magical);
            var useQ    = HarassMenu.GetCheckBoxValue("qUse");
            var useW    = HarassMenu.GetCheckBoxValue("wUse");
            var useE    = HarassMenu.GetCheckBoxValue("eUse");
            var useR    = HarassMenu.GetCheckBoxValue("rUse");
            var useEE   = HarassMenu.GetCheckBoxValue("UseEEC");
            var tqq     = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
            var tee     = TargetSelector.GetTarget(E.Range, DamageType.Physical);

            if (useQ && tqq.IsValidTarget(SpellsManager.Q.Range) && Q.IsReady())
            {
                Q.Cast();
            }

            if (useE && tee.IsValidTarget(E.Range) && E.IsReady() && E.GetPrediction(tee).HitChance >= Hitch.hitchance(E, FirstMenu))
            {
                E.Cast(tee);
            }

            if (useW && tqq.IsValidTarget(SpellsManager.W.Range) && W.IsReady())
            {
                W.Cast();
            }
        }