private float Get_Ult_Dmg(Obj_AI_Base enemy)
        {
            var damage = 0d;

            if (DFG.IsReady())
            {
                damage += MyHero.GetItemDamage(enemy, Damage.DamageItems.Dfg) / 1.2;
            }
            if (R.IsReady())
            {
                damage += (3 + getOrbCount()) * MyHero.GetSpellDamage(enemy, SpellSlot.R, 1) - 20;
            }
            return((float)damage * (DFG.IsReady() ? 1.2f : 1));
        }
Beispiel #2
0
        private float GetComboDamage(Obj_AI_Base enemy)
        {
            double damage = 0d;

            if (DFG.IsReady())
            {
                damage += Player.GetItemDamage(enemy, Damage.DamageItems.Dfg) / 1.2;
            }

            if (Q.IsReady())
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.Q) + Player.GetSpellDamage(enemy, SpellSlot.Q, 1);
            }

            if (W.IsReady())
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.W);
            }

            if (E.IsReady())
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.E);
            }

            if (R.IsReady() || (rSpell.State == SpellState.Surpressed && R.Level > 0))
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.R) * 8;
            }

            if (DFG.IsReady())
            {
                damage = damage * 1.2;
            }

            if (IgniteSlot != SpellSlot.Unknown && Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
            {
                damage += Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
            }

            return((float)damage);
        }
Beispiel #3
0
        private void Cast_R()
        {
            var rTarget = SimpleTs.GetTarget(R.Level > 2 ? R.Range : 675, SimpleTs.DamageType.Magical);

            if (rTarget == null)
            {
                return;
            }
            if (Menu.Item("Dont_R" + rTarget.ChampionName) == null)
            {
                return;
            }
            if (Menu.Item("Dont_R" + rTarget.ChampionName).GetValue <bool>())
            {
                return;
            }
            if (Menu.Item("R_Overkill_Check").GetValue <bool>())
            {
                if (MyHero.GetSpellDamage(rTarget, SpellSlot.Q) > rTarget.Health)
                {
                }
                else if (Get_Ult_Dmg(rTarget) > rTarget.Health + 20 && rTarget.Distance(MyHero) < R.Range)
                {
                    if (DFG.IsReady())
                    {
                        Use_DFG(rTarget);
                    }

                    R.CastOnUnit(rTarget, UsePackets());
                }
            }
            else if (Get_Ult_Dmg(rTarget) > rTarget.Health - 20 && rTarget.Distance(MyHero) < R.Range)
            {
                if (DFG.IsReady())
                {
                    Use_DFG(rTarget);
                }

                R.CastOnUnit(rTarget, UsePackets());
            }
        }
Beispiel #4
0
        private void Cast_R()
        {
            var R_Target = SimpleTs.GetTarget(R.Level > 2 ? R.Range : 675, SimpleTs.DamageType.Magical);

            if (R_Target != null)
            {
                if (Menu.Item("Dont_R" + R_Target.BaseSkinName) != null)
                {
                    if (!Menu.Item("Dont_R" + R_Target.BaseSkinName).GetValue <bool>())
                    {
                        if (Menu.Item("R_Overkill_Check").GetValue <bool>())
                        {
                            if (MyHero.GetSpellDamage(R_Target, SpellSlot.Q) > R_Target.Health)
                            {
                            }
                            else if (Get_Ult_Dmg(R_Target) > R_Target.Health + 20 && R_Target.Distance(MyHero) < R.Range)
                            {
                                if (DFG.IsReady())
                                {
                                    Use_DFG(R_Target);
                                }

                                R.CastOnUnit(R_Target, UsePackets());
                            }
                        }
                        else if (Get_Ult_Dmg(R_Target) > R_Target.Health - 20 && R_Target.Distance(MyHero) < R.Range)
                        {
                            if (DFG.IsReady())
                            {
                                Use_DFG(R_Target);
                            }

                            R.CastOnUnit(R_Target, UsePackets());
                        }
                    }
                }
            }
        }
