Пример #1
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana())
            {
                var target = HarassOption.GetTarget(R.Range);

                if (target.IsValidTarget(R.Range))
                {
                    if (HarassOption.UseR && R.Ready &&
                        R.GetBasicSpell().Ammo >= HarassOption.GetSlider("HarassRLimit").Value&&
                        target.IsValidTarget(R.Range))
                    {
                        var rPred = R.GetPrediction(target);

                        if (rPred.HitChance >= HitChance.High)
                        {
                            R.Cast(rPred.UnitPosition);
                        }
                    }

                    if (HarassOption.UseQ && Q.Ready && target.IsValidTarget(Q.Range))
                    {
                        var qPred = Q.GetPrediction(target);

                        if (qPred.HitChance >= HitChance.High)
                        {
                            Q.Cast(qPred.CastPosition);
                        }
                    }

                    if (HarassOption.UseE && E.Ready && target.IsValidAutoRange())
                    {
                        E.Cast();
                    }
                }
            }
        }
Пример #2
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana())
            {
                var target = HarassOption.GetTarget(R.Range);

                if (target.IsValidTarget(R.Range))
                {
                    if (HarassOption.UseR && R.IsReady() &&
                        R.Ammo >= HarassOption.GetSlider("HarassRLimit").Value&&
                        target.IsValidTarget(R.Range))
                    {
                        var rPred = R.GetPrediction(target);

                        if (rPred.Hitchance >= HitChance.High)
                        {
                            R.Cast(rPred.UnitPosition);
                        }
                    }

                    if (HarassOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                    {
                        var qPred = Q.GetPrediction(target);

                        if (qPred.Hitchance >= HitChance.High)
                        {
                            Q.Cast(qPred.CastPosition);
                        }
                    }

                    if (HarassOption.UseE && E.IsReady() && target.InAutoAttackRange())
                    {
                        E.Cast(Me.PreviousPosition);
                    }
                }
            }
        }
Пример #3
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                if (HarassOption.UseW && W.IsReady())
                {
                    var wTarget = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                    if (wTarget.IsValidTarget(W.Range))
                    {
                        SpellManager.PredCast(W, wTarget, true);
                    }
                }

                if (HarassOption.UseE && E.IsReady())
                {
                    var eTarget = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                    if (eTarget.IsValidTarget(E.Range))
                    {
                        if (HarassOption.GetBool("HarassEStack"))
                        {
                            if (eTarget.DistanceToPlayer() > E.Range * 0.8 && eTarget.IsValidTarget(E.Range) &&
                                GetEStackCount(eTarget) >= HarassOption.GetSlider("HarassEStackCount"))
                            {
                                E.Cast();
                            }
                        }

                        if (HarassOption.GetBool("HarassEFull") && GetEStackCount(eTarget) >= 6)
                        {
                            E.Cast();
                        }
                    }
                }
            }
        }
Пример #4
0
        private static void OnAction(object sender, OrbwalkerActionArgs Args)
        {
            if (Args.Type == OrbwalkerType.BeforeAttack)
            {
                if (Orbwalker.ActiveMode == OrbwalkerMode.Combo || Orbwalker.ActiveMode == OrbwalkerMode.Harass)
                {
                    var ForcusTarget =
                        GameObjects.EnemyHeroes.FirstOrDefault(
                            x => x.IsValidTarget(Me.AttackRange + Me.BoundingRadius + x.BoundingRadius + 50) && Has2WStacks(x));

                    if (MiscOption.GetBool("Forcus", "ForcusAttack").Enabled&& ForcusTarget != null &&
                        ForcusTarget.IsValidTarget(Me.AttackRange + Me.BoundingRadius - ForcusTarget.BoundingRadius + 15))
                    {
                        Orbwalker.ForceTarget = ForcusTarget;
                        LastForcusTime        = Variables.GameTimeTickCount;
                    }
                    else
                    {
                        Orbwalker.ForceTarget = null;
                    }
                }
            }

            if (Args.Type == OrbwalkerType.AfterAttack)
            {
                Orbwalker.ForceTarget = null;

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

                switch (Args.Target.Type)
                {
                case GameObjectType.AIHeroClient:
                {
                    if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
                    {
                        if (ComboOption.GetBool("ComboAQA").Enabled)
                        {
                            var target = (AIHeroClient)Args.Target;
                            if (target != null && !target.IsDead && Q.IsReady())
                            {
                                AfterQLogic(target);
                            }
                        }
                    }
                    else if (Orbwalker.ActiveMode == OrbwalkerMode.Harass || Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellHarass)
                    {
                        if (HarassOption.HasEnouguMana() && HarassOption.UseQ)
                        {
                            var target = (AIHeroClient)Args.Target;
                            if (target != null && !target.IsDead && Q.IsReady() &&
                                HarassOption.GetHarassTargetEnabled(target.CharacterName))
                            {
                                if (HarassOption.GetBool("HarassQ2Passive").Enabled&& !Has2WStacks(target))
                                {
                                    return;
                                }

                                AfterQLogic(target);
                            }
                        }
                    }
                }
                break;

                case GameObjectType.AIMinionClient:
                {
                    if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
                    {
                        var m = (AIMinionClient)Args.Target;
                        if (m != null && m.IsValidTarget())
                        {
                            if (m.IsMinion())
                            {
                                if (LaneClearOption.HasEnouguMana() && LaneClearOption.UseQ)
                                {
                                    var minions =
                                        GameObjects.EnemyMinions.Where(x => x.IsValidTarget(Me.AttackRange + Me.BoundingRadius) && x.IsMinion())
                                        .Where(x => x.Health <= Me.GetAutoAttackDamage(x) + Me.GetSpellDamage(x, SpellSlot.Q))
                                        .ToList();

                                    if (minions.Any() && minions.Count >= 1)
                                    {
                                        var minion         = minions.OrderBy(x => x.Health).FirstOrDefault();
                                        var afterQPosition = Me.PreviousPosition.Extend(Game.CursorPosRaw, Q.Range);

                                        if (minion != null &&
                                            afterQPosition.Distance(minion.PreviousPosition) <= Me.AttackRange + Me.BoundingRadius)
                                        {
                                            Q.Cast(Game.CursorPosRaw);
                                        }
                                    }
                                }
                            }
                            else if (m.GetJungleType() != JungleType.Unknown)
                            {
                                if (JungleClearOption.HasEnouguMana() && JungleClearOption.UseQ)
                                {
                                    Q.Cast(Game.CursorPosRaw);
                                }
                            }
                        }
                    }
                }
                break;

                case GameObjectType.AITurretClient:
                case GameObjectType.HQClient:
                case GameObjectType.Barracks:
                case GameObjectType.BarracksDampenerClient:
                case GameObjectType.BuildingClient:
                {
                    if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
                    {
                        if (LaneClearOption.HasEnouguMana(true) && LaneClearOption.UseQ)
                        {
                            if (Me.CountEnemyHeroesInRange(850) == 0)
                            {
                                if (Me.CanMoveMent())
                                {
                                    Q.Cast(Game.CursorPosRaw);
                                }
                            }
                        }
                    }
                }
                break;
                }
            }
        }
Пример #5
0
        private static void Initializer()
        {
            Q = new Spell(SpellSlot.Q, 300f);
            W = new Spell(SpellSlot.W);
            E = new Spell(SpellSlot.E, 650f)
            {
                Delay = 0.25f
            };
            R = new Spell(SpellSlot.R);

            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddBool("ComboAQA", "Use Q| After Attack");
            ComboOption.AddE();
            ComboOption.AddR();
            ComboOption.AddSlider("ComboRCount", "Use R| Enemies Count >= x", 2, 1, 5);
            ComboOption.AddSlider("ComboRHp", "Use R| And Player HealthPercent <= x%", 40, 0, 100);

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddBool("HarassQ2Passive", "Use Q| Only target have 2 Stack");
            HarassOption.AddE();
            HarassOption.AddBool("HarassE2Passive", "Use E| Only target have 2 Stack");
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddQ();
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddE();
            JungleClearOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddE();

            //GapcloserOption.AddMenu();

            MiscOption.AddMenu();
            MiscOption.AddSubMenu("Stealth", "Stealth Settings");
            MiscOption.AddList("Stealth", "HideSelect", "Enabled Mode: ", new[] { "Always Max Stealth Time", "Config", "Off" }, 1);
            MiscOption.AddBool("Stealth", "Hideinsolo", "Enabled Solo Stealth Config");
            MiscOption.AddSlider("Stealth", "Hideinsolomyhp", "When Player HealthPercent <= x%", 30);
            MiscOption.AddSlider("Stealth", "Hideinsolotargethp", "And Enemy HealthPercent => x%", 60);
            MiscOption.AddBool("Stealth", "Hideinmulti", "Enabled Team Fight Stealth Config");
            MiscOption.AddSlider("Stealth", "Hideinmultimyhp", "When Player HealthPercent <= x%", 70);
            MiscOption.AddSlider("Stealth", "HideinmultiallyCount", "And Allies Count <= x", 2, 0, 4);
            MiscOption.AddSlider("Stealth", "HideinmultienemyCount", "And Enemies Count >= x", 3, 2, 5);
            MiscOption.AddBasic();
            MiscOption.AddQ();
            MiscOption.AddBool("Q", "QCheck", "Auto Q| Safe Check");
            MiscOption.AddList("Q", "QTurret", "Auto Q| Disable Dash to Enemy Turret",
                               new[] { "Only Dash Q", "Only After Attack Q", "Both", "Off" });
            MiscOption.AddBool("Q", "QMelee", "Auto Q| Anti Melee");
            MiscOption.AddE();
            MiscOption.AddBool("E", "AntiGapcloserE", "Auto E| Anti Gapcloser");
            MiscOption.AddR();
            MiscOption.AddBool("R", "AutoR", "Auto R");
            MiscOption.AddSlider("R", "AutoRCount", "Auto R| Enemies Count >= x", 3, 1, 5);
            MiscOption.AddSlider("R", "AutoRRange", "Auto R| Search Enemies Range", 600, 500, 1200);
            MiscOption.AddSetting("Forcus");
            MiscOption.AddBool("Forcus", "ForcusAttack", "Forcus Attack 2 Passive Target");

            DrawOption.AddMenu();
            DrawOption.AddE(E);
            DrawOption.AddDamageIndicatorToHero(false, true, true, false, true);

            Game.OnUpdate      += OnUpdate;
            Orbwalker.OnAction += OnAction;
            //Gapcloser.OnGapcloser += OnGapcloser;
        }
