Example #1
0
        private void Farm()
        {
            if (!ManaManager.HasMana("LaneClear"))
            {
                return;
            }

            var useQ = Menu.Item("UseQFarm", true).GetValue <bool>();
            var useE = Menu.Item("UseEFarm", true).GetValue <bool>();
            var useR = Menu.Item("UseRFarm", true).GetValue <bool>();

            if (useQ)
            {
                SpellCastManager.CastBasicFarm(Q);
            }

            if (useR)
            {
                Cast_R(3);
            }

            if (useE)
            {
                var allMinionECount = MinionManager.GetMinions(Player.ServerPosition, E.Range, MinionTypes.All, MinionTeam.NotAlly).Count;

                if (allMinionECount > 1)
                {
                    E.Cast();
                }
            }
        }
Example #2
0
        private void Farm()
        {
            if (!ManaManager.HasMana("LaneClear"))
            {
                return;
            }

            var useQ = Menu.Item("UseQFarm", true).GetValue <bool>();
            var useW = Menu.Item("UseWFarm", true).GetValue <bool>();
            var useE = Menu.Item("UseEFarm", true).GetValue <bool>();

            if (useQ)
            {
                SpellCastManager.CastBasicFarm(Q);
            }

            if (useW)
            {
                Cast_W(false);
            }

            if (useE)
            {
                SpellCastManager.CastBasicFarm(E);
            }
        }
Example #3
0
        private void Farm()
        {
            if (!ManaManager.HasMana("LaneClear"))
            {
                return;
            }

            List <Obj_AI_Base> allMinionsQ = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, W.Range,
                                                                      MinionTypes.All, MinionTeam.NotAlly);

            var useQ = menu.Item("UseQFarm", true).GetValue <bool>();
            var useW = menu.Item("UseWFarm", true).GetValue <bool>();

            if (useQ && allMinionsQ.Count > 0)
            {
                var qMin = menu.Item("Q_Min_Stack", true).GetValue <Slider>().Value;

                if (qMin <= QStacks)
                {
                    Q.Cast();
                }
            }

            if (useW)
            {
                SpellCastManager.CastBasicFarm(W);
            }
        }
Example #4
0
        private void Harass()
        {
            if (!ManaManager.HasMana("Harass"))
            {
                return;
            }

            var target = TargetSelector.GetTarget(Q2.Range, TargetSelector.DamageType.Physical);

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

            if (Menu.Item("UseWHarass", true).GetValue <bool>() && W.IsReady())
            {
                Cast_W(target);
            }

            if (Menu.Item("UseEHarass", true).GetValue <bool>() && E.IsReady())
            {
                SpellCastManager.CastBasicSkillShot(E, E.Range, TargetSelector.DamageType.Physical, HitChance.VeryHigh);
            }

            if (Menu.Item("UseQHarass", true).GetValue <bool>() && Q.IsReady())
            {
                if (Player.ServerPosition.Distance(target.ServerPosition) > E.Range || !E.IsReady() || !Menu.Item("ForceE", true).GetValue <bool>())
                {
                    Cast_Q(target);
                }
            }
        }
Example #5
0
        private void Harass()
        {
            if (!ManaManager.HasMana("Harass"))
            {
                return;
            }

            if (Menu.Item("UseWHarass", true).GetValue <bool>() && W.IsReady())
            {
                if (ShouldW())
                {
                    SpellCastManager.CastBasicSkillShot(W, W.Range, TargetSelector.DamageType.Magical,
                                                        HitChance.VeryHigh);
                }
            }

            if (Menu.Item("UseQHarass", true).GetValue <bool>() && Q.IsReady())
            {
                SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Magical,
                                                    HitChance.VeryHigh);
            }

            if (Menu.Item("UseEHarass", true).GetValue <bool>() && E.IsReady() && ESpell.ToggleState == 1 && HasManaForE("Harass") &&
                Utils.TickCount - E.LastCastAttemptT > 500)
            {
                var target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Magical);

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

                E.Cast();
            }
        }