Beispiel #5
0
        public void SmartKs()
        {
            if (!menu.Item("smartKS").GetValue <bool>())
            {
                return;
            }

            if (menu.Item("rCancel").GetValue <bool>() && countEnemiesNearPosition(Player.ServerPosition, 570) > 1)
            {
                return;
            }

            foreach (Obj_AI_Hero target in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(1375) && x.IsEnemy && !x.IsDead).OrderByDescending(GetComboDamage))
            {
                if (target != null && !target.HasBuffOfType(BuffType.Invulnerability) &&
                    target.IsValidTarget(1375))
                {
                    var  delay   = menu.Item("E_Delay_Slider").GetValue <Slider>().Value;
                    bool shouldE = !menu.Item("KS_With_E").GetValue <KeyBind>().Active&& Environment.TickCount - E.LastCastAttemptT > 0;
                    //QEW
                    if (Player.Distance(target.ServerPosition) <= E.Range && shouldE &&
                        (Player.GetSpellDamage(target, SpellSlot.E) + Player.GetSpellDamage(target, SpellSlot.Q) +
                         Player.GetSpellDamage(target, SpellSlot.W)) > target.Health + 20)
                    {
                        if (E.IsReady() && Q.IsReady() && W.IsReady())
                        {
                            CancelUlt(target);
                            Q.Cast(target, packets());
                            E.Cast(target, packets());
                            E.LastCastAttemptT = Environment.TickCount + delay;
                            if (Player.Distance(target.ServerPosition) < W.Range)
                            {
                                W.Cast();
                            }
                            return;
                        }
                    }

                    //E + W
                    if (Player.Distance(target.ServerPosition) <= E.Range && shouldE &&
                        (Player.GetSpellDamage(target, SpellSlot.E) + Player.GetSpellDamage(target, SpellSlot.W)) >
                        target.Health + 20)
                    {
                        if (E.IsReady() && W.IsReady())
                        {
                            CancelUlt(target);
                            E.Cast(target, packets());
                            E.LastCastAttemptT = Environment.TickCount + delay;
                            if (Player.Distance(target.ServerPosition) < W.Range)
                            {
                                W.Cast();
                            }
                            //Game.PrintChat("ks 5");
                            return;
                        }
                    }

                    //E + Q
                    if (Player.Distance(target.ServerPosition) <= E.Range && shouldE &&
                        (Player.GetSpellDamage(target, SpellSlot.E) + Player.GetSpellDamage(target, SpellSlot.Q)) >
                        target.Health + 20)
                    {
                        if (E.IsReady() && Q.IsReady())
                        {
                            CancelUlt(target);
                            E.Cast(target, packets());
                            E.LastCastAttemptT = Environment.TickCount + delay;
                            Q.Cast(target, packets());
                            //Game.PrintChat("ks 6");
                            return;
                        }
                    }

                    //Q
                    if ((Player.GetSpellDamage(target, SpellSlot.Q)) > target.Health + 20)
                    {
                        if (Q.IsReady() && Player.Distance(target.ServerPosition) <= Q.Range)
                        {
                            CancelUlt(target);
                            Q.Cast(target, packets());
                            //Game.PrintChat("ks 7");
                            return;
                        }
                        if (Q.IsReady() && E.IsReady() && Player.Distance(target.ServerPosition) <= 1375 &&
                            menu.Item("wardKs").GetValue <bool>() &&
                            countEnemiesNearPosition(target.ServerPosition, 500) < 3)
                        {
                            CancelUlt(target);
                            JumpKs(target);
                            //Game.PrintChat("wardKS!!!!!");
                            return;
                        }
                    }

                    //E
                    if (Player.Distance(target.ServerPosition) <= E.Range && shouldE &&
                        (Player.GetSpellDamage(target, SpellSlot.E)) > target.Health + 20)
                    {
                        if (E.IsReady())
                        {
                            CancelUlt(target);
                            E.Cast(target, packets());
                            E.LastCastAttemptT = Environment.TickCount + delay;
                            //Game.PrintChat("ks 8");
                            return;
                        }
                    }

                    //R
                    if (Player.Distance(target.ServerPosition) <= E.Range &&
                        (Player.GetSpellDamage(target, SpellSlot.R) * 5) > target.Health + 20 &&
                        menu.Item("rKS").GetValue <bool>())
                    {
                        if (R.IsReady())
                        {
                            R.Cast();
                            //Game.PrintChat("ks 8");
                            return;
                        }
                    }

                    //dfg
                    if (DFG.IsReady() && Player.GetItemDamage(target, Damage.DamageItems.Dfg) > target.Health + 20 &&
                        Player.Distance(target.ServerPosition) <= 750)
                    {
                        Items.UseItem(DFG.Id, target);
                        //Game.PrintChat("ks 1");
                        return;
                    }

                    //dfg + q
                    if (Player.Distance(target.ServerPosition) <= Q.Range &&
                        (Player.GetItemDamage(target, Damage.DamageItems.Dfg) +
                         (Player.GetSpellDamage(target, SpellSlot.Q)) * 1.2) > target.Health + 20)
                    {
                        if (DFG.IsReady() && Q.IsReady())
                        {
                            Items.UseItem(DFG.Id, target);
                            CancelUlt(target);
                            Q.Cast(target, packets());
                            //Game.PrintChat("ks 2");
                            return;
                        }
                    }

                    //dfg + e
                    if (Player.Distance(target.ServerPosition) <= E.Range &&
                        (Player.GetItemDamage(target, Damage.DamageItems.Dfg) +
                         (Player.GetSpellDamage(target, SpellSlot.E)) * 1.2) > target.Health + 20)
                    {
                        if (DFG.IsReady() && E.IsReady())
                        {
                            Items.UseItem(DFG.Id, target);
                            CancelUlt(target);
                            E.Cast(target, packets());
                            E.LastCastAttemptT = Environment.TickCount + delay;
                            //Game.PrintChat("ks 3");
                            return;
                        }
                    }

                    //ignite
                    if (menu.Item("ignite").GetValue <bool>() && IgniteSlot != SpellSlot.Unknown &&
                        Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready &&
                        Player.Distance(target.ServerPosition) <= 600)
                    {
                        if (Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) > target.Health)
                        {
                            Player.SummonerSpellbook.CastSpell(IgniteSlot, target);
                        }
                    }
                }
            }
        }