Пример #6
0
        private static void Initializer()
        {
            Q = new Spell(SpellSlot.Q, 600f);

            W = new Spell(SpellSlot.W, 2500f);
            W.SetSkillshot(0.75f, 40f, 5000f, false, false, SkillshotType.Line);

            E = new Spell(SpellSlot.E, 750f);
            E.SetSkillshot(0.50f, 120f, 1600f, false, true, SkillshotType.Circle);

            R = new Spell(SpellSlot.R, 3500f);
            R.SetSkillshot(0.21f, 80f, 5000f, true, false, SkillshotType.Line);

            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddBool("ComboQMinion", "Use Q| On Minion", false);
            ComboOption.AddW();
            ComboOption.AddBool("ComboWAA", "Use W| After Attack");
            ComboOption.AddBool("ComboWOnly", "Use W| Only Use to MarkTarget");
            ComboOption.AddE();
            ComboOption.AddR();

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddBool("HarassQMinion", "Use Q| On Minion");
            HarassOption.AddW();
            HarassOption.AddBool("HarassWOnly", "Use W| Only Use to MarkTarget");
            HarassOption.AddE();
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddQ();
            LaneClearOption.AddW();
            LaneClearOption.AddMana();
            LaneClearOption.AddBool("LaneClearReload", "Use Spell Clear| Only Jhin Reloading");

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddW();
            JungleClearOption.AddE();
            JungleClearOption.AddMana();

            LastHitOption.AddMenu();
            LastHitOption.AddQ();
            LastHitOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddQ();
            KillStealOption.AddW();
            KillStealOption.AddBool("KillStealWInAttackRange", "Use W| Target In Attack Range");

            //GapcloserOption.AddMenu();

            MiscOption.AddMenu();
            MiscOption.AddBasic();
            MiscOption.AddW();
            MiscOption.AddBool("W", "AutoW", "Auto W| CC");
            MiscOption.AddE();
            MiscOption.AddBool("E", "AutoE", "Auto E| CC");
            MiscOption.AddR();
            MiscOption.AddBool("R", "rMenuAuto", "Auto R");
            MiscOption.AddKey("R", "rMenuSemi", "Semi-manual R Key", Keys.T, KeyBindType.Press);
            MiscOption.AddBool("R", "rMenuCheck", "Use R| Check is Safe?");
            MiscOption.AddSlider("R", "rMenuMin", "Use R| Min Range >= x", 1000, 500, 2500);
            MiscOption.AddSlider("R", "rMenuMax", "Use R| Max Range <= x", 3000, 1500, 3500);
            MiscOption.AddSlider("R", "rMenuKill", "Use R| Min Shot Can Kill >= x (0 = off)", 3, 0, 4);

            DrawOption.AddMenu();
            DrawOption.AddQ(Q);
            DrawOption.AddW(W);
            DrawOption.AddE(E);
            DrawOption.AddR(R);
            DrawOption.AddDamageIndicatorToHero(true, true, false, true, true);

            Tick.OnTick        += OnUpdate;
            Orbwalker.OnAction += OnAction;
            AIBaseClient.OnProcessSpellCast += OnProcessSpellCast;
            //Gapcloser.OnGapcloser += OnGapcloser;
        }
Пример #7
0
        private static void Initializer()
        {
            Q = new Aimtec.SDK.Spell(SpellSlot.Q, 1050f);
            Q.SetSkillshot(0.25f, 79f, 1200f, true, SkillshotType.Line);

            Q2 = new Aimtec.SDK.Spell(SpellSlot.Q, 600f)
            {
                Speed = float.MaxValue, Delay = 0.25f
            };

            QE = new Aimtec.SDK.Spell(SpellSlot.Q, 1650f);
            QE.SetSkillshot(0.35f, 98f, 1900f, true, SkillshotType.Line);

            W = new Aimtec.SDK.Spell(SpellSlot.W);

            W2 = new Aimtec.SDK.Spell(SpellSlot.W, 350f);

            E = new Aimtec.SDK.Spell(SpellSlot.E, 650f);
            E.SetSkillshot(0.1f, 120f, float.MaxValue, false, SkillshotType.Circle);

            E2 = new Aimtec.SDK.Spell(SpellSlot.E, 240f)
            {
                Speed = float.MaxValue, Delay = 0.25f
            };

            R = new Aimtec.SDK.Spell(SpellSlot.R);

            ComboOption.AddMenu();
            ComboOption.AddBool("UsQECombo", "Use Cannon Q");
            ComboOption.AddBool("UseWCombo", "Use Cannon W");
            ComboOption.AddBool("UseECombo", "Use Cannon E");
            ComboOption.AddBool("UsQEComboHam", "Use Hammer Q");
            ComboOption.AddBool("UseWComboHam", "Use Hammer W");
            ComboOption.AddBool("UseEComboHam", "Use Hammer E");
            ComboOption.AddBool("UseRCombo", "Use R Switch");

            HarassOption.AddMenu();
            HarassOption.AddBool("UsQEHarass", "Use Cannon Q");
            HarassOption.AddBool("UseWHarass", "Use Cannon W");
            HarassOption.AddBool("UseEHarass", "Use Cannon E");
            HarassOption.AddBool("UsQEHarassHam", "Use Hammer Q", false);
            HarassOption.AddBool("UseWHarassHam", "Use Hammer W", false);
            HarassOption.AddBool("UseEHarassHam", "Use Hammer E", false);
            HarassOption.AddBool("UseRHarass", "Use R Switch");
            HarassOption.AddMana(60);
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddBool("UsQEFarm", "Use Cannon Q");
            LaneClearOption.AddBool("UseRFarm", "Use R Switch");
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddBool("UsQEJungle", "Use Cannon Q");
            JungleClearOption.AddBool("UseWJungle", "Use Cannon W");
            JungleClearOption.AddBool("UseEJungle", "Use Cannon E");
            JungleClearOption.AddBool("UsQEJungleHam", "Use Hammer Q");
            JungleClearOption.AddBool("UseWJungleHam", "Use Hammer W");
            JungleClearOption.AddBool("UseEJungleHam", "Use Hammer E");
            JungleClearOption.AddBool("UseRJungle", "Use R Switch");
            JungleClearOption.AddMana();

            FleeOption.AddMenu();
            FleeOption.AddQ();
            FleeOption.AddE();
            FleeOption.AddR();

            KillStealOption.AddMenu();
            KillStealOption.AddQ();
            KillStealOption.AddE();
            KillStealOption.AddBool("UsQEEKS", "Use QE");
            KillStealOption.AddR();

            GapcloserOption.AddMenu();

            MiscOption.AddMenu();
            MiscOption.AddE();
            MiscOption.AddBool("E", "forceGate", "Auto E| After Q", false);
            MiscOption.AddSlider("E", "gatePlace", "Gate Place Distance", 50, 50, 110);
            MiscOption.AddSlider("E", "autoE", "Auto E Save|When Player HealthPercent < x%", 20, 0, 101);
            MiscOption.AddSetting("QE");
            MiscOption.AddKey("QE", "SemiQE", "Semi-manual QE Key", KeyCode.T, KeybindType.Press);
            MiscOption.AddList("QE", "SemiQEMode", "Semi-manual QE Mode", new[] { "To Target", "To Mouse" });

            DrawOption.AddMenu();
            DrawOption.AddRange(Q, "Cannon Q");
            DrawOption.AddRange(QE, "Cannon Q Extend");
            DrawOption.AddRange(W, "Cannon W");
            DrawOption.AddRange(E, "Cannon E");
            DrawOption.AddRange(Q, "Hammer Q");
            DrawOption.AddRange(W, "Hammer W");
            DrawOption.AddRange(E, "Hammer E");
            DrawOption.AddFarm();
            DrawOption.AddDamageIndicatorToHero(true, true, true, false, false);
            DrawOption.AddBool("DrawCoolDown", "Draw Spell CoolDown");

            Game.OnUpdate         += OnUpdate;
            Orbwalker.PostAttack  += PostAttack;
            GameObject.OnCreate   += OnCreate;
            Gapcloser.OnGapcloser += OnGapcloser;
            Render.OnRender       += OnRender;
        }