Example #6
0
        private void AutoQ()
        {
            var qDashing = Menu.Item("qImmo", true).GetValue <bool>();
            var qImmo    = Menu.Item("qDash", true).GetValue <bool>();

            if (!Q.IsReady())
            {
                return;
            }

            if (!qDashing && !qImmo)
            {
                return;
            }

            foreach (var target in ObjectManager.Get <AIHeroClient>().Where(x => x.IsValidTarget(Q.Range)))
            {
                if ((Q.GetPrediction(target).Hitchance == HitChance.Immobile || IsStunned(target)) && qImmo && Player.Distance(target.Position) < Q.Range)
                {
                    SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Magical, HitChance.VeryHigh);
                    return;
                }

                if (Q.GetPrediction(target).Hitchance == HitChance.Dashing && qDashing && Player.Distance(target.Position) < Q.Range)
                {
                    SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Magical, HitChance.VeryHigh);
                }
            }
        }
Example #7
0
        private void Harass()
        {
            if (!ManaManager.HasMana("Harass"))
            {
                return;
            }

            if (Menu.Item("UseRHarass", true).GetValue <bool>() && R.IsReady())
            {
                Cast_R("Harass");
            }

            if (Menu.Item("UseQHarass", true).GetValue <bool>() && Q.IsReady())
            {
                SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Magical, HitChance.VeryHigh);
            }

            if (Menu.Item("UseEHarass", true).GetValue <bool>() && E.IsReady())
            {
                SpellCastManager.CastBasicSkillShot(E, E.Range, TargetSelector.DamageType.Physical, HitChance.VeryHigh);
            }

            if (Menu.Item("UseWHarass", true).GetValue <bool>() && W.IsReady())
            {
                var target = TargetSelector.GetTarget(Player.AttackRange + new[] { 130, 150, 170, 190, 210 }[W.Level - 1], TargetSelector.DamageType.Magical);

                if (target.IsValidTarget(Player.AttackRange + new[] { 90, 120, 150, 180, 210 }[W.Level - 1]))
                {
                    W.Cast();
                }
            }
        }
Example #8
0
        private void Harass()
        {
            if (!ManaManager.HasMana("Harass"))
            {
                return;
            }

            var target = TargetSelector.GetTarget(Orbwalking.GetRealAutoAttackRange(Player), TargetSelector.DamageType.Physical);

            if (target.IsValidTarget())
            {
                if (Menu.Item("UseQHarass", true).GetValue <bool>() && Q.IsReady() &&
                    Player.ServerPosition.Distance(target.ServerPosition) < 550)
                {
                    var qMin = Menu.Item("Q_Min_Stack", true).GetValue <Slider>().Value;

                    if (qMin <= QStacks)
                    {
                        Q.Cast();
                    }
                }
            }

            if (Menu.Item("UseWHarass", true).GetValue <bool>() && W.IsReady())
            {
                SpellCastManager.CastBasicSkillShot(W, W.Range, TargetSelector.DamageType.Magical, HitChance.VeryHigh);
            }
        }
Example #9
0
        private void Farm()
        {
            if (!ManaManager.HasMana("LaneClear"))
            {
                return;
            }

            var useQ = menu.Item("UseQFarm", true).GetValue <bool>();
            var useE = menu.Item("UseEFarm", true).GetValue <bool>();
            var useR = menu.Item("UseRFarm", true).GetValue <bool>();

            if (useQ)
            {
                var minion = MinionManager.GetMinions(Player.ServerPosition, Q.Range, MinionTypes.All,
                                                      MinionTeam.NotAlly);

                if (minion.Count > 0)
                {
                    Q.Cast(minion[0]);
                }
            }
            if (useR)
            {
                Cast_R("Farm");
            }
            if (useE)
            {
                SpellCastManager.CastBasicFarm(E);
            }
        }
Example #10
0
        private void Harass()
        {
            if (!ManaManager.HasMana("Harass"))
            {
                return;
            }

            if (Menu.Item("UseQEHarass", true).GetValue <bool>())
            {
                Cast_QE();
            }

            if (Menu.Item("UseQHarass", true).GetValue <bool>())
            {
                SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Magical, HitChance.VeryHigh);
            }

            if (Menu.Item("UseEHarass", true).GetValue <bool>())
            {
                Cast_E();
            }

            if (Menu.Item("UseWHarass", true).GetValue <bool>())
            {
                Cast_W(true);
            }
        }