Beispiel #6
0
        private void Combo(bool useQ, bool useW, bool useE, bool useR)
        {
            Obj_AI_Hero target = SimpleTs.GetTarget(E.Range, SimpleTs.DamageType.Magical);

            int mode       = menu.Item("comboMode").GetValue <StringList>().SelectedIndex;
            int igniteMode = menu.Item("igniteMode").GetValue <StringList>().SelectedIndex;

            int eDis = menu.Item("eDis").GetValue <Slider>().Value;

            var range = E.Range;

            if (GetTargetFocus(range) != null)
            {
                target = GetTargetFocus(range);
            }

            if (!target.HasBuffOfType(BuffType.Invulnerability) && target.IsValidTarget(E.Range))
            {
                if (mode == 0) //qwe
                {
                    if (DFG != null && (DFG.IsReady() && E.IsReady() && menu.Item("dfg").GetValue <bool>()))
                    {
                        Items.UseItem(DFG.Id, target);
                    }

                    if (useQ && Q.IsReady() && Player.Distance(target) <= Q.Range)
                    {
                        Q.Cast(target, packets());
                    }

                    if (useE && E.IsReady() && Player.Distance(target) < E.Range && Environment.TickCount - E.LastCastAttemptT > 0 &&
                        Player.Distance(target) > eDis)
                    {
                        if (menu.Item("smartE").GetValue <bool>() &&
                            countEnemiesNearPosition(target.ServerPosition, 500) > 2 &&
                            (!R.IsReady() || !(rSpell.State == SpellState.Surpressed && R.Level > 0)))
                        {
                            return;
                        }

                        var delay = menu.Item("E_Delay_Slider").GetValue <Slider>().Value;
                        E.Cast(target, packets());
                        E.LastCastAttemptT = Environment.TickCount + delay;
                    }
                }
                else if (mode == 1) //eqw
                {
                    if (DFG.IsReady() && E.IsReady() && menu.Item("dfg").GetValue <bool>())
                    {
                        Items.UseItem(DFG.Id, target);
                    }

                    if (useE && E.IsReady() && Player.Distance(target) < E.Range && Environment.TickCount - E.LastCastAttemptT > 0 &&
                        Player.Distance(target) > eDis)
                    {
                        if (menu.Item("smartE").GetValue <bool>() &&
                            countEnemiesNearPosition(target.ServerPosition, 500) > 2 &&
                            (!R.IsReady() || !(rSpell.State == SpellState.Surpressed && R.Level > 0)))
                        {
                            return;
                        }

                        var delay = menu.Item("E_Delay_Slider").GetValue <Slider>().Value;
                        E.Cast(target, packets());
                        E.LastCastAttemptT = Environment.TickCount + delay;
                    }

                    if (useQ && Q.IsReady() && Player.Distance(target) <= Q.Range)
                    {
                        Q.Cast(target, packets());
                    }
                }

                //Ignite
                if (menu.Item("ignite").GetValue <bool>() && IgniteSlot != SpellSlot.Unknown &&
                    Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
                {
                    if (igniteMode == 0 && GetComboDamage(target) > target.Health)
                    {
                        Player.SummonerSpellbook.CastSpell(IgniteSlot, target);
                    }
                }

                if (useW && W.IsReady() && Player.Distance(target) <= W.Range)
                {
                    W.Cast();
                }

                if (useR && R.IsReady() &&
                    countEnemiesNearPosition(Player.ServerPosition, R.Range) > 0)
                {
                    if (!Q.IsReady() && !E.IsReady() && !W.IsReady())
                    {
                        R.Cast();
                    }
                }
            }
        }
Beispiel #7
0
        public void CheckKs()
        {
            foreach (Obj_AI_Hero target in ObjectManager.Get <Obj_AI_Hero>().Where(x => Player.Distance(x) < 1300 && x.IsValidTarget() && x.IsEnemy && !x.IsDead))
            {
                if (target != null)
                {
                    if (DFG.IsReady() && Player.GetItemDamage(target, Damage.DamageItems.Dfg) > target.Health &&
                        Player.Distance(target.ServerPosition) <= 750)
                    {
                        Use_DFG(target);
                        return;
                    }

                    if (DFG.IsReady() && Player.Distance(target.ServerPosition) <= 750 && Q.IsReady() &&
                        (Player.GetItemDamage(target, Damage.DamageItems.Dfg) +
                         (Player.GetSpellDamage(target, SpellSlot.Q) + Player.GetSpellDamage(target, SpellSlot.Q, 1)) *
                         1.2) > target.Health)
                    {
                        Use_DFG(target);
                        Q.Cast(target, packets());
                        return;
                    }

                    if (DFG.IsReady() && Player.Distance(target.ServerPosition) <= 750 && W.IsReady() &&
                        (Player.GetItemDamage(target, Damage.DamageItems.Dfg) +
                         Player.GetSpellDamage(target, SpellSlot.W) * 1.2) > target.Health)
                    {
                        Use_DFG(target);
                        W.Cast();
                        return;
                    }

                    if (Player.Distance(target.ServerPosition) <= W.Range &&
                        (Player.GetSpellDamage(target, SpellSlot.Q) + Player.GetSpellDamage(target, SpellSlot.Q, 1) +
                         Player.GetSpellDamage(target, SpellSlot.W)) > target.Health && Q.IsReady() && Q.IsReady())
                    {
                        Q.Cast(target, packets());
                        return;
                    }

                    if (Player.Distance(target.ServerPosition) <= Q.Range &&
                        (Player.GetSpellDamage(target, SpellSlot.Q) + Player.GetSpellDamage(target, SpellSlot.Q, 1)) >
                        target.Health && Q.IsReady())
                    {
                        Q.Cast(target, packets());
                        return;
                    }

                    if (Player.Distance(target.ServerPosition) <= E.Range &&
                        (Player.GetSpellDamage(target, SpellSlot.E)) > target.Health & E.IsReady())
                    {
                        E.Cast(target, packets());
                        return;
                    }

                    if (Player.Distance(target.ServerPosition) <= W.Range &&
                        (Player.GetSpellDamage(target, SpellSlot.W)) > target.Health && W.IsReady())
                    {
                        W.Cast();
                        return;
                    }

                    Vector3 dashVector = Player.Position +
                                         Vector3.Normalize(target.ServerPosition - Player.Position) * 425;
                    if (Player.Distance(target.ServerPosition) <= R.Range &&
                        (Player.GetSpellDamage(target, SpellSlot.R)) > target.Health && R.IsReady() && _rOn &&
                        target.Distance(dashVector) < 425 && R.IsReady())
                    {
                        R.Cast(dashVector, packets());
                    }

                    //ignite
                    if (menu.Item("ignite").GetValue <bool>() && IgniteSlot != SpellSlot.Unknown &&
                        Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready &&
                        Player.Distance(target.ServerPosition) <= 600)
                    {
                        if (Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) > target.Health + 20)
                        {
                            Use_Ignite(target);
                        }
                    }
                }
            }
        }