Пример #8
0
        private static void OnAction(object sender, OrbwalkerActionArgs Args)
        {
            if (Args.Type != OrbwalkerType.BeforeAttack)
            {
                return;
            }

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

            switch (Args.Target.Type)
            {
            case GameObjectType.AIHeroClient:
            {
                var target = (AIHeroClient)Args.Target;
                if (target != null && target.IsValidTarget())
                {
                    if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
                    {
                        if (ComboOption.UseQ && Q.IsReady())
                        {
                            if (Me.HasBuff("JinxQ"))
                            {
                                if (target.Health < Me.GetAutoAttackDamage(target) * 3 &&
                                    target.DistanceToPlayer() <= Q.Range + 60)
                                {
                                    Q.Cast();
                                }
                                else if (Me.Mana < (rCoolDown == -1 ? 100 : (rCoolDown > 10 ? 130 : 150)))
                                {
                                    Q.Cast();
                                }
                                else if (target.IsValidTarget(Q.Range))
                                {
                                    Q.Cast();
                                }
                            }
                            else
                            {
                                if (target.CountEnemyHeroesInRange(150) >= 2 &&
                                    Me.Mana > R.Mana + Q.Mana * 2 + W.Mana &&
                                    target.DistanceToPlayer() > Q.Range)
                                {
                                    Q.Cast();
                                }
                            }
                        }
                    }
                    else if (Orbwalker.ActiveMode == OrbwalkerMode.Harass ||
                             Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellHarass)
                    {
                        if (HarassOption.HasEnouguMana())
                        {
                            if (HarassOption.UseQ && Q.IsReady())
                            {
                                if (Me.HasBuff("JinxQ"))
                                {
                                    if (target.DistanceToPlayer() >= bigGunRange)
                                    {
                                        Q.Cast();
                                    }
                                }
                                else
                                {
                                    if (target.CountEnemyHeroesInRange(150) >= 2 &&
                                        Me.Mana > R.Mana + Q.Mana * 2 + W.Mana &&
                                        target.DistanceToPlayer() > Q.Range)
                                    {
                                        Q.Cast();
                                    }
                                }
                            }
                        }
                        else
                        {
                            if (Me.HasBuff("JinxQ") && Q.IsReady())
                            {
                                Q.Cast();
                            }
                        }
                    }
                }
            }
            break;

            case GameObjectType.AIMinionClient:
            {
                var minion = (AIMinionClient)Args.Target;
                if (minion != null && minion.IsMinion())
                {
                    if (LaneClearOption.HasEnouguMana() && Q.IsReady() && LaneClearOption.UseQ)
                    {
                        var min     = (AIBaseClient)Args.Target;
                        var minions =
                            GameObjects.EnemyMinions.Where(x => x.IsValidTarget(bigGunRange) && x.IsMinion())
                            .ToList();

                        if (minions.Any() && min != null)
                        {
                            foreach (var m in minions.Where(x => x.NetworkId != min.NetworkId))
                            {
                                var count =
                                    ObjectManager.Get <AIMinionClient>().Count(x => x.Distance(m) <= 150);

                                if (m.DistanceToPlayer() <= bigGunRange)
                                {
                                    if (Me.HasBuff("JinxQ"))
                                    {
                                        if (LaneClearOption.GetSlider("LaneClearQCount").Value > count)
                                        {
                                            Q.Cast();
                                        }
                                        else if (min.Health > Me.GetAutoAttackDamage(min) * 1.1f)
                                        {
                                            Q.Cast();
                                        }
                                    }
                                    else if (!Me.HasBuff("JinxQ"))
                                    {
                                        if (LaneClearOption.GetSlider("LaneClearQCount").Value <= count)
                                        {
                                            Q.Cast();
                                        }
                                        else if (min.Health < Me.GetAutoAttackDamage(min) * 1.1f &&
                                                 min.DistanceToPlayer() > Q.Range)
                                        {
                                            Q.Cast();
                                        }
                                    }
                                }
                            }

                            if (minions.Count <= 2 && Me.HasBuff("JinxQ"))
                            {
                                Q.Cast();
                            }
                        }
                    }
                    else
                    {
                        if (Me.HasBuff("JinxQ") && Q.IsReady())
                        {
                            Q.Cast();
                        }
                    }
                }
            }
            break;
            }
        }
Пример #9
0
        private static void Initializer()
        {
            Q = new Spell(SpellSlot.Q, 650f)
            {
                Delay = 0.35f
            };

            Q2 = new Spell(SpellSlot.Q, 900f);
            Q2.SetSkillshot(0.35f, 25f, int.MaxValue, false, true, SkillshotType.Line);

            W = new Spell(SpellSlot.W, 1000f);
            W.SetSkillshot(0.30f, 80f, 1600f, true, true, SkillshotType.Line);

            W2 = new Spell(SpellSlot.W, 1000f);
            W2.SetSkillshot(0.30f, 80f, 1600f, false, true, SkillshotType.Line);

            E = new Spell(SpellSlot.E, 425f);

            R = new Spell(SpellSlot.R, 1200f);
            R.SetSkillshot(0.10f, 110f, 2500f, true, true, SkillshotType.Line);

            R2 = new Spell(SpellSlot.R, 1200f);
            R2.SetSkillshot(0.10f, 110f, 2500f, false, true, SkillshotType.Line);


            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddBool("ComboQExtend", "Use Q Extend", false);
            ComboOption.AddW();
            ComboOption.AddBool("ComboWLogic", "Use W |Logic Cast");
            ComboOption.AddBool("ComboEDash", "Use E Dash to target");
            ComboOption.AddBool("ComboEReset", "Use E Reset Auto Attack");
            ComboOption.AddBool("ComboESafe", "Use E| Safe Check");
            ComboOption.AddBool("ComboEWall", "Use E| Dont Dash to Wall");
            ComboOption.AddBool("ComboEShort", "Use E| Enabled the Short E Logic");
            ComboOption.AddR();

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddBool("HarassQExtend", "Use Q Extend");
            HarassOption.AddW(false);
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddQ();
            LaneClearOption.AddW();
            LaneClearOption.AddE();
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddW();
            JungleClearOption.AddE();
            JungleClearOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddQ();
            KillStealOption.AddW();

            //GapcloserOption.AddMenu();

            MiscOption.AddMenu();
            MiscOption.AddBasic();
            MiscOption.AddR();
            MiscOption.AddKey("R", "SemiRKey", "Semi-manual R Key", Keys.T, KeyBindType.Press);

            DrawOption.AddMenu();
            DrawOption.AddQ(Q);
            DrawOption.AddQExtend(Q2);
            DrawOption.AddW(W);
            DrawOption.AddR(R);
            DrawOption.AddDamageIndicatorToHero(true, true, false, true, true);

            Tick.OnTick += OnUpdate;
            AIBaseClient.OnPlayAnimation    += OnPlayAnimation;
            Spellbook.OnCastSpell           += OnCastSpell;
            AIBaseClient.OnProcessSpellCast += OnProcessSpellCast;
            Orbwalker.OnAction += OnAction;
            //Gapcloser.OnGapcloser += OnGapcloser;
        }
Пример #10
0
        private static void Initializer()
        {
            Q = new Spell(SpellSlot.Q, 1150f);
            Q.SetSkillshot(0.35f, 40f, 2400f, true, false, SkillshotType.Line);

            W = new Spell(SpellSlot.W, 5000f);

            E = new Spell(SpellSlot.E, 950f);

            R = new Spell(SpellSlot.R, 1500f);

            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddE();
            ComboOption.AddBool("ComboESlow", "Use E| When Enemy Have Buff and Minion Can KillAble");
            ComboOption.AddBool("ComboGapcloser", "Auto Attack Minion To Gapcloser Target");

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddE();
            HarassOption.AddBool("HarassESlow", "Use E| When Enemy Have Buff and Minion Can KillAble");
            HarassOption.AddSliderBool("HarassELeave", "Use E| When Enemy Will Leave E Range And Buff Count >= x", 3, 1, 10);
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddSliderBool("LaneClearE", "Use E| Min KillAble Count >= x", 3, 1, 5, true);
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddE();
            JungleClearOption.AddMana();

            LastHitOption.AddMenu();
            LastHitOption.AddE();
            LastHitOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddQ();
            KillStealOption.AddE();

            MiscOption.AddMenu();
            MiscOption.AddBasic();
            MiscOption.AddE();
            MiscOption.AddBool("E", "AutoESteal", "Auto E Steal Mob (Only Buff&Dragon&Baron)");
            MiscOption.AddSliderBool("E", "EToler", "Enabled E Toler DMG", 0, -100, 110, true);
            MiscOption.AddR();
            MiscOption.AddSliderBool("R", "AutoRAlly", "Auto R| My Allies HealthPercent <= x%", 30, 1, 99, true);
            MiscOption.AddBool("R", "Balista", "Auto Balista");
            MiscOption.AddSetting("Forcus");
            MiscOption.AddBool("Forcus", "ForcusAttack", "Forcus Attack Passive Target");

            DrawOption.AddMenu();
            DrawOption.AddQ(Q);
            DrawOption.AddW(W);
            DrawOption.AddE(E);
            DrawOption.AddR(R);
            DrawOption.AddDamageIndicatorToHero(false, false, true, false, false);

            Tick.OnTick += OnUpdate;
            AIBaseClient.OnProcessSpellCast += OnProcessSpellCast;
            Orbwalker.OnAction += OnAction;
        }