Example #11
0
        private void Harass()
        {
            if (!ManaManager.HasMana("Harass"))
            {
                return;
            }

            var qTarget = TargetSelector.GetTarget(QExtend.Range, TargetSelector.DamageType.Magical);
            var eTarget = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Magical);

            if (Menu.Item("UseEHarass", true).GetValue <bool>() && eTarget != null && E.IsReady() && Player.Distance(eTarget.Position) < E.Range && ShouldE(eTarget))
            {
                SpellCastManager.CastBasicSkillShot(E, E.Range, TargetSelector.DamageType.Magical, HitChance.VeryHigh);
            }

            if (Menu.Item("UseWHarass", true).GetValue <bool>() && qTarget != null && W.IsReady())
            {
                if (W.GetPrediction(qTarget).Hitchance > HitChance.High && Player.Distance(qTarget.Position) <= W.Width)
                {
                    W.Cast();
                }
            }

            if (Menu.Item("UseQHarass", true).GetValue <bool>() && Q.IsReady() && qTarget != null)
            {
                CastQ();
            }
        }
Example #12
0
        protected override void Game_OnGameUpdate(EventArgs args)
        {
            //check if player is dead
            if (Player.IsDead)
            {
                return;
            }

            SpellCastManager.CastBestLine(false, E, E2, (int)(E2.Range / 2), menu);

            AutoR();


            if (menu.Item("ComboActive", true).GetValue <KeyBind>().Active)
            {
                Combo();
            }
            else
            {
                if (menu.Item("LastHitQQ", true).GetValue <KeyBind>().Active)
                {
                    LastHit();
                }

                if (menu.Item("LaneClearActive", true).GetValue <KeyBind>().Active)
                {
                    Farm();
                }

                if (menu.Item("HarassActive", true).GetValue <KeyBind>().Active || menu.Item("HarassActiveT", true).GetValue <KeyBind>().Active)
                {
                    Harass();
                }
            }
        }
Example #13
0
        private void Farm()
        {
            var allMinionsQ = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, Q.Range + Q.Width, MinionTypes.All, MinionTeam.NotAlly);

            var useQ = Menu.Item("UseQFarm", true).GetValue <bool>();
            var useE = Menu.Item("UseEFarm", true).GetValue <bool>();

            if (useQ && allMinionsQ.Count > 0 && Q.IsReady())
            {
                Q.Cast(allMinionsQ[0]);
            }

            var minionsE = MinionManager.GetMinions(Player.ServerPosition, E.Range, MinionTypes.All, MinionTeam.NotAlly);

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

            var minionsE2 = MinionManager.GetMinions(minionsE[0].ServerPosition, E.Range, MinionTypes.All, MinionTeam.NotAlly);
            var points    = minionsE2.Select(x => x.ServerPosition.To2D()).ToList();

            if (useE && E.IsReady() && minionsE.Count > 0)
            {
                E2.UpdateSourcePosition(minionsE[0].ServerPosition, minionsE[0].ServerPosition);

                var pred = GetBestLineFarmLocation(minionsE[0].ServerPosition.To2D(), points, E.Width, E2.Range);
                var min  = Menu.Item("MinMinion", true).GetValue <Slider>().Value;

                if (pred.MinionsHit >= min)
                {
                    SpellCastManager.CastLineSpell(minionsE[0].Position, pred.Position.To3D());
                }
            }
        }