Beispiel #8
0
        private void UseSpells(bool useQ, bool useW, bool useE, bool useR, string source)
        {
            var         range   = Q.Range;
            Obj_AI_Hero eTarget = SimpleTs.GetTarget(range, SimpleTs.DamageType.Magical);


            if (GetTargetFocus(range) != null)
            {
                eTarget = GetTargetFocus(range);
            }

            Obj_AI_Hero rETarget = SimpleTs.GetTarget(E.Range, SimpleTs.DamageType.Magical);

            int igniteMode;

            igniteMode = menu.Item("igniteMode").GetValue <StringList>().SelectedIndex;

            var hitC = GetHitchance(source);
            var dmg  = GetComboDamage(eTarget);

            //DFG
            if (eTarget != null && dmg > eTarget.Health - 300 && DFG.IsReady() && source == "Combo" && Player.Distance(eTarget) <= 750 &&
                (eTarget.HasBuffOfType(BuffType.Charm) || !menu.Item("dfgCharm").GetValue <bool>()))
            {
                Use_DFG(eTarget);
            }

            //E
            if (useE && eTarget != null && E.IsReady() && Player.Distance(eTarget) < E.Range &&
                E.GetPrediction(eTarget).Hitchance >= hitC)
            {
                E.Cast(eTarget, packets());
                if (menu.Item("EQ").GetValue <bool>() && Q.IsReady())
                {
                    Q.Cast(eTarget, packets());
                }
                return;
            }

            //Ignite
            if (eTarget != null && Ignite_Ready() && !E.IsReady() && source == "Combo")
            {
                if (igniteMode == 0 && dmg > eTarget.Health)
                {
                    Use_Ignite(eTarget);
                }
            }

            //W
            if (useW && eTarget != null && W.IsReady() && Player.Distance(eTarget) <= W.Range - 100 &&
                ShouldW(eTarget, source))
            {
                W.Cast();
            }
            if (source == "Harass" && menu.Item("longQ").GetValue <bool>())
            {
                if (useQ && Q.IsReady() && Player.Distance(eTarget) <= Q.Range && eTarget != null &&
                    ShouldQ(eTarget, source) && Player.Distance(eTarget) > 600)
                {
                    if (Q.GetPrediction(eTarget).Hitchance >= hitC)
                    {
                        Q.Cast(eTarget, packets(), true);
                        return;
                    }
                }
            }
            else if (useQ && Q.IsReady() && Player.Distance(eTarget) <= Q.Range && eTarget != null &&
                     ShouldQ(eTarget, source))
            {
                if (Q.GetPrediction(eTarget).Hitchance >= hitC)
                {
                    Q.Cast(eTarget, packets(), true);
                    return;
                }
            }

            //R
            if (useR && eTarget != null && R.IsReady() && Player.Distance(eTarget) < R.Range)
            {
                if (E.IsReady())
                {
                    if (CheckReq(rETarget))
                    {
                        E.Cast(rETarget, packets());
                    }
                }
                if (ShouldR(eTarget) && R.IsReady())
                {
                    R.Cast(Game.CursorPos, packets());
                    _rTimer = Environment.TickCount - 250;
                }
                if (_rTimeLeft > 9500 && _rOn && R.IsReady())
                {
                    R.Cast(Game.CursorPos, packets());
                    _rTimer = Environment.TickCount - 250;
                }
            }
        }