Пример #11
0
        private static void OnAction(object sender, OrbwalkerActionArgs Args)
        {
            if (Args.Type == OrbwalkerType.NonKillableMinion)
            {
                if (Me.IsDead || Me.IsRecalling() || !Me.CanMoveMent())
                {
                    return;
                }

                if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
                {
                    return;
                }

                if (LastHitOption.HasEnouguMana && LastHitOption.UseE && E.IsReady())
                {
                    var minion = Args.Target as AIMinionClient;
                    if (minion != null && minion.IsValidTarget(E.Range) && Me.CountEnemyHeroesInRange(600) == 0 &&
                        minion.Health < E.GetKalistaRealDamage(minion))
                    {
                        E.Cast();
                    }
                }
            }

            if (Args.Type == OrbwalkerType.BeforeAttack)
            {
                if (MiscOption.GetBool("Forcus", "ForcusAttack").Enabled&& Me.CanMoveMent() && Args.Target != null &&
                    !Args.Target.IsDead && Args.Target.Health > 0)
                {
                    if (Orbwalker.ActiveMode == OrbwalkerMode.Combo || Orbwalker.ActiveMode == OrbwalkerMode.Harass)
                    {
                        foreach (var target in GameObjects.EnemyHeroes.Where(x => !x.IsDead &&
                                                                             x.InAutoAttackRange() &&
                                                                             x.Buffs.Any(
                                                                                 a =>
                                                                                 a.Name.ToLower()
                                                                                 .Contains(
                                                                                     "kalistacoopstrikemarkally"))))
                        {
                            if (!target.IsDead && target.IsValidTarget(Me.GetRealAutoAttackRange(target)))
                            {
                                Orbwalker.ForceTarget = target;
                                LastForcusTime        = Variables.GameTimeTickCount;
                            }
                        }
                    }
                    else if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
                    {
                        foreach (var target in GameObjects.Minions.Where(x => !x.IsDead && x.IsEnemy &&
                                                                         x.InAutoAttackRange() &&
                                                                         x.Buffs.Any(
                                                                             a =>
                                                                             a.Name.ToLower()
                                                                             .Contains(
                                                                                 "kalistacoopstrikemarkally"))))
                        {
                            if (!target.IsDead && target.IsValidTarget(Me.GetRealAutoAttackRange(target)))
                            {
                                Orbwalker.ForceTarget = target;
                                LastForcusTime        = Variables.GameTimeTickCount;
                            }
                        }
                    }
                }
            }

            if (Args.Type == OrbwalkerType.AfterAttack)
            {
                Orbwalker.ForceTarget = null;

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

                switch (Args.Target.Type)
                {
                case GameObjectType.AIHeroClient:
                {
                    var target = (AIHeroClient)Args.Target;

                    if (target != null && !target.IsDead && target.IsValidTarget(Q.Range))
                    {
                        if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
                        {
                            if (ComboOption.UseQ)
                            {
                                var qPred = Q.GetPrediction(target);

                                if (qPred.Hitchance >= HitChance.High)
                                {
                                    Q.Cast(qPred.CastPosition);
                                }
                            }
                        }
                        else if (HarassOption.HasEnouguMana() &&
                                 (Orbwalker.ActiveMode == OrbwalkerMode.Harass ||
                                  Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellHarass))
                        {
                            if (HarassOption.UseQ)
                            {
                                var qPred = Q.GetPrediction(target);

                                if (qPred.Hitchance >= HitChance.High)
                                {
                                    Q.Cast(qPred.CastPosition);
                                }
                            }
                        }
                    }
                }
                break;

                case GameObjectType.AIMinionClient:
                {
                    if (MyManaManager.SpellFarm && Orbwalker.ActiveMode == OrbwalkerMode.LaneClear &&
                        JungleClearOption.HasEnouguMana())
                    {
                        var mob = (AIMinionClient)Args.Target;
                        if (mob != null && mob.IsValidTarget(Q.Range) && mob.GetJungleType() != JungleType.Unknown)
                        {
                            if (JungleClearOption.UseQ)
                            {
                                Q.Cast(mob);
                            }
                        }
                    }
                }
                break;
                }
            }
        }
Пример #12
0
        //private static void OnGapcloser(AIHeroClient target, GapcloserArgs Args)
        //{
        //    if (E.IsReady() && target != null && target.IsValidTarget(E.Range))
        //    {
        //        switch (Args.Type)
        //        {
        //            case SpellType.Melee:
        //                {
        //                    if (target.IsValidTarget(target.AttackRange + target.BoundingRadius + 100))
        //                    {
        //                        E.Cast(Me.PreviousPosition.Extend(target.PreviousPosition, -E.Range));
        //                    }
        //                }
        //                break;
        //            case SpellType.Dash:
        //                {
        //                    if (Args.EndPosition.DistanceToPlayer() <= 250 ||
        //                        target.PreviousPosition.DistanceToPlayer() <= 300)
        //                    {
        //                        E.Cast(Me.PreviousPosition.Extend(target.PreviousPosition, -E.Range));
        //                    }
        //                }
        //                break;
        //            case SpellType.SkillShot:
        //            case SpellType.Targeted:
        //                {
        //                    if (target.PreviousPosition.DistanceToPlayer() <= 300)
        //                    {
        //                        E.Cast(Me.PreviousPosition.Extend(target.PreviousPosition, -E.Range));
        //                    }
        //                }
        //                break;
        //        }
        //    }
        //}


        private static void OnAction(object sender, OrbwalkerActionArgs Args)
        {
            if (Args.Type == OrbwalkerType.BeforeAttack)
            {
                if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() || Args.Target.Health <= 0)
                {
                    return;
                }

                switch (Args.Target.Type)
                {
                case GameObjectType.AIHeroClient:
                {
                    if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
                    {
                        var target = (AIHeroClient)Args.Target;
                        if (target != null && target.IsValidTarget(W.Range))
                        {
                            if (ComboOption.UseW && W.IsReady())
                            {
                                var pred = W.GetPrediction(target);
                                if (pred.Hitchance >= HitChance.High)
                                {
                                    W.Cast(pred.CastPosition);
                                }
                            }
                        }
                    }
                }
                break;

                case GameObjectType.AITurretClient:
                case GameObjectType.HQClient:
                case GameObjectType.Barracks:
                case GameObjectType.BarracksDampenerClient:
                case GameObjectType.BuildingClient:
                {
                    if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellFarm &&
                        LaneClearOption.HasEnouguMana(true))
                    {
                        if (LaneClearOption.UseW && W.IsReady())
                        {
                            W.Cast(Args.Target.Position);
                        }
                    }
                }
                break;
                }
            }

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

                switch (Args.Target.Type)
                {
                case GameObjectType.AIHeroClient:
                {
                    var target = (AIHeroClient)Args.Target;
                    if (target != null && target.IsValidTarget())
                    {
                        if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
                        {
                            if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                            {
                                var qPred = Q.GetPrediction(target);
                                if (qPred.Hitchance >= HitChance.High)
                                {
                                    Q.Cast(qPred.CastPosition);
                                }
                            }
                        }
                        else if (Orbwalker.ActiveMode == OrbwalkerMode.Harass ||
                                 Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellHarass)
                        {
                            if (!HarassOption.HasEnouguMana() ||
                                !HarassOption.GetHarassTargetEnabled(target.CharacterName))
                            {
                                return;
                            }

                            if (HarassOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                            {
                                var qPred = Q.GetPrediction(target);
                                if (qPred.Hitchance >= HitChance.High)
                                {
                                    Q.Cast(qPred.CastPosition);
                                }
                            }
                        }
                    }
                }
                break;
                }
            }
        }
Пример #13
0
        private static void OnAction(object sender, OrbwalkerActionArgs Args)
        {
            if (Args.Type == OrbwalkerType.BeforeAttack)
            {
                if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() || Args.Target.Health <= 0)
                {
                    return;
                }

                switch (Args.Target.Type)
                {
                case GameObjectType.AIHeroClient:
                {
                    var target = (AIHeroClient)Args.Target;
                    if (target != null && target.IsValidTarget())
                    {
                        if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
                        {
                            if (ComboOption.UseW && W.IsReady())
                            {
                                W.Cast();
                            }
                        }
                    }
                }
                break;

                case GameObjectType.AIMinionClient:
                {
                    if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
                    {
                        var mob = (AIMinionClient)Args.Target;
                        if (mob != null && mob.IsValidTarget() && mob.GetJungleType() != JungleType.Unknown &&
                            mob.GetJungleType() != JungleType.Small)
                        {
                            if (JungleClearOption.HasEnouguMana() && GetPassiveCount < 3)
                            {
                                if (JungleClearOption.UseW && W.IsReady())
                                {
                                    W.Cast();
                                }
                            }
                        }
                    }
                }
                break;

                case GameObjectType.AITurretClient:
                case GameObjectType.HQClient:
                case GameObjectType.Barracks:
                case GameObjectType.BarracksDampenerClient:
                case GameObjectType.BuildingClient:
                {
                    if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellFarm && LaneClearOption.HasEnouguMana(true))
                    {
                        if (Me.CountEnemyHeroesInRange(800) == 0)
                        {
                            if (LaneClearOption.UseW && W.IsReady())
                            {
                                W.Cast();
                            }
                        }
                    }
                }
                break;
                }
            }

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

                switch (Args.Target.Type)
                {
                case GameObjectType.AIHeroClient:
                {
                    var target = (AIHeroClient)Args.Target;
                    if (target != null && target.IsValidTarget())
                    {
                        if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
                        {
                            if (ComboOption.UseQ && Q.IsReady())
                            {
                                if (!isWActive)
                                {
                                    var qPred = Q.GetPrediction(target);

                                    if (qPred.Hitchance >= HitChance.High)
                                    {
                                        Q.Cast(qPred.CastPosition);
                                    }
                                }
                            }

                            if (ComboOption.UseW && W.IsReady())
                            {
                                W.Cast();
                            }
                        }
                        else if (Orbwalker.ActiveMode == OrbwalkerMode.Harass ||
                                 Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellHarass)
                        {
                            if (HarassOption.HasEnouguMana() && HarassOption.GetHarassTargetEnabled(target.CharacterName))
                            {
                                if (HarassOption.UseQ && Q.IsReady())
                                {
                                    var qPred = Q.GetPrediction(target);
                                    if (qPred.Hitchance >= HitChance.High)
                                    {
                                        Q.Cast(qPred.CastPosition);
                                    }
                                }
                            }
                        }
                    }
                }
                break;
                }
            }
        }