Example #14
0
        private void Harass()
        {
            var range  = E.IsReady() ? E.Range + E2.Range : Q.Range;
            var target = TargetSelector.GetTarget(range, TargetSelector.DamageType.Magical);

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

            var dmg = GetComboDamage(target);

            if (Menu.Item("UseEHarass", true).GetValue <bool>() && E.IsReady())
            {
                SpellCastManager.CastBestLine(true, E, E2, (int)(E2.Range / 2), Menu, 1, false);
            }

            if (Menu.Item("QAARange", true).GetValue <bool>())
            {
                if (Menu.Item("UseQHarass", true).GetValue <bool>() && target != null && Q.IsReady() &&
                    Player.ServerPosition.Distance(target.ServerPosition) <= Player.AttackRange) // Q only in AA range for guaranteed AutoAttack
                {
                    Q.Cast(target);
                }
            }
            else if (Menu.Item("UseQHarass", true).GetValue <bool>() && Q.IsReady() && Player.ServerPosition.Distance(target.ServerPosition) <= Q.Range)
            {
                Q.Cast(target);
            }
        }
Example #15
0
        private void Harass()
        {
            if (!ManaManager.HasMana("Harass"))
            {
                return;
            }

            if (Menu.Item("UseQHarass", true).GetValue <bool>() && Q.IsReady())
            {
                var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
                if (target.IsValidTarget(Q.Range))
                {
                    var pred = Prediction.GetPrediction(target, 625);

                    if (pred.Hitchance >= HitChance.VeryHigh && target.IsMoving)
                    {
                        Q.Cast(pred.UnitPosition);
                    }
                }
            }

            if (Menu.Item("UseWHarass", true).GetValue <bool>() && W.IsReady())
            {
                SpellCastManager.CastBasicSkillShot(W, W.Range, TargetSelector.DamageType.Magical, HitChance.VeryHigh);
            }
        }
Example #16
0
        private void Farm()
        {
            if (!ManaManager.HasMana("Farm"))
            {
                return;
            }

            var allMinionsE = MinionManager.GetMinions(Player.ServerPosition, E.Range,
                                                       MinionTypes.All, MinionTeam.NotAlly);

            var useQ = Menu.Item("UseQFarm", true).GetValue <bool>();
            var useE = Menu.Item("UseEFarm", true).GetValue <bool>();

            if (useQ && Q.IsReady())
            {
                SpellCastManager.CastBasicFarm(Q);
            }

            if (useE && allMinionsE.Count > 0 && E.IsReady() && ESpell.ToggleState == 1)
            {
                var ePos = E.GetCircularFarmLocation(allMinionsE);

                if (ePos.MinionsHit > 1)
                {
                    E.Cast();
                }
            }
        }
Example #17
0
        protected override void Drawing_OnDraw(EventArgs args)
        {
            if (Menu.Item("Draw_Disabled", true).GetValue <bool>())
            {
                return;
            }

            if (Menu.Item("Draw_Q", true).GetValue <bool>())
            {
                if (Q.Level > 0)
                {
                    Render.Circle.DrawCircle(Player.Position, 600, Q.IsReady() ? Color.Green : Color.Red);
                    var pos = ObjectManager.Player.Position.To2D() + 600 * ObjectManager.Player.Direction.To2D().Perpendicular();
                    Drawing.DrawCircle(pos.To3D(), 50, Q.IsReady() ? Color.Green : Color.Red);
                    var       playerPosition      = ObjectManager.Player.Position.To2D();
                    var       direction           = ObjectManager.Player.Direction.To2D().Perpendicular();
                    var       currentScreenPlayer = Drawing.WorldToScreen(ObjectManager.Player.Position);
                    const int distance            = 600;
                    var       currentAngel        = 30 * (float)Math.PI / 180;
                    var       currentCheckPoint1  = playerPosition + distance * direction.Rotated(currentAngel);
                    currentAngel = 335 * (float)Math.PI / 180;
                    var currentCheckPoint2       = playerPosition + distance * direction.Rotated(currentAngel);
                    var currentScreenCheckPoint1 = Drawing.WorldToScreen(currentCheckPoint1.To3D());
                    var currentScreenCheckPoint2 = Drawing.WorldToScreen(currentCheckPoint2.To3D());
                    Drawing.DrawLine(currentScreenPlayer.X, currentScreenPlayer.Y, currentScreenCheckPoint1.X, currentScreenCheckPoint1.Y, 2, Q.IsReady() ? Color.Green : Color.Red);
                    Drawing.DrawLine(currentScreenPlayer.X, currentScreenPlayer.Y, currentScreenCheckPoint2.X, currentScreenCheckPoint2.Y, 2, Q.IsReady() ? Color.Green : Color.Red);
                }
            }

            if (Menu.Item("Draw_W", true).GetValue <bool>())
            {
                if (W.Level > 0)
                {
                    Render.Circle.DrawCircle(Player.Position, W.Range - 2, W.IsReady() ? Color.Green : Color.Red);
                }
            }

            if (Menu.Item("Draw_E", true).GetValue <bool>())
            {
                if (E.Level > 0)
                {
                    Render.Circle.DrawCircle(Player.Position, E.Range, E.IsReady() ? Color.Green : Color.Red);
                }
            }

            if (Menu.Item("Draw_R", true).GetValue <bool>())
            {
                if (R.Level > 0)
                {
                    Render.Circle.DrawCircle(Player.Position, R.Range, R.IsReady() ? Color.Green : Color.Red);
                }
            }


            if (Menu.Item("Draw_R_Pred", true).GetValue <bool>() && R.IsReady())
            {
                SpellCastManager.DrawBestLine(R, R2, (int)(R2.Range / 2), .9f);
            }
        }