Beispiel #9
0
        private float GetComboDamage(Obj_AI_Base enemy)
        {
            double damage = 0d;

            if (Q.IsReady())
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.Q);
                damage += Player.GetSpellDamage(enemy, SpellSlot.Q, 1);
            }

            if (DFG.IsReady())
            {
                damage += Player.GetItemDamage(enemy, Damage.DamageItems.Dfg) / 1.2;
            }

            if (W.IsReady())
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.W);
            }

            if (_rOn)
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.R) * RCount();
            }
            else if (R.IsReady())
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.R) * 3;
            }

            if (DFG.IsReady() && E.IsReady())
            {
                damage = damage * 1.44;
            }
            else if (DFG.IsReady() && enemy.HasBuffOfType(BuffType.Charm))
            {
                damage = damage * 1.44;
            }
            else if (E.IsReady())
            {
                damage = damage * 1.2;
            }
            else if (DFG.IsReady())
            {
                damage = damage * 1.2;
            }
            else if (enemy.HasBuffOfType(BuffType.Charm))
            {
                damage = damage * 1.2;
            }

            if (Ignite_Ready())
            {
                damage += Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
            }

            if (E.IsReady())
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.E);
            }

            return((float)damage);
        }
Beispiel #10
0
        private static void doCombo()
        {
            try
            {
                // Menu Config
                var FeroSpell = Config.Item("FeroSpellC").GetValue <StringList>();
                var ForceW    = Config.Item("ForceWC").GetValue <Slider>();
                var ForceE    = Config.Item("ForceEC").GetValue <bool>();

                var Target = SimpleTs.GetSelectedTarget() ?? SimpleTs.GetTarget(1600f, SimpleTs.DamageType.Physical);

                // Force Leap to target
                if (Player.HasBuff("RengarR", true))
                {
                    LXOrbwalker.ForcedTarget = Target;
                    LXOrbwalker.SetAttack(LXOrbwalker.GetPossibleTarget() == Target);
                }

                // Use Tiamat / Hydra
                if (Target.IsValidTarget(TMT.Range))
                {
                    if (TMT.IsReady())
                    {
                        TMT.Cast();
                    }
                    else if (HYD.IsReady())
                    {
                        HYD.Cast();
                    }
                }

                // Use Yommus Ghostblade
                if (YGB.IsReady() && Target.IsValidTarget(Orbwalking.GetRealAutoAttackRange(Player) + (Player.HasBuff("RengarR", true) ? Player.MoveSpeed / 2 : 0)))
                {
                    YGB.Cast();
                }

                // Cutlass
                if (BCL.IsReady() && Target.IsValidTarget(BCL.Range))
                {
                    BCL.Cast(Target);
                }

                // BORK
                if (BRK.IsReady() && Target.IsValidTarget(BRK.Range))
                {
                    BRK.Cast(Target);
                }

                // DFG
                if (W.IsReady() && DFG.IsReady() && Target.IsValidTarget(DFG.Range))
                {
                    DFG.Cast(Target);
                }

                // Ferocity Spell
                if (Player.Mana == 5)
                {
                    if (Player.Health / Player.MaxHealth < ForceW.Value / 100f && Target.IsValidTarget(W.Range))
                    {
                        W.CastOnUnit(Player, UsePackets);
                        return;
                    }

                    switch (FeroSpell.SelectedIndex)
                    {
                    case 1:
                        if (!Target.IsValidTarget(W.Range))
                        {
                            return;
                        }
                        W.CastOnUnit(Player, UsePackets);
                        break;

                    case 2:
                        if (!Target.IsValidTarget(E.Range) || Player.HasBuff("RengarR", true))
                        {
                            return;
                        }
                        E.Cast(Target, UsePackets);
                        break;
                    }
                    return;
                }

                // Don't cast W or E while ultimate is active (force leap)
                if (Player.HasBuff("RengarR", true))
                {
                    return;
                }

                if (E.IsReady() && Target.IsValidTarget(E.Range) &&
                    (!Target.HasBuff("RengarEFinalMAX", true) && !Target.HasBuff("rengareslow") &&
                     LastETick + 1500 < Environment.TickCount || ForceE))
                {
                    E.Cast(Target, UsePackets);
                }

                if (W.IsReady() && Target.IsValidTarget(W.Range))
                {
                    W.CastOnUnit(Player, UsePackets);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Combo Exception: {0}", e);
            }
        }