Пример #14
0
        private static void Initializer()
        {
            Q = new Spell(SpellSlot.Q, 1150f);
            Q.SetSkillshot(0.25f, 60f, 2000f, true, false, SkillshotType.Line);

            W = new Spell(SpellSlot.W, 950f);
            W.SetSkillshot(0.25f, 60f, 1200f, false, false, SkillshotType.Line);

            E = new Spell(SpellSlot.E, 475f)
            {
                Delay = 0.65f
            };

            R = new Spell(SpellSlot.R, 5000f);
            R.SetSkillshot(1.05f, 160f, 2200f, false, false, SkillshotType.Line);

            EQ = new Spell(SpellSlot.Q, 1625f);
            EQ.SetSkillshot(0.90f, 60f, 1350f, true, false, SkillshotType.Line);

            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddW();
            ComboOption.AddE();
            ComboOption.AddBool("ComboECheck", "Use E |Safe Check");
            ComboOption.AddBool("ComboEWall", "Use E |Wall Check");
            ComboOption.AddR();

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddW();
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddQ();
            LaneClearOption.AddBool("LaneClearQLH", "Use Q| Only LastHit", false);
            LaneClearOption.AddW();
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddW();
            JungleClearOption.AddMana();

            LastHitOption.AddMenu();
            LastHitOption.AddQ();
            LastHitOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddQ();

            //GapcloserOption.AddMenu();

            MiscOption.AddMenu();
            MiscOption.AddBasic();
            MiscOption.AddR();
            MiscOption.AddBool("R", "AutoR", "Auto R");
            MiscOption.AddSlider("R", "RRange", "Auto R |Min Cast Range >= x", 800, 0, 1500);
            MiscOption.AddSlider("R", "RMaxRange", "Auto R |Max Cast Range >= x", 3000, 1500, 5000);
            MiscOption.AddKey("R", "SemiR", "Semi-manual R Key", Keys.T, KeyBindType.Press);

            DrawOption.AddMenu();
            DrawOption.AddQ(Q);
            DrawOption.AddW(W);
            DrawOption.AddE(E);
            DrawOption.AddDamageIndicatorToHero(true, true, true, true, true);

            Game.OnUpdate += OnUpdate;
            //Gapcloser.OnGapcloser += OnGapcloser;
            Orbwalker.OnAction += OnAction;
        }
Пример #15
0
        private static void OnAction(object sender, OrbwalkerActionArgs Args)
        {
            if (Args.Type != OrbwalkerType.AfterAttack)
            {
                return;
            }

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

            switch (Args.Target.Type)
            {
            case GameObjectType.AIHeroClient:
            {
                var target = (AIHeroClient)Args.Target;

                if (target != null && target.IsValidTarget())
                {
                    if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
                    {
                        if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                        {
                            Q.CastOnUnit(target);
                        }
                        else if (ComboOption.UseW && ComboOption.GetBool("ComboWAA").Enabled&& W.IsReady() &&
                                 target.IsValidTarget(W.Range) && HasPassive(target))
                        {
                            var wPred = W.GetPrediction(target);

                            if (wPred.Hitchance >= HitChance.High)
                            {
                                W.Cast(wPred.UnitPosition);
                            }
                        }
                    }
                    else if (Orbwalker.ActiveMode == OrbwalkerMode.Harass ||
                             Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellHarass)
                    {
                        if (HarassOption.HasEnouguMana())
                        {
                            if (HarassOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                            {
                                Q.CastOnUnit(target);
                            }
                            else if (HarassOption.UseW && W.IsReady() && target.IsValidTarget(W.Range) &&
                                     HasPassive(target))
                            {
                                var wPred = W.GetPrediction(target);

                                if (wPred.Hitchance >= HitChance.High)
                                {
                                    W.Cast(wPred.UnitPosition);
                                }
                            }
                        }
                    }
                }
            }
            break;
            }
        }
Пример #16
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana())
            {
                if (HarassOption.UseQ && Q.IsReady())
                {
                    var target = HarassOption.GetTarget(Q.Range + 300);

                    if (target.IsValidTarget(Q.Range))
                    {
                        Q.Cast(target);
                    }
                    else if (target.IsValidTarget(Q.Range + 300) && HarassOption.GetBool("HarassQMinion").Enabled)
                    {
                        if (Me.HasBuff("JhinPassiveReload") || !Me.HasBuff("JhinPassiveReload") &&
                            Me.CountEnemyHeroesInRange(Me.AttackRange + Me.BoundingRadius) == 0)
                        {
                            var qPred =
                                SpellPrediction.GetPrediction(new SpellPrediction.PredictionInput {
                                Unit = target, Delay = 0.25f
                            });
                            var bestQMinion =
                                GameObjects.EnemyMinions.Where(x => x.IsValidTarget(300, true, qPred.CastPosition) && x.MaxHealth > 5)
                                .Where(x => x.IsValidTarget(Q.Range))
                                .OrderBy(x => x.Distance(target))
                                .ThenBy(x => x.Health)
                                .FirstOrDefault();

                            if (bestQMinion != null && bestQMinion.IsValidTarget(Q.Range))
                            {
                                Q.CastOnUnit(bestQMinion);
                            }
                        }
                    }
                }

                if (HarassOption.UseE && E.IsReady() && Variables.GameTimeTickCount - lastETime > 2500 && !isAttacking)
                {
                    var target = HarassOption.GetTarget(E.Range);

                    if (target.IsValidTarget(E.Range))
                    {
                        var ePred = E.GetPrediction(target);

                        if (ePred.Hitchance >= HitChance.High)
                        {
                            E.Cast(ePred.CastPosition);
                        }
                    }
                }

                if (HarassOption.UseW && W.IsReady())
                {
                    var target = HarassOption.GetTarget(1500);

                    if (target.IsValidTarget(W.Range))
                    {
                        if (HarassOption.GetBool("HarassWOnly").Enabled&& !HasPassive(target))
                        {
                            return;
                        }

                        var wPred = W.GetPrediction(target);

                        if (wPred.Hitchance >= HitChance.High)
                        {
                            W.Cast(wPred.UnitPosition);
                        }
                    }
                }
            }
        }
Пример #17
0
        internal static void Init()
        {
            Q = new Spell(SpellSlot.Q, 1150f)
            {
                MinHitChance = HitChance.VeryHigh
            };
            W  = new Spell(SpellSlot.W, 950f);
            E  = new Spell(SpellSlot.E, 475f);
            R  = new Spell(SpellSlot.R, 10000f);
            EQ = new Spell(SpellSlot.Q, 1150f + 475f);

            EQ.SetSkillshot(0.25f + 0.65f, 60f, 2000f, true, SkillshotType.SkillshotLine);
            Q.SetSkillshot(0.25f, 60f, 2000f, true, SkillshotType.SkillshotLine);
            W.SetSkillshot(0.25f, 80f, 1600f, false, SkillshotType.SkillshotLine);
            R.SetSkillshot(1.1f, 160f, 2000f, false, SkillshotType.SkillshotLine);

            ComboOption.AddQ();
            ComboOption.AddW();
            ComboOption.AddE();
            ComboOption.AddBool("ComboECheck", "Use E | Safe Check");
            ComboOption.AddBool("ComboEWall", "Use E | Wall Check");
            ComboOption.AddR();

            HarassOption.AddQ();
            HarassOption.AddW();
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddQ();
            LaneClearOption.AddBool("LaneClearQLH", "Use Q| Only LastHit", false);
            LaneClearOption.AddW();
            LaneClearOption.AddMana();

            JungleClearOption.AddQ();
            JungleClearOption.AddMana();

            LastHitOption.AddQ();
            LastHitOption.AddMana();

            FleeOption.AddMove();

            KillStealOption.AddQ();
            KillStealOption.AddW();

            MiscOption.AddE();
            MiscOption.AddBool("Gapcloser", "Anti GapCloser");
            MiscOption.AddBool("AntiMelee", "Anti Melee");
            MiscOption.AddSlider("AntiMeleeHp", "Anti Melee|When Player HealthPercent <= x%", 50);
            MiscOption.AddR();
            MiscOption.AddBool("AutoR", "Auto R?");
            MiscOption.AddSlider("RRange", "Use R |Min Cast Range >= x", 800, 0, 1500);
            MiscOption.AddSlider("RMaxRange", "Use R |Max Cast Range >= x", 3000, 1500, 5000);
            MiscOption.AddSlider("RMinCast", "Use R| Min Hit Enemies >= x (6 = off)", 2, 1, 6);
            MiscOption.AddKey("SemiR", "Semi-manual R Key", SharpDX.DirectInput.Key.T);
            MiscOption.AddSetting("Mode");
            MiscOption.AddList("PlayMode", "Play Mode: ", new[] { "AD", "AP" });

            DrawOption.AddQ();
            DrawOption.AddW();
            DrawOption.AddE();
            DrawOption.AddFarm();
            DrawOption.AddEvent();

            Game.OnUpdate                  += OnUpdate;
            Orbwalker.BeforeAttack         += BeforeAttack;
            Orbwalker.AfterAttack          += AfterAttack;
            AntiGapcloser.OnEnemyGapcloser += OnEnemyGapcloser;
            Obj_AI_Base.OnProcessSpellCast += OnProcessSpellCast;
        }