Example #18
0
        private void UseSpells(bool useQ, bool useW, bool useE, bool useR, bool useQe, string source)
        {
            if (source == "Harass" && !ManaManager.HasMana("Harass"))
            {
                return;
            }

            var   qTarget = TargetSelector.GetTarget(650, TargetSelector.DamageType.Magical);
            float dmg     = 0;

            if (qTarget != null)
            {
                dmg += GetComboDamage(qTarget);
            }

            if (useR)
            {
                Cast_R();
            }

            if (useQe)
            {
                Cast_QE(source);
            }

            if (useQ)
            {
                SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Magical, HitChanceManager.GetQHitChance(source));
            }

            if (useE)
            {
                Cast_E(source);
            }

            if (useW)
            {
                Cast_W(true, source);
            }

            //items
            if (source == "Combo")
            {
                var itemTarget = TargetSelector.GetTarget(750, TargetSelector.DamageType.Physical);
                if (itemTarget != null)
                {
                    ItemManager.Target = itemTarget;

                    //see if killable
                    if (dmg > itemTarget.Health - 50)
                    {
                        ItemManager.KillableTarget = true;
                    }

                    ItemManager.UseTargetted = true;
                }
            }
        }
Example #19
0
        private void UseSpells(bool useQ, bool useW, bool useE, bool useR, string source)
        {
            if (source == "Harass" && !ManaManager.HasMana("Harass"))
            {
                return;
            }

            //items
            if (source == "Combo")
            {
                var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);
                if (target.IsValidTarget(Q.Range))
                {
                    var dmg = GetComboDamage(target);
                    ItemManager.Target = target;

                    //see if killable
                    if (dmg > target.Health - 50)
                    {
                        ItemManager.KillableTarget = true;
                    }

                    ItemManager.UseTargetted = true;
                }
            }

            if (useR && R.IsReady())
            {
                Cast_R(source);
            }
            if (useE && E.IsReady())
            {
                Cast_E();
            }
            if (useQ && Q.IsReady())
            {
                SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Magical, HitChanceManager.GetQHitChance(source));
            }
            if (useW && W.IsReady())
            {
                if (menu.Item("OnlyWIfnotPoison", true).GetValue <bool>())
                {
                    var target = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Magical);
                    if (target.IsValidTarget(W.Range))
                    {
                        if (!Q.IsReady() && QSuccessfullyCasted(target))
                        {
                            SpellCastManager.CastBasicSkillShot(W, W.Range, TargetSelector.DamageType.Magical,
                                                                HitChanceManager.GetWHitChance(source));
                        }
                    }
                }
                else
                {
                    SpellCastManager.CastBasicSkillShot(W, W.Range, TargetSelector.DamageType.Magical, HitChanceManager.GetWHitChance(source));
                }
            }
        }