Пример #18
0
        private static void Initializer()
        {
            Q = new Spell(SpellSlot.Q, 1250f);
            Q.SetSkillshot(0.70f, 50f, 2000f, false, false, SkillshotType.Line);

            W = new Spell(SpellSlot.W, 800f);
            W.SetSkillshot(0.80f, 80f, 2000f, false, false, SkillshotType.Circle);

            E = new Spell(SpellSlot.E, 750f);
            E.SetSkillshot(0.25f, 60f, 1600f, true, false, SkillshotType.Line);

            R = new Spell(SpellSlot.R, rRange)
            {
                Delay = 1.5f
            };

            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddSlider("ComboQCount", "Use Q |Min Hit Count >= x(0 = Off)", 3, 0, 5);
            ComboOption.AddSlider("ComboQRange", "UseQ |Min Cast Range >= x", 800, 500, 1100);
            ComboOption.AddW();
            ComboOption.AddSlider("ComboWCount", "Use W|Min Stack >= x", 1, 1, 3);
            ComboOption.AddE();
            ComboOption.AddR();
            ComboOption.AddBool("ComboRSafe", "Use R|Safe Check");
            ComboOption.AddSlider("ComboRRange", "Use R|Min Cast Range >= x", 900, 500, 1500);

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddQ();
            LaneClearOption.AddSlider("LaneClearQCount", "Use Q|Min Hit Count >= x", 3, 1, 5);
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddQ();

            //GapcloserOption.AddMenu();

            MiscOption.AddMenu();
            MiscOption.AddBasic();
            MiscOption.AddQ();
            MiscOption.AddBool("Q", "AutoQ", "Use Q| CC");
            MiscOption.AddW();
            MiscOption.AddBool("W", "AutoWCC", "Use W| CC");
            MiscOption.AddBool("W", "AutoWTP", "Use W| TP");
            MiscOption.AddE();
            MiscOption.AddBool("E", "AutoE", "Use E| Anti Gapcloser");
            MiscOption.AddR();
            MiscOption.AddKey("R", "SemiR", "Semi-manual R Key", Keys.T, KeyBindType.Press);
            //MiscOption.AddSetting("EQ");
            //MiscOption.AddKey("EQKey", "Semi-manual EQ Key", KeyCode.G, KeyBindType.Press);

            DrawOption.AddMenu();
            DrawOption.AddQ(Q);
            DrawOption.AddW(W);
            DrawOption.AddE(E);
            DrawOption.AddR(R);
            DrawOption.AddDamageIndicatorToHero(true, false, true, true, true);

            Game.OnTick += OnUpdate;
            //Gapcloser.OnGapcloser += OnGapcloser;
            AIBaseClient.OnProcessSpellCast += OnProcessSpellCast;
        }
Пример #19
0
        private static void Initializer()
        {
            Q = new Spell(SpellSlot.Q, 525f);

            W = new Spell(SpellSlot.W, 1500f);
            W.SetSkillshot(0.60f, 60f, 3300f, true, false, SkillshotType.Line);

            E = new Spell(SpellSlot.E, 900f);
            E.SetSkillshot(1.20f, 100f, 1750f, false, false, SkillshotType.Circle);

            R = new Spell(SpellSlot.R, 3000f);
            R.SetSkillshot(0.70f, 140f, 1500f, true, false, SkillshotType.Line);

            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddW();
            ComboOption.AddE();
            ComboOption.AddR();
            ComboOption.AddBool("ComboRSolo", "Use R| Solo Mode");
            ComboOption.AddBool("ComboRTeam", "Use R| Team Fight");

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddW();
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddQ();
            LaneClearOption.AddSlider("LaneClearQCount", "Use Q| Min Hit Count >= x", 3, 1, 5);
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddW();
            JungleClearOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddW();
            KillStealOption.AddR();
            KillStealOption.AddTargetList();

            //GapcloserOption.AddMenu();

            MiscOption.AddMenu();
            MiscOption.AddBasic();
            MiscOption.AddW();
            MiscOption.AddBool("W", "AutoW", "Auto W| CC");
            MiscOption.AddE();
            MiscOption.AddBool("E", "AutoE", "Auto E| CC");
            MiscOption.AddBool("E", "AutoETP", "Auto E| Teleport");
            MiscOption.AddR();
            MiscOption.AddKey("R", "rMenuSemi", "Semi-manual R Key", Keys.T, KeyBindType.Press);
            MiscOption.AddSlider("R", "rMenuMin", "Use R| Min Range >= x", 1000, 500, 2500);
            MiscOption.AddSlider("R", "rMenuMax", "Use R| Max Range <= x", 3000, 1500, 3500);

            DrawOption.AddMenu();
            DrawOption.AddW(W);
            DrawOption.AddE(E);
            DrawOption.AddDamageIndicatorToHero(false, true, false, true, true);

            Game.OnUpdate      += OnUpdate;
            Orbwalker.OnAction += OnAction;
            //Gapcloser.OnGapcloser += OnGapcloser;
        }
Пример #20
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana())
            {
                var target = HarassOption.GetTarget(1600f);

                if (target.IsValidTarget(1600f))
                {
                    if (HarassOption.UseQ && Q.IsReady() && target.IsValidTarget(1600))
                    {
                        if (Q.IsCharging)
                        {
                            if (target != null && target.IsValidTarget(Q.ChargedMaxRange))
                            {
                                if (target.IsValidTarget(800))
                                {
                                    Q.ShootChargedSpell(target.Position);
                                }
                                else
                                {
                                    var qPred = Q.GetPrediction(target);

                                    if (qPred.Hitchance >= HitChance.High)
                                    {
                                        Q.ShootChargedSpell(qPred.CastPosition);
                                    }
                                }
                            }
                            else
                            {
                                foreach (
                                    var t in
                                    GameObjects.EnemyHeroes.Where(
                                        x => !x.IsDead && x.IsValidTarget(Q.ChargedMaxRange))
                                    .OrderBy(x => x.Health))
                                {
                                    if (t.IsValidTarget(800))
                                    {
                                        Q.ShootChargedSpell(t.Position);
                                    }
                                    else if (t.IsValidTarget(Q.ChargedMinRange))
                                    {
                                        var qPred = Q.GetPrediction(t);

                                        if (qPred.Hitchance >= HitChance.High)
                                        {
                                            Q.ShootChargedSpell(qPred.CastPosition);
                                        }
                                    }
                                }
                            }
                        }
                        else
                        {
                            Q.StartCharging();
                        }
                    }

                    if (Q.IsCharging)
                    {
                        return;
                    }

                    if (HarassOption.UseE && E.IsReady() && target.IsValidTarget(E.Range))
                    {
                        var ePred = E.GetPrediction(target);

                        if (ePred.Hitchance >= HitChance.High)
                        {
                            E.Cast(ePred.UnitPosition);
                        }
                    }
                }
            }
        }
Пример #21
0
        private static void Initializer()
        {
            Q = new Spell(SpellSlot.Q);

            W = new Spell(SpellSlot.W);

            E = new Spell(SpellSlot.E, 950f);
            E.SetSkillshot(0.25f, 100f, 1400f, false, false, SkillshotType.Line);

            R = new Spell(SpellSlot.R, 3000f);
            R.SetSkillshot(0.4f, 160f, 2000f, false, false, SkillshotType.Line);

            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddW();
            ComboOption.AddE();
            ComboOption.AddR();
            ComboOption.AddBool("RSolo", "Use R | Solo Ks Mode");
            ComboOption.AddBool("RTeam", "Use R| Team Fight");

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddE();
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddQ();
            LaneClearOption.AddSliderBool("LaneClearECount", "Use E| Min Hit Count >= x", 4, 1, 7, true);
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddW();
            JungleClearOption.AddE();
            JungleClearOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddE();
            KillStealOption.AddR();
            KillStealOption.AddTargetList();

            AxeOption.AddMenu();
            AxeOption.AddList("CatchMode", "Catch Axe Mode: ", new[] { "All", "Only Combo", "Off" });
            AxeOption.AddSlider("CatchRange", "Catch Axe Range(Cursor center)", 2000, 180, 3000);
            AxeOption.AddSlider("CatchCount", "Max Axe Count <= x", 2, 1, 3);
            AxeOption.AddBool("CatchWSpeed", "Use W| When Axe Too Far");
            AxeOption.AddBool("NotCatchKS", "Dont Catch| If Target Can KillAble(1-3 AA)");
            AxeOption.AddBool("NotCatchTurret", "Dont Catch| If Axe Under Enemy Turret");
            AxeOption.AddSliderBool("NotCatchMoreEnemy", "Dont Catch| If Enemy Count >= x", 3, 1, 5, true);
            AxeOption.AddBool("CancelCatch", "Enabled Cancel Catch Axe Key");
            AxeOption.AddKey("CancelKey1", "Cancel Catch Key 1", Keys.G, KeyBindType.Press);
            AxeOption.AddBool("CancelKey2", "Cancel Catch Key 2(is right click)");
            AxeOption.AddBool("CancelKey3", "Cancel Catch Key 3(is mouse scroll)", false);
            AxeOption.AddSeperator("Set Orbwalker->Misc->Hold Radius to 0 (will better)");

            //GapcloserOption.AddMenu();

            MiscOption.AddMenu();
            MiscOption.AddBasic();
            MiscOption.AddW();
            MiscOption.AddBool("W", "WSlow", "Auto W| When Player Have Debuff(Slow)");
            MiscOption.AddR();
            MiscOption.AddSlider("R", "GlobalRMin", "Global -> Cast R Min Range", 1000, 500, 2500);
            MiscOption.AddSlider("R", "GlobalRMax", "Global -> Cast R Max Range", 3000, 1500, 3500);
            MiscOption.AddKey("R", "SemiRKey", "Semi-manual R Key", Keys.T, KeyBindType.Press);

            DrawOption.AddMenu();
            DrawOption.AddE(E);
            DrawOption.AddR(R);
            DrawOption.AddBool("AxeRange", "Draw Catch Axe Range");
            DrawOption.AddBool("AxePosition", "Draw Axe Position");
            DrawOption.AddDamageIndicatorToHero(true, false, true, true, true);

            AxeOption.GetKey("CancelKey1").ValueChanged += OnCancelValueChange;

            Tick.OnTick         += OnUpdate;
            Game.OnWndProc      += OnWndProc;
            GameObject.OnCreate += (sender, args) => OnCreate(sender);
            GameObject.OnDelete += (sender, args) => OnDestroy(sender);
            //Gapcloser.OnGapcloser += OnGapcloser;
            Orbwalker.OnAction += OnAction;
            Drawing.OnDraw     += OnRender;
        }
Пример #22
0
        internal static void Init()
        {
            Q = new Spell(SpellSlot.Q, 980f);
            W = new Spell(SpellSlot.W, Me.AttackRange);
            E = new Spell(SpellSlot.E, 1200f);
            R = new Spell(SpellSlot.R, 1800f);

            Q.SetSkillshot(0.25f, 50f, 2000f, true, SkillshotType.SkillshotLine);
            E.SetSkillshot(0.25f, 120f, 1400f, false, SkillshotType.SkillshotLine);
            R.SetSkillshot(1.2f, 120f, float.MaxValue, false, SkillshotType.SkillshotCircle);

            ComboOption.AddQ();
            ComboOption.AddW();
            ComboOption.AddE();
            ComboOption.AddR();
            ComboOption.AddSlider("ComboRLimit", "Use R| Limit Stack >= x", 3, 0, 10);

            HarassOption.AddQ();
            HarassOption.AddE();
            HarassOption.AddR();
            HarassOption.AddSlider("HarassRLimit", "Use R| Limit Stack >= x", 5, 0, 10);
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddQ();
            LaneClearOption.AddE();
            LaneClearOption.AddSlider("LaneClearECount", "Use E| Min Hit Counts >= x", 3, 1, 5);
            LaneClearOption.AddR();
            LaneClearOption.AddSlider("LaneClearRLimit", "Use R| Limit Stack >= x", 4, 0, 10);
            LaneClearOption.AddMana();

            JungleClearOption.AddQ();
            JungleClearOption.AddW();
            JungleClearOption.AddE();
            JungleClearOption.AddR();
            JungleClearOption.AddSlider("JungleClearRLimit", "Use R| Limit Stack >= x", 5, 0, 10);
            JungleClearOption.AddMana();

            LastHitOption.AddNothing();

            FleeOption.AddMove(false);

            KillStealOption.AddQ();
            KillStealOption.AddE();
            KillStealOption.AddR();

            MiscOption.AddE();
            MiscOption.AddBool("GapE", "Use E| Anti GapCloser");
            MiscOption.AddR();
            MiscOption.AddKey("SemiR", "Semi-manual R Key", SharpDX.DirectInput.Key.T);

            DrawOption.AddQ();
            DrawOption.AddW();
            DrawOption.AddE();
            DrawOption.AddR();
            DrawOption.AddFarm();
            DrawOption.AddEvent();

            Game.OnUpdate                  += OnUpdate;
            Orbwalker.AfterAttack          += AfterAttack;
            AntiGapcloser.OnEnemyGapcloser += OnEnemyGapcloser;
        }
Пример #23
0
        private static void Initializer()
        {
            Q = new Spell(SpellSlot.Q, 925f);
            Q.SetSkillshot(0.25f, 70f, 1650f, false, false, SkillshotType.Line);
            Q.SetCharged("VarusQ", "VarusQ", 925, 1600, 1.5f);

            W = new Spell(SpellSlot.W, 0f);

            E = new Spell(SpellSlot.E, 975f);
            E.SetSkillshot(0.35f, 120f, 1500f, false, true, SkillshotType.Circle);

            R = new Spell(SpellSlot.R, 1050f);
            R.SetSkillshot(0.25f, 120f, 1950f, false, false, SkillshotType.Line);

            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddSlider("ComboQPassive", "Use Q |Target Stack Count >= x", 3, 0, 3);
            ComboOption.AddBool("ComboQFast", "Use Q |Fast Cast");
            ComboOption.AddW();
            ComboOption.AddE();
            ComboOption.AddSlider("ComboEPassive", "Use E |Target Stack Count >= x", 3, 0, 3);
            ComboOption.AddR();
            ComboOption.AddBool("ComboRSolo", "Use R |Solo Mode");
            ComboOption.AddSlider("ComboRCount", "Use R |Min Hit Count >= x", 3, 1, 5);

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddE(false);
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddQ();
            LaneClearOption.AddSlider("LaneClearQCount", "Use Q |Min Hit Count >= x", 3, 1, 5);
            LaneClearOption.AddE();
            LaneClearOption.AddSlider("LaneClearECount", "Use E |Min Hit Count >= x", 3, 1, 5);
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddE();
            JungleClearOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddQ();
            KillStealOption.AddE();

            //GapcloserOption.AddMenu();

            MiscOption.AddMenu();
            MiscOption.AddBasic();
            MiscOption.AddR();
            MiscOption.AddKey("R", "SemiR", "Semi-manual R Key", Keys.T, KeyBindType.Press);
            MiscOption.AddBool("R", "AutoR", "Auto R |Anti Gapcloser");

            DrawOption.AddMenu();
            DrawOption.AddQ(Q);
            DrawOption.AddE(E);
            DrawOption.AddR(R);
            DrawOption.AddDamageIndicatorToHero(true, true, true, true, true);

            Game.OnTick += OnUpdate;
            //Gapcloser.OnGapcloser += OnGapcloser;
            AIBaseClient.OnProcessSpellCast += OnProcessSpellCast;
            Spellbook.OnCastSpell           += OnCastSpell;
        }
Пример #24
0
        private static void OnAction(object sender, OrbwalkerActionArgs Args)
        {
            if (Args.Type != OrbwalkerType.AfterAttack)
            {
                return;
            }

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

            switch (Args.Target.Type)
            {
            case GameObjectType.AIHeroClient:
            {
                var target = (AIHeroClient)Args.Target;
                if (target != null && target.IsValidTarget())
                {
                    if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
                    {
                        if (ComboOption.UseW && W.IsReady() && !isWActive)
                        {
                            if (GameObjects.EnemyHeroes.Any(x => x.IsValidTarget(W.Range)))
                            {
                                if (target.IsValidTarget(E.Range) && HaveEBuff(target))
                                {
                                    W.Cast();
                                }
                                else if (!E.IsReady() && target.IsValidTarget(350) && Variables.GameTimeTickCount - lastETime < 1500 + Game.Ping)
                                {
                                    W.Cast();
                                }
                            }
                        }
                        else if (ComboOption.UseQ && Q.IsReady())
                        {
                            var qPred = Q.GetPrediction(target);

                            if (qPred.Hitchance >= HitChance.High)
                            {
                                Q.Cast(qPred.UnitPosition);
                            }
                        }
                    }
                    else if (Orbwalker.ActiveMode == OrbwalkerMode.Harass ||
                             Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellHarass)
                    {
                        if (HarassOption.HasEnouguMana() && HarassOption.GetHarassTargetEnabled(target.CharacterName))
                        {
                            if (HarassOption.UseQ && Q.IsReady())
                            {
                                var qPred = Q.GetPrediction(target);

                                if (qPred.Hitchance >= HitChance.High)
                                {
                                    Q.Cast(qPred.UnitPosition);
                                }
                            }
                        }
                    }
                }
            }
            break;

            case GameObjectType.AIMinionClient:
            {
                var mob = (AIMinionClient)Args.Target;
                if (mob != null && mob.IsValidTarget() && mob.GetJungleType() != JungleType.Unknown && mob.GetJungleType() != JungleType.Small)
                {
                    if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellFarm && JungleClearOption.HasEnouguMana())
                    {
                        if (JungleClearOption.UseQ && Q.IsReady() && mob.IsValidTarget(Q.Range))
                        {
                            Q.Cast(mob.PreviousPosition);
                        }
                    }
                }
            }
            break;
            }
        }
Пример #25
0
        private static void Initializer()
        {
            Q = new Spell(SpellSlot.Q, 825f);
            Q.SetSkillshot(0.30f, 200f, 1000f, false, false, SkillshotType.Circle);

            W = new Spell(SpellSlot.W, 800f);

            E = new Spell(SpellSlot.E, 600f);

            R = new Spell(SpellSlot.R, rRange);
            R.SetSkillshot(0.20f, 50f, 2000f, true, false, SkillshotType.Line);

            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddE();
            ComboOption.AddR();
            ComboOption.AddSlider("ComboRLimit", "Use R|Limit Stack >= x", 0, 0, 7);
            ComboOption.AddSlider("ComboRHP", "Use R|Target HealthPercent <= x%", 100, 1, 101);

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddE();
            HarassOption.AddR();
            HarassOption.AddSlider("HarassRLimit", "Use R|Limit Stack >= x", 4, 0, 7);
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddQ();
            LaneClearOption.AddSlider("LaneClearQCount", "Use Q|Min Hit Count >= x", 3, 1, 5);
            LaneClearOption.AddE();
            LaneClearOption.AddSlider("LaneClearECount", "Use E|Min Hit Count >= x", 3, 1, 5);
            LaneClearOption.AddR();
            LaneClearOption.AddSlider("LaneClearRCount", "Use R|Min Hit Count >= x", 3, 1, 5);
            LaneClearOption.AddSlider("LaneClearRLimit", "Use R|Limit Stack >= x", 4, 0, 7);
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddE();
            JungleClearOption.AddR();
            JungleClearOption.AddSlider("JungleClearRLimit", "Use R|Limit Stack >= x", 0, 0, 7);
            JungleClearOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddQ();
            KillStealOption.AddR();

            MiscOption.AddMenu();
            MiscOption.AddBasic();
            MiscOption.AddR();
            MiscOption.AddKey("R", "SemiR", "Semi-manual R Key", Keys.T, KeyBindType.Press);

            DrawOption.AddMenu();
            DrawOption.AddQ(Q);
            DrawOption.AddW(W);
            DrawOption.AddE(E);
            DrawOption.AddR(R);
            DrawOption.AddDamageIndicatorToHero(true, false, true, true, true);

            Game.OnUpdate      += OnUpdate;
            Orbwalker.OnAction += OnAction;
        }