Example #20
0
        private void UseSpells(bool useQ, bool useW, bool useE, string source)
        {
            if (source == "Harass" && !ManaManager.HasMana("Harass"))
            {
                return;
            }

            if (source == "Combo")
            {
                var itemTarget = TargetSelector.GetTarget(750, TargetSelector.DamageType.Physical);
                if (itemTarget != null)
                {
                    ItemManager.Target = itemTarget;

                    float dmg = GetComboDamage(itemTarget);

                    //see if killable
                    if (dmg > itemTarget.Health - 50)
                    {
                        ItemManager.KillableTarget = true;
                    }

                    ItemManager.UseTargetted = true;
                }
            }

            //W
            if (useW && W.IsReady())
            {
                if (ShouldW())
                {
                    SpellCastManager.CastBasicSkillShot(W, W.Range, TargetSelector.DamageType.Magical,
                                                        HitChanceManager.GetWHitChance(source));
                }
            }

            //Q
            if (useQ && Q.IsReady())
            {
                SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Magical,
                                                    HitChanceManager.GetQHitChance(source));
            }

            //E
            if (useE && E.IsReady() && ESpell.ToggleState == 1 && HasManaForE(source) &&
                Utils.TickCount - E.LastCastAttemptT > 500)
            {
                var target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Magical);

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

                E.Cast();
            }
        }
Example #21
0
        protected override void Game_OnGameUpdate(EventArgs args)
        {
            if (Player.IsDead)
            {
                return;
            }

            SpellCastManager.CastBestLine(false, R, R2, (int)(R2.Range / 2), Menu, .9f);

            if (Menu.Item("Stay_Danger", true).GetValue <KeyBind>().Active)
            {
                StayInDangerZone();
            }

            if (Menu.Item("FarmT", true).GetValue <KeyBind>().Active)
            {
                Harass();
            }

            switch (Orbwalker.ActiveMode)
            {
            case Orbwalking.OrbwalkingMode.Combo:
                Combo();
                break;

            case Orbwalking.OrbwalkingMode.Mixed:
                Harass();
                break;

            case Orbwalking.OrbwalkingMode.LastHit:
                LastHit();
                break;

            case Orbwalking.OrbwalkingMode.LaneClear:
                Farm();
                break;

            case Orbwalking.OrbwalkingMode.Freeze:
                break;

            case Orbwalking.OrbwalkingMode.CustomMode:
                break;

            case Orbwalking.OrbwalkingMode.None:
                if (Menu.Item("UseMecR", true).GetValue <KeyBind>().Active)
                {
                    SpellCastManager.CastBestLine(true, R, R2, (int)(R2.Range / 2 + 100), Menu, .9f);
                }
                break;

            case Orbwalking.OrbwalkingMode.Flee:
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Example #22
0
        private void Cast_W(string source)
        {
            if (!W.IsReady() || !PassiveCheck())
            {
                return;
            }

            SpellCastManager.CastBasicSkillShot(W, W.Range, TargetSelector.DamageType.Magical, HitChanceManager.GetWHitChance(source));
        }
Example #23
0
 private void Cast_Q(Obj_AI_Hero target)
 {
     if (target.HasBuff("urgotcorrosivedebuff"))
     {
         Q2.Cast(target);
     }
     else
     {
         SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Physical, HitChance.VeryHigh);
     }
 }
Example #24
0
 private void Cast_Q(Obj_AI_Hero target, string source)
 {
     if (target.HasBuff("urgotcorrosivedebuff", true))
     {
         Q2.Cast(target);
     }
     else
     {
         SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Physical, HitChanceManager.GetQHitChance(source));
     }
 }
Example #25
0
        private void UseSpells(bool useQ, bool useW, bool useR, string source)
        {
            if (source == "Harass" && !ManaManager.HasMana(source))
            {
                return;
            }

            var itemTarget = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);

            if (itemTarget != null)
            {
                var dmg = GetComboDamage(itemTarget);
                ItemManager.Target = itemTarget;

                //see if killable
                if (dmg > itemTarget.Health - 50)
                {
                    ItemManager.KillableTarget = true;
                }

                ItemManager.UseTargetted = true;
            }

            if (useQ && Q.IsReady())
            {
                var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
                if (target.IsValidTarget(Q.Range))
                {
                    var pred = Prediction.GetPrediction(target, 625);

                    if (pred.Hitchance >= HitChanceManager.GetQHitChance(source) && target.IsMoving)
                    {
                        Q.Cast(pred.UnitPosition);
                    }
                }
            }
            if (useW && W.IsReady())
            {
                SpellCastManager.CastBasicSkillShot(W, W.Range, TargetSelector.DamageType.Magical, HitChanceManager.GetWHitChance(source));
            }

            if (useR && R.IsReady())
            {
                foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(GetRealRRange(x))))
                {
                    var dmg = GetComboDamage(enemy);
                    if (dmg > enemy.Health)
                    {
                        R.Cast(enemy);
                    }
                }
            }
        }
Example #26
0
        private void UseSpells(bool useQ, bool useW, bool useE, bool useR, string source)
        {
            if (source == "Harass" && !ManaManager.HasMana("Harass"))
            {
                return;
            }

            var target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Physical);

            if (target.IsValidTarget(R.Range))
            {
                var dmg = GetComboDamage(target);

                if (useR && dmg > target.Health && Player.ServerPosition.Distance(target.ServerPosition) > menu.Item("R_Min_Range", true).GetValue <Slider>().Value)
                {
                    SpellCastManager.CastBasicSkillShot(R, R.Range, TargetSelector.DamageType.Physical, HitChanceManager.GetRHitChance(source));
                }

                if (Q.IsReady() && Player.ServerPosition.Distance(target.ServerPosition) < 550)
                {
                    var qMin = menu.Item("Q_Min_Stack", true).GetValue <Slider>().Value;

                    if (qMin <= QStacks)
                    {
                        Q.Cast();
                    }
                }
            }

            if (useW && W.IsReady())
            {
                SpellCastManager.CastBasicSkillShot(W, W.Range, TargetSelector.DamageType.Magical, HitChanceManager.GetWHitChance(source));
            }

            //items
            if (source == "Combo")
            {
                var itemTarget = TargetSelector.GetTarget(750, TargetSelector.DamageType.Physical);
                if (itemTarget != null)
                {
                    var dmg = GetComboDamage(itemTarget);
                    ItemManager.Target = itemTarget;

                    //see if killable
                    if (dmg > itemTarget.Health - 50)
                    {
                        ItemManager.KillableTarget = true;
                    }

                    ItemManager.UseTargetted = true;
                }
            }
        }
Example #27
0
        private void UseSpells(bool useQ, bool useW, bool useE, bool useR, string source)
        {
            if (source == "Harass" && !ManaManager.HasMana("Harass"))
            {
                return;
            }

            var qTarget = TargetSelector.GetTarget(QExtend.Range, TargetSelector.DamageType.Magical);
            var eTarget = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Magical);

            //E
            if (useE && eTarget != null && E.IsReady() && Player.Distance(eTarget.Position) < E.Range && ShouldE(eTarget))
            {
                SpellCastManager.CastBasicSkillShot(E, E.Range, TargetSelector.DamageType.Magical, HitChanceManager.GetEHitChance(source));
            }

            //R
            if (useR && qTarget != null && R.IsReady() && Player.Distance(qTarget.Position) < R.Range)
            {
                CastR(qTarget);
            }

            var itemTarget = TargetSelector.GetTarget(750, TargetSelector.DamageType.Physical);

            if (itemTarget != null)
            {
                var dmg = GetComboDamage(itemTarget);
                ItemManager.Target = itemTarget;

                //see if killable
                if (dmg > itemTarget.Health - 50)
                {
                    ItemManager.KillableTarget = true;
                }

                ItemManager.UseTargetted = true;
            }

            //W
            if (useW && qTarget != null && W.IsReady())
            {
                if (W.GetPrediction(qTarget).Hitchance > HitChance.High && Player.Distance(qTarget.Position) <= W.Width)
                {
                    W.Cast();
                }
            }

            //Q
            if (useQ && Q.IsReady() && qTarget != null)
            {
                CastQ(source);
            }
        }