Пример #26
0
        private static void Initializer()
        {
            Q = new Aimtec.SDK.Spell(SpellSlot.Q, 825f);
            Q.SetSkillshot(0.30f, 200f, 1000f, false, SkillshotType.Circle);

            W = new Aimtec.SDK.Spell(SpellSlot.W, 800f);

            E = new Aimtec.SDK.Spell(SpellSlot.E, 600f);

            R = new Aimtec.SDK.Spell(SpellSlot.R, 1300f);
            R.SetSkillshot(0.20f, 50f, 2000f, true, SkillshotType.Line);

            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddE();
            ComboOption.AddR();
            ComboOption.AddSlider("ComboRLimit", "Use R|Limit Stack >= x", 0, 0, 7);
            ComboOption.AddSlider("ComboRHP", "Use R|Target HealthPercent <= x%", 100, 1, 101);

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddE();
            HarassOption.AddR();
            HarassOption.AddSlider("HarassRLimit", "Use R|Limit Stack >= x", 4, 0, 7);
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddQ();
            LaneClearOption.AddSlider("LaneClearQCount", "Use Q|Min Hit Count >= x", 3, 1, 5);
            LaneClearOption.AddE();
            LaneClearOption.AddSlider("LaneClearECount", "Use E|Min Hit Count >= x", 3, 1, 5);
            LaneClearOption.AddR();
            LaneClearOption.AddSlider("LaneClearRCount", "Use R|Min Hit Count >= x", 3, 1, 5);
            LaneClearOption.AddSlider("LaneClearRLimit", "Use R|Limit Stack >= x", 4, 0, 7);
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddE();
            JungleClearOption.AddR();
            JungleClearOption.AddSlider("JungleClearRLimit", "Use R|Limit Stack >= x", 0, 0, 7);
            JungleClearOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddQ();
            KillStealOption.AddR();

            MiscOption.AddMenu();
            MiscOption.AddBasic();
            MiscOption.AddR();
            MiscOption.AddKey("SemiR", "Semi R Key", KeyCode.T, KeybindType.Press);

            DrawOption.AddMenu();
            DrawOption.AddQ(Q.Range);
            DrawOption.AddW(W.Range);
            DrawOption.AddE(E.Range);
            DrawOption.AddR(R.Range);
            DrawOption.AddFarm();
            DrawOption.AddEvent();

            Game.OnUpdate        += OnUpdate;
            Orbwalker.PostAttack += PostAttack;
        }
Пример #27
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                var target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                if (target.IsValidTarget(R.Range))
                {
                    if (HarassOption.UseR && R.IsReady() && HarassOption.GetSlider("HarassRLimit") >= GetRCount &&
                        target.IsValidTarget(R.Range))
                    {
                        SpellManager.PredCast(R, target, true);
                    }

                    if (HarassOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                    {
                        SpellManager.PredCast(Q, target);
                    }

                    if (HarassOption.UseE && E.IsReady() && target.IsValidTarget(E.Range))
                    {
                        SpellManager.PredCast(E, target, true);
                    }
                }
            }
        }
Пример #28
0
        private static void Initializer()
        {
            Q = new Spell(SpellSlot.Q, 1450f);
            Q.SetSkillshot(0.25f, 40f, 1000f, false, false, SkillshotType.Line);

            W = new Spell(SpellSlot.W, 850f);

            E = new Spell(SpellSlot.E);

            R = new Spell(SpellSlot.R, 5500f);

            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddBool("ComboSaveMana", "Use Q| Save Mana To Cast W");
            ComboOption.AddW();
            ComboOption.AddList("ComboWSmartKS", "Use W| Smart Card KillAble", new[] { "First Card", "Blue Card", "Off" });
            ComboOption.AddBool("ComboDisableAA", "Auto Disable Attack| When Selecting");

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddQ();
            LaneClearOption.AddSlider("LaneClearQCount", "Use Q|Min Hit Count >= x", 4, 1, 10);
            LaneClearOption.AddW();
            LaneClearOption.AddBool("LaneClearWBlue", "Use W| Blue Card");
            LaneClearOption.AddBool("LaneClearWRed", "Use W| Red Card");
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddW();
            JungleClearOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddQ();

            //GapcloserOption.AddMenu();

            MiscOption.AddMenu();
            MiscOption.AddBasic();
            MiscOption.AddSubMenu("CardSelect", "Card Select Settings");
            MiscOption.AddKey("CardSelect", "CardSelectYellow", "Gold Card", Keys.W, KeyBindType.Press);
            MiscOption.AddKey("CardSelect", "CardSelectBlue", "Blue Card", Keys.E, KeyBindType.Press);
            MiscOption.AddKey("CardSelect", "CardSelectRed", "Red Card", Keys.T, KeyBindType.Press);
            MiscOption.AddBool("CardSelect", "HumanizerSelect", "Humanizer Select Card", false);
            MiscOption.AddSlider("CardSelect", "HumanizerSelectMin", "Humanizer Select Card Min Delay", 0, 0, 2000);
            MiscOption.AddSlider("CardSelect", "HumanizerSelectMax", "Humanizer Select Card Max Delay", 2000, 0, 3500);
            MiscOption.AddQ();
            MiscOption.AddBool("Q", "AutoQImmobile", "Auto Q|Enemy Cant Movement");
            MiscOption.AddKey("Q", "SemiQ", "Semi-manual Q Key", Keys.Q, KeyBindType.Press);
            MiscOption.AddR();
            MiscOption.AddBool("R", "UltYellow", "Auto Gold Card| In Ult");

            DrawOption.AddMenu();
            DrawOption.AddQ(Q);
            DrawOption.AddR(R);
            DrawOption.AddDamageIndicatorToHero(true, true, true, false, true);

            Game.OnTick += OnUpdate;
            //Gapcloser.OnGapcloser += OnGapcloser;
            AIBaseClient.OnProcessSpellCast += OnProcessSpellCast;
            Orbwalker.OnAction += OnAction;
        }
Пример #29
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                if (E.IsReady())
                {
                    if (HarassOption.UseE)
                    {
                        var target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                        if (target.IsValidTarget(E.Range))
                        {
                            E.CastOnUnit(target, true);
                        }
                    }

                    if (HarassOption.GetBool("HarassEToMinion"))
                    {
                        foreach (var minion in MinionManager.GetMinions(E.Range).Where(m =>
                                                                                       m.Health < Me.GetAutoAttackDamage(m) && m.CountEnemiesInRange(m.BoundingRadius + 150) >= 1))
                        {
                            var etarget = E.GetTarget();

                            if (etarget != null)
                            {
                                return;
                            }

                            E.CastOnUnit(minion, true);
                            myOrbwalker.ForceTarget(minion);
                        }
                    }
                }
            }
        }
Пример #30
0
        private static void Initializer()
        {
            Q = new Spell(SpellSlot.Q, 700f)
            {
                Delay = 0.25f, Speed = 1400f
            };

            Q2 = new Spell(SpellSlot.Q, 1300f);
            Q2.SetSkillshot(0.25f, 70f, 1500f, true, false, SkillshotType.Line);

            W = new Spell(SpellSlot.W);

            E = new Spell(SpellSlot.E, 1000f);
            E.SetSkillshot(0.5f, 200f, float.MaxValue, false, false, SkillshotType.Circle);

            R = new Spell(SpellSlot.R, 1350f);
            R.SetSkillshot(0.25f, 50f, 3000f, false, false, SkillshotType.Cone);

            ComboOption.AddMenu();
            ComboOption.AddQ();
            ComboOption.AddBool("ComboQ1", "Use Q Extend");
            ComboOption.AddW();
            ComboOption.AddE();

            HarassOption.AddMenu();
            HarassOption.AddQ();
            HarassOption.AddBool("HarassQ1", "Use Q Extend");
            HarassOption.AddE();
            HarassOption.AddMana();
            HarassOption.AddTargetList();

            LaneClearOption.AddMenu();
            LaneClearOption.AddE();
            LaneClearOption.AddSlider("LaneClearECount", "Use E| Min Hit Counts >= x", 3, 1, 5);
            LaneClearOption.AddMana();

            JungleClearOption.AddMenu();
            JungleClearOption.AddQ();
            JungleClearOption.AddW();
            JungleClearOption.AddE();
            JungleClearOption.AddMana();

            KillStealOption.AddMenu();
            KillStealOption.AddQ();
            KillStealOption.AddE();

            //GapcloserOption.AddMenu();

            MiscOption.AddMenu();
            MiscOption.AddBasic();
            MiscOption.AddR();
            MiscOption.AddKey("R", "SemiR", "Semi-manual R Key", Keys.T, KeyBindType.Press);

            DrawOption.AddMenu();
            DrawOption.AddQ(Q);
            DrawOption.AddE(E);
            DrawOption.AddR(R);
            DrawOption.AddDamageIndicatorToHero(true, false, true, true, true);

            Game.OnUpdate      += OnUpdate;
            Orbwalker.OnAction += OnAction;
            AIBaseClient.OnProcessSpellCast += OnProcessSpellCast;
            //Gapcloser.OnGapcloser += OnGapcloser;
        }