Example #28
0
        private void Harass()
        {
            if (!ManaManager.HasMana("Harass"))
            {
                return;
            }

            var target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Magical);

            if (target == null)
            {
                return;
            }

            var dmg = GetComboDamage(target);

            if (Menu.Item("UseWHarass", true).GetValue <bool>())
            {
                if (Menu.Item("UseEHarass", true).GetValue <bool>())
                {
                    var pred = E.GetPrediction(target, true);

                    if (pred.Hitchance >= HitChance.VeryHigh && E.IsReady())
                    {
                        E.Cast(target);
                        Cast_W(pred.CastPosition);
                    }
                }

                if (Menu.Item("UseQHarass", true).GetValue <bool>())
                {
                    var pred = Q.GetPrediction(target);
                    if (pred.Hitchance >= HitChance.VeryHigh && pred.CastPosition.Distance(Player.ServerPosition) < Q.Range)
                    {
                        Q.Cast(pred.CastPosition);
                        Cast_W(pred.CastPosition);
                    }
                }
            }
            else
            {
                if (Menu.Item("UseQHarass", true).GetValue <bool>())
                {
                    SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Magical, HitChance.VeryHigh);
                }

                if (Menu.Item("UseEHarass", true).GetValue <bool>())
                {
                    SpellCastManager.CastBasicSkillShot(E, E.Range, TargetSelector.DamageType.Magical, HitChance.VeryHigh);
                }
            }
        }
Example #29
0
        private void Combo()
        {
            var itemTarget = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);

            if (itemTarget != null)
            {
                var dmg = GetComboDamage(itemTarget);
                ItemManager.Target = itemTarget;

                if (dmg > itemTarget.Health - 50)
                {
                    ItemManager.KillableTarget = true;
                }

                ItemManager.UseTargetted = true;
            }

            if (Menu.Item("UseQCombo", true).GetValue <bool>() && Q.IsReady())
            {
                var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);

                if (target.IsValidTarget(Q.Range))
                {
                    var pred = Prediction.GetPrediction(target, 625);

                    if (pred.Hitchance >= HitChance.VeryHigh && target.IsMoving)
                    {
                        Q.Cast(pred.UnitPosition);
                    }
                }
            }

            if (Menu.Item("UseWCombo", true).GetValue <bool>() && W.IsReady())
            {
                SpellCastManager.CastBasicSkillShot(W, W.Range, TargetSelector.DamageType.Magical, HitChance.VeryHigh);
            }

            if (Menu.Item("UseRCombo", true).GetValue <bool>() && R.IsReady())
            {
                foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(GetRealRRange(x))))
                {
                    var dmg = GetComboDamage(enemy);
                    if (dmg > enemy.Health)
                    {
                        R.Cast(enemy);
                    }
                }
            }
        }
Example #30
0
        private void Combo()
        {
            var   qTarget = TargetSelector.GetTarget(650, TargetSelector.DamageType.Magical);
            float dmg     = 0;

            if (qTarget != null)
            {
                dmg += GetComboDamage(qTarget);
            }

            var itemTarget = TargetSelector.GetTarget(750, TargetSelector.DamageType.Physical);

            if (itemTarget != null)
            {
                ItemManager.Target = itemTarget;

                if (dmg > itemTarget.Health - 50)
                {
                    ItemManager.KillableTarget = true;
                }

                ItemManager.UseTargetted = true;
            }

            if (Menu.Item("UseRCombo", true).GetValue <bool>())
            {
                Cast_R();
            }

            if (Menu.Item("UseQECombo", true).GetValue <bool>())
            {
                Cast_QE();
            }

            if (Menu.Item("UseQCombo", true).GetValue <bool>())
            {
                SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Magical, HitChance.VeryHigh);
            }

            if (Menu.Item("UseECombo", true).GetValue <bool>())
            {
                Cast_E();
            }

            if (Menu.Item("UseWCombo", true).GetValue <bool>())
            {
                Cast_W(true);
            }
        }