示例#1
0
        private static void Game_OnUpdate(EventArgs args)
        {
            try // lazy
            {
                if (GlobalManager.GetHero.IsDead)
                {
                    return;
                }

                MenuManager.Orbwalker.SetAttack(true);

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

                if (GlobalManager.Config.Item("doHuman").GetValue <bool>())
                {
                    if (!Humanizer.CheckDelay("generalDelay")) // Wait for delay for all other events
                    {
                        Console.WriteLine("Waiting on Human Dealy");
                        return;
                    }
                    //Console.WriteLine("Seeding Human Delay");
                    var nDelay = Seeder.Next(GlobalManager.Config.Item("minDelay").GetValue <Slider>().Value, GlobalManager.Config.Item("maxDelay").GetValue <Slider>().Value); // set a new random delay :D
                    Humanizer.ChangeDelay("generalDelay", nDelay);
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
                {
                    MenuManager.Orbwalker.SetAttack((target.IsValidTarget() &&
                                                     (GlobalManager.GetHero.Distance(target) > 440) ||
                                                     (Champion.Q.IsReady() || Champion.E.IsReady() ||
                                                      Champion.W.IsReady())));
                    Champion.AABlock(!GlobalManager.Config.Item("AAblock").GetValue <bool>());
                    LaneOptions.ImprovedCombo();
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed)
                {
                    LaneOptions.Mixed();
                    MenuManager.Orbwalker.SetAttack(true);
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
                {
                    if (GlobalManager.Config.Item("disablelane").GetValue <KeyBind>().Active)
                    {
                        LaneOptions.LaneClear();
                    }


                    if (GlobalManager.Config.Item("presslane").GetValue <KeyBind>().Active)
                    {
                        LaneOptions.LaneClear();
                    }


                    MenuManager.Orbwalker.SetAttack(true);
                    LaneOptions.JungleClear();
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
                {
                    LaneOptions.LastHit();
                }


                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.None)
                {
                    if (GlobalManager.Config.Item("tearS").GetValue <KeyBind>().Active)
                    {
                        ItemManager.TearStack();
                    }

                    else if (GlobalManager.Config.Item("autoPassive").GetValue <KeyBind>().Active)
                    {
                        Champion.AutoPassive();
                    }

                    ItemManager.Potion();
                    MenuManager.Orbwalker.SetAttack(true);
                }

                if (GlobalManager.Config.Item("UseQauto").GetValue <bool>() && target != null)
                {
                    if (Champion.Q.IsReady() && target.IsValidTarget(Champion.Q.Range))
                    {
                        Champion.Q.Cast(target);
                    }
                }


                // Seplane();
                ItemManager.Item();
                Champion.KillSteal();
                ItemManager.Potion();

                if (GlobalManager.Config.Item("level").GetValue <bool>())
                {
                    AutoLevelManager.LevelUpSpells();
                }

                if (!GlobalManager.Config.Item("autow").GetValue <bool>() || !target.UnderTurret(true))
                {
                    return;
                }

                if (target == null)
                {
                    return;
                }

                if (!ObjectManager.Get <Obj_AI_Turret>()
                    .Any(turret => turret.IsValidTarget(300) && turret.IsAlly && turret.Health > 0))
                {
                    return;
                }

                Champion.W.CastOnUnit(target);
                // DebugClass.ShowDebugInfo(true);
            }
            catch
            {
                // ignored
            }
        }
示例#2
0
        private static void Game_OnUpdate(EventArgs args)
        {
            try // lazy
            {
                //var target2 = TargetSelector.GetTarget(Champion.Q.Range, TargetSelector.DamageType.Magical);
                //if (target2.IsValidTarget())
                //    Game.PrintChat(Champion.Q.GetPrediction(target2).CollisionObjects.Count.ToString());



                if (GlobalManager.Config.Item("chase").GetValue <KeyBind>().Active)
                {
                    switch (Champion.R.Level)
                    {
                    case 1:
                        rRange = 1500;
                        break;

                    case 2:
                        rRange = 3000;
                        break;
                    }
                    GlobalManager.GetHero.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                    var targets = TargetSelector.GetTarget(rRange, TargetSelector.DamageType.Magical);
                    if (!targets.IsValidTarget())
                    {
                        return;
                    }

                    if (GlobalManager.Config.Item("usewchase").GetValue <bool>() && targets.IsValidTarget(Champion.E.Range))
                    {
                        LaneOptions.CastW(targets);
                    }

                    var target1 = TargetSelector.GetSelectedTarget();
                    if (!target1.IsValidTarget(rRange))
                    {
                        return;
                    }
                    if (GlobalManager.Config.Item("chaser").GetValue <bool>() &&
                        target1.Distance(GlobalManager.GetHero) > Champion.W.Range + 200 &&
                        targets.Distance(GlobalManager.GetHero) < rRange &&
                        Champion.R.IsReady())
                    {
                        Champion.R.Cast(GlobalManager.GetHero.Position.Extend(target1.Position,
                                                                              target1.Distance(GlobalManager.GetHero.Position) + 260));
                    }
                }

                if (GlobalManager.GetHero.IsDead)
                {
                    return;
                }
                if (GlobalManager.GetHero.IsRecalling())
                {
                    return;
                }

                if (Champion.casted == false)
                {
                    MenuManager.Orbwalker.SetAttack(true);
                }

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


                if (GlobalManager.Config.Item("doHuman").GetValue <bool>())
                {
                    if (!Humanizer.CheckDelay("generalDelay")) // Wait for delay for all other events
                    {
                        return;
                    }
                    //Console.WriteLine("Seeding Human Delay");
                    var nDelay = Seeder.Next(GlobalManager.Config.Item("minDelay").GetValue <Slider>().Value, GlobalManager.Config.Item("maxDelay").GetValue <Slider>().Value); // set a new random delay :D
                    Humanizer.ChangeDelay("generalDelay", nDelay);
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
                {
                    var expires = (GlobalManager.GetHero.Spellbook.GetSpell(SpellSlot.Q).CooldownExpires);
                    var CD      =
                        (int)
                        (expires -
                         (Game.Time - 1));
                    if (Champion.W.IsReady() && !(CD < 2.5f))
                    {
                        MenuManager.Orbwalker.SetAttack(true);
                    }
                    else
                    {
                        MenuManager.Orbwalker.SetAttack(false);
                    }

                    Champion.AABlock();
                    LaneOptions.Combo();

                    MenuManager.Orbwalker.SetAttack(!(target.Distance(GlobalManager.GetHero) >=
                                                      GlobalManager.Config.Item("minaarange").GetValue <Slider>().Value));
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed)
                {
                    LaneOptions.Mixed();
                    MenuManager.Orbwalker.SetAttack(true);
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
                {
                    LaneOptions.JungleClear();
                    LaneOptions.LaneClear();
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
                {
                    LaneOptions.LastHit();
                }


                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.None)
                {
                    if (GlobalManager.Config.Item("tearS").GetValue <KeyBind>().Active)
                    {
                        ItemManager.TearStack();
                    }

                    ItemManager.Potion();
                    MenuManager.Orbwalker.SetAttack(true);
                }

                if (GlobalManager.Config.Item("UseQauto").GetValue <bool>() && target != null)
                {
                    if (Champion.Q.IsReady() && target.IsValidTarget(Champion.Q.Range))
                    {
                        Champion.Q.Cast(target);
                    }
                }


                // Seplane();
                ItemManager.Item();
                Champion.KillSteal();
                ItemManager.Potion();

                if (GlobalManager.Config.Item("level").GetValue <bool>())
                {
                    AutoLevelManager.LevelUpSpells();
                }

                if (!GlobalManager.Config.Item("autow").GetValue <bool>() || !target.UnderTurret(true))
                {
                    return;
                }

                if (target == null)
                {
                    return;
                }

                if (!ObjectManager.Get <Obj_AI_Turret>()
                    .Any(turret => turret.IsValidTarget(300) && turret.IsAlly && turret.Health > 0))
                {
                    return;
                }

                Champion.W.CastOnUnit(target);
                // DebugClass.ShowDebugInfo(true);
            }
            catch
            {
                // ignored
            }
        }
示例#3
0
        private static void Game_OnUpdate(EventArgs args)
        {
            try // lazy
            {
                if (getKeyBindItem(MenuManager._config, "test"))
                {
                    EloBuddy.Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                    var targets = TargetSelector.GetTarget(Champion.W.Range, DamageType.Magical);
                    if (targets == null)
                    {
                        return;
                    }
                    if (Champion.W.IsReady())
                    {
                        LaneOptions.CastW(targets);
                        {
                            _lastw = Environment.TickCount;
                        }
                    }

                    if (Environment.TickCount - _lastw >= 700 - Game.Ping)
                    {
                        if (Champion.Q.IsReady())
                        {
                            LaneOptions.CastQn(targets);
                            _casted = true;
                        }
                    }

                    if (_casted)
                    {
                        LaneOptions.CastE(targets);
                        LaneOptions.CastQn(targets);
                        _casted = false;
                    }
                }

                if (getKeyBindItem(MenuManager.chase, "chase"))
                {
                    EloBuddy.Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                    var targets = TargetSelector.GetTarget(Champion.W.Range + 200, DamageType.Magical);
                    if (targets == null)
                    {
                        return;
                    }

                    if (getCheckBoxItem(MenuManager.chase, "usewchase"))
                    {
                        LaneOptions.CastW(targets);
                    }

                    if (getCheckBoxItem(MenuManager.chase, "chaser") &&
                        targets.LSDistance(GlobalManager.GetHero) > Champion.W.Range + 200)
                    {
                        Champion.R.Cast();
                    }
                }

                if (GlobalManager.GetHero.IsDead)
                {
                    return;
                }

                if (GlobalManager.GetHero.IsRecalling())
                {
                    return;
                }

                Orbwalker.DisableAttacking = false;

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

                if (getCheckBoxItem(MenuManager.humanizerMenu, "doHuman"))
                {
                    if (!Humanizer.CheckDelay("generalDelay")) // Wait for delay for all other events
                    {
                        return;
                    }
                    //Console.WriteLine("Seeding Human Delay");
                    var nDelay = Seeder.Next(getSliderItem(MenuManager.humanizerMenu, "minDelay"), (getSliderItem(MenuManager.humanizerMenu, "maxDelay"))); // set a new random delay :D
                    Humanizer.ChangeDelay("generalDelay", nDelay);
                }

                if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
                {
                    var expires = (GlobalManager.GetHero.Spellbook.GetSpell(SpellSlot.Q).CooldownExpires);
                    var CD      =
                        (int)
                        (expires -
                         (Game.Time - 1));
                    if (Champion.W.IsReady() && !(CD < 2.5f))
                    {
                        //MenuManager.Orbwalker.SetAttack(true);
                        Orbwalker.DisableAttacking = false;
                    }
                    else
                    {
                        //MenuManager.Orbwalker.SetAttack(false);
                        Orbwalker.DisableAttacking = true;
                    }

                    Champion.AABlock();
                    LaneOptions.ImprovedCombo();

                    Orbwalker.DisableAttacking = ((target.LSDistance(GlobalManager.GetHero) >= getSliderItem(MenuManager.combo1Menu, "minaarange")));
                }

                if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
                {
                    LaneOptions.Mixed();
                    //MenuManager.Orbwalker.SetAttack(true);
                    Orbwalker.DisableAttacking = false;
                }

                if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
                {
                    LaneOptions.JungleClear();
                    if (getKeyBindItem(MenuManager.laneMenu, "disablelane"))
                    {
                        LaneOptions.LaneClear();
                    }
                }

                if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit))
                {
                    LaneOptions.LastHit();
                }


                if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.None))
                {
                    if (getKeyBindItem(MenuManager.itemMenu, "tearS"))
                    {
                        ItemManager.TearStack();
                    }

                    if (getKeyBindItem(MenuManager.passiveMenu, "autoPassive"))
                    {
                        Champion.AutoPassive();
                    }

                    ItemManager.Potion();
                    //MenuManager.Orbwalker.SetAttack(true);
                    Orbwalker.DisableAttacking = false;
                }

                if (getCheckBoxItem(MenuManager.mixedMenu, "UseQauto") && target != null)
                {
                    if (Champion.Q.IsReady() && target.IsValidTarget(Champion.Q.Range))
                    {
                        Champion.Q.Cast(target);
                    }
                }


                // Seplane();
                ItemManager.Item();
                Champion.KillSteal();
                ItemManager.Potion();

                if (getCheckBoxItem(MenuManager.eventMenu, "level"))
                {
                    AutoLevelManager.LevelUpSpells();
                }

                if (!getCheckBoxItem(MenuManager.eventMenu, "autow") || !target.UnderTurret(true))
                {
                    return;
                }

                if (target == null)
                {
                    return;
                }

                if (!ObjectManager.Get <Obj_AI_Turret>()
                    .Any(turret => turret.LSIsValidTarget(300) && turret.IsAlly && turret.Health > 0))
                {
                    return;
                }

                Champion.W.CastOnUnit(target);
                // DebugClass.ShowDebugInfo(true);
            }
            catch
            {
                // ignored
            }
        }
示例#4
0
        private static void Game_OnUpdate(EventArgs args)
        {
            try // lazy
            {
                //    var data = GetHero.Buffs.FirstOrDefault(b => b.DisplayName == "RyzePassiveStack");
                //foreach (var buffs in GlobalManager.GetHero.Buffs)
                //{
                //    Game.PrintChat(buffs.Name);
                //}
                //  Game.PrintChat(GlobalManager.GetPassiveBuff.ToString());


                if (GlobalManager.Config.Item("test").GetValue <KeyBind>().Active)
                {
                    GlobalManager.GetHero.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                    var targets = TargetSelector.GetTarget(Champion.W.Range, TargetSelector.DamageType.Magical);
                    if (targets == null)
                    {
                        return;
                    }
                    if (Champion.W.IsReady())
                    {
                        LaneOptions.CastW(targets);
                        {
                            _lastw = Environment.TickCount;
                        }
                    }

                    if (Environment.TickCount - _lastw >= 700 - Game.Ping)
                    {
                        if (Champion.Q.IsReady())
                        {
                            LaneOptions.CastQn(targets);
                            _casted = true;
                        }
                    }

                    if (_casted)
                    {
                        LaneOptions.CastE(targets);
                        LaneOptions.CastQn(targets);
                        _casted = false;
                    }
                }

                if (GlobalManager.Config.Item("chase").GetValue <KeyBind>().Active)
                {
                    GlobalManager.GetHero.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                    var targets = TargetSelector.GetTarget(Champion.W.Range + 200, TargetSelector.DamageType.Magical);
                    if (targets == null)
                    {
                        return;
                    }

                    if (GlobalManager.Config.Item("usewchase").GetValue <bool>())
                    {
                        LaneOptions.CastW(targets);
                    }

                    if (GlobalManager.Config.Item("chaser").GetValue <bool>() &&
                        targets.Distance(GlobalManager.GetHero) > Champion.W.Range + 200)
                    {
                        Champion.R.Cast();
                    }
                }

                if (GlobalManager.GetHero.IsDead)
                {
                    return;
                }
                if (GlobalManager.GetHero.IsRecalling())
                {
                    return;
                }

                if (Champion.casted == false)
                {
                    MenuManager.Orbwalker.SetAttack(true);
                }

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

                if (GlobalManager.Config.Item("doHuman").GetValue <bool>())
                {
                    if (!Humanizer.CheckDelay("generalDelay")) // Wait for delay for all other events
                    {
                        return;
                    }
                    //Console.WriteLine("Seeding Human Delay");
                    var nDelay = Seeder.Next(GlobalManager.Config.Item("minDelay").GetValue <Slider>().Value, GlobalManager.Config.Item("maxDelay").GetValue <Slider>().Value); // set a new random delay :D
                    Humanizer.ChangeDelay("generalDelay", nDelay);
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
                {
                    var expires = (GlobalManager.GetHero.Spellbook.GetSpell(SpellSlot.Q).CooldownExpires);
                    var CD      =
                        (int)
                        (expires -
                         (Game.Time - 1));
                    if (Champion.W.IsReady() && !(CD < 2.5f))
                    {
                        MenuManager.Orbwalker.SetAttack(true);
                    }
                    else
                    {
                        MenuManager.Orbwalker.SetAttack(false);
                    }

                    Champion.AABlock();
                    LaneOptions.ImprovedCombo();

                    MenuManager.Orbwalker.SetAttack(!(target.Distance(GlobalManager.GetHero) >=
                                                      GlobalManager.Config.Item("minaarange").GetValue <Slider>().Value));
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed)
                {
                    LaneOptions.Mixed();
                    MenuManager.Orbwalker.SetAttack(true);
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
                {
                    LaneOptions.JungleClear();
                    if (GlobalManager.Config.Item("disablelane").GetValue <KeyBind>().Active)
                    {
                        LaneOptions.LaneClear();
                    }
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
                {
                    LaneOptions.LastHit();
                }


                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.None)
                {
                    if (GlobalManager.Config.Item("tearS").GetValue <KeyBind>().Active)
                    {
                        ItemManager.TearStack();
                    }

                    if (GlobalManager.Config.Item("autoPassive").GetValue <KeyBind>().Active)
                    {
                        Champion.AutoPassive();
                    }

                    ItemManager.Potion();
                    MenuManager.Orbwalker.SetAttack(true);
                }

                if (GlobalManager.Config.Item("UseQauto").GetValue <bool>() && target != null)
                {
                    if (Champion.Q.IsReady() && target.IsValidTarget(Champion.Q.Range))
                    {
                        Champion.Q.Cast(target);
                    }
                }


                // Seplane();
                ItemManager.Item();
                Champion.KillSteal();
                ItemManager.Potion();

                if (GlobalManager.Config.Item("level").GetValue <bool>())
                {
                    AutoLevelManager.LevelUpSpells();
                }

                if (!GlobalManager.Config.Item("autow").GetValue <bool>() || !target.UnderTurret(true))
                {
                    return;
                }

                if (target == null)
                {
                    return;
                }

                if (!ObjectManager.Get <Obj_AI_Turret>()
                    .Any(turret => turret.IsValidTarget(300) && turret.IsAlly && turret.Health > 0))
                {
                    return;
                }

                Champion.W.CastOnUnit(target);
                // DebugClass.ShowDebugInfo(true);
            }
            catch
            {
                // ignored
            }
        }
示例#5
0
        private static void Game_OnUpdate(EventArgs args)
        {
            try // lazy
            {
                if (GlobalManager.Config.Item("test").GetValue <KeyBind>().Active)
                {
                    GlobalManager.GetHero.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                    var targets = TargetSelector.GetTarget(Champion.W.Range, TargetSelector.DamageType.Magical);
                    if (targets == null)
                    {
                        return;
                    }
                    if (Champion.W.IsReady())
                    {
                        LaneOptions.CastW(targets);
                        {
                            _lastw = Environment.TickCount;
                        }
                    }

                    if (Environment.TickCount - _lastw >= 700 - Game.Ping)
                    {
                        if (Champion.Q.IsReady())
                        {
                            LaneOptions.CastQn(targets);
                            _casted = true;
                        }
                    }

                    if (_casted)
                    {
                        LaneOptions.CastE(targets);
                        LaneOptions.CastQn(targets);
                        _casted = false;
                    }
                }

                if (GlobalManager.GetHero.IsDead)
                {
                    return;
                }
                if (GlobalManager.GetHero.IsRecalling())
                {
                    return;
                }

                if (Champion.casted == false)
                {
                    MenuManager.Orbwalker.SetAttack(true);
                }

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

                if (GlobalManager.Config.Item("doHuman").GetValue <bool>())
                {
                    if (!Humanizer.CheckDelay("generalDelay")) // Wait for delay for all other events
                    {
                        Console.WriteLine(@"Waiting on Human delay");
                        return;
                    }
                    //Console.WriteLine("Seeding Human Delay");
                    var nDelay = Seeder.Next(GlobalManager.Config.Item("minDelay").GetValue <Slider>().Value, GlobalManager.Config.Item("maxDelay").GetValue <Slider>().Value); // set a new random delay :D
                    Humanizer.ChangeDelay("generalDelay", nDelay);
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
                {
                    if (target.IsValidTarget() &&
                        GlobalManager.GetHero.Distance(target) > 400 && (Champion.Q.IsReady() && Champion.W.IsReady() && Champion.E.IsReady()))
                    {
                        MenuManager.Orbwalker.SetAttack(false);
                    }

                    if (target.IsValidTarget() && GlobalManager.GetHero.Distance(target) > 400 &&
                        (GlobalManager.GetPassiveBuff == 4 || GlobalManager.GetHero.HasBuff("ryzepassivecharged"))
                        &&
                        ((!Champion.Q.IsReady() && !Champion.W.IsReady() && !Champion.E.IsReady()) ||
                         (Champion.Q.IsReady() && Champion.W.IsReady() && Champion.E.IsReady())))
                    {
                        MenuManager.Orbwalker.SetAttack(false);
                    }

                    Champion.AABlock();
                    LaneOptions.ImprovedCombo();
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed)
                {
                    LaneOptions.Mixed();
                    MenuManager.Orbwalker.SetAttack(true);
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
                {
                    if (!GlobalManager.Config.Item("disablelane").GetValue <KeyBind>().Active)
                    {
                        LaneOptions.LaneClear();
                    }

                    LaneOptions.JungleClear();
                }

                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
                {
                    LaneOptions.LastHit();
                }


                if (MenuManager.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.None)
                {
                    if (GlobalManager.Config.Item("tearS").GetValue <KeyBind>().Active)
                    {
                        ItemManager.TearStack();
                    }

                    if (GlobalManager.Config.Item("autoPassive").GetValue <KeyBind>().Active)
                    {
                        Champion.AutoPassive();
                    }

                    ItemManager.Potion();
                    MenuManager.Orbwalker.SetAttack(true);
                }

                if (GlobalManager.Config.Item("UseQauto").GetValue <bool>() && target != null)
                {
                    if (Champion.Q.IsReady() && target.IsValidTarget(Champion.Q.Range))
                    {
                        Champion.Q.Cast(target);
                    }
                }


                // Seplane();
                ItemManager.Item();
                Champion.KillSteal();
                ItemManager.Potion();

                if (GlobalManager.Config.Item("level").GetValue <bool>())
                {
                    AutoLevelManager.LevelUpSpells();
                }

                if (!GlobalManager.Config.Item("autow").GetValue <bool>() || !target.UnderTurret(true))
                {
                    return;
                }

                if (target == null)
                {
                    return;
                }

                if (!ObjectManager.Get <Obj_AI_Turret>()
                    .Any(turret => turret.IsValidTarget(300) && turret.IsAlly && turret.Health > 0))
                {
                    return;
                }

                Champion.W.CastOnUnit(target);
                // DebugClass.ShowDebugInfo(true);
            }
            catch
            {
                // ignored
            }
        }
示例#6
0
        private static void Game_OnUpdate(EventArgs args)
        {
            try // lazy
            {
                if (getKeyBindItem(_config, "test"))
                {
                    Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                    var targets = TargetSelector.GetTarget(Champion.W.Range, DamageType.Magical);
                    if (targets == null)
                    {
                        return;
                    }
                    if (Champion.W.IsReady())
                    {
                        LaneOptions.CastW(targets);
                        {
                            _lastw = Environment.TickCount;
                        }
                    }

                    if (Environment.TickCount - _lastw >= 700 - Game.Ping)
                    {
                        if (Champion.Q.IsReady())
                        {
                            LaneOptions.CastQn(targets);
                            _casted = true;
                        }
                    }

                    if (_casted)
                    {
                        LaneOptions.CastE(targets);
                        LaneOptions.CastQn(targets);
                        _casted = false;
                    }
                }

                if (getKeyBindItem(chase, "chase"))
                {
                    Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                    var targets = TargetSelector.GetTarget(Champion.W.Range + 200, DamageType.Magical);
                    if (targets == null)
                    {
                        return;
                    }

                    if (getCheckBoxItem(chase, "usewchase"))
                    {
                        LaneOptions.CastW(targets);
                    }

                    if (getCheckBoxItem(chase, "chaser") &&
                        targets.Distance(GlobalManager.GetHero) > Champion.W.Range + 200)
                    {
                        Champion.R.Cast();
                    }
                }

                if (GlobalManager.GetHero.IsDead)
                {
                    return;
                }

                if (GlobalManager.GetHero.IsRecalling())
                {
                    return;
                }

                if (Champion.casted == false)
                {
                    Orbwalker.DisableAttacking = false;
                }

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

                if (getCheckBoxItem(humanizerMenu, "doHuman"))
                {
                    if (!Humanizer.CheckDelay("generalDelay")) // Wait for delay for all other events
                    {
                        return;
                    }
                    var nDelay = Seeder.Next(getSliderItem(humanizerMenu, "minDelay"),
                                             getSliderItem(humanizerMenu, "maxDelay")); // set a new random delay :D
                    Humanizer.ChangeDelay("generalDelay", nDelay);
                }

                if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
                {
                    var expires = GlobalManager.GetHero.Spellbook.GetSpell(SpellSlot.Q).CooldownExpires;

                    LaneOptions.COMBO();
                }

                if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
                {
                    LaneOptions.Mixed();
                    Orbwalker.DisableAttacking = false;
                }

                if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) ||
                    Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
                {
                    LaneOptions.JungleClear();
                    if (getKeyBindItem(laneMenu, "disablelane"))
                    {
                        Console.WriteLine("1");
                        if (GlobalManager.GetPassiveBuff == 4 && !GlobalManager.GetHero.HasBuff("RyzeR") &&
                            getCheckBoxItem(laneMenu, "passiveproc"))
                        {
                            Console.WriteLine("2");
                            return;
                        }

                        Console.WriteLine("3");
                        var qlchSpell = getCheckBoxItem(laneMenu, "useQlc");
                        var elchSpell = getCheckBoxItem(laneMenu, "useElc");
                        var wlchSpell = getCheckBoxItem(laneMenu, "useWlc");

                        var rSpell  = getCheckBoxItem(laneMenu, "useRl");
                        var rSlider = getSliderItem(laneMenu, "rMin");
                        var minMana = getSliderItem(laneMenu, "useEPL");

                        var minionCount =
                            EntityManager.MinionsAndMonsters.GetLaneMinions()
                            .Where(x => !x.IsAlly && Champion.Q.IsInRange(x));

                        if (GlobalManager.GetHero.ManaPercent <= minMana)
                        {
                            Console.WriteLine("4");
                            return;
                        }

                        foreach (var minion in minionCount)
                        {
                            Console.WriteLine("5");
                            if (!GlobalManager.CheckMinion(minion))
                            {
                                continue;
                            }

                            Console.WriteLine("123123123");

                            var minionHp = minion.Health;

                            SpellSequence(minion, "useQ2L", "useE2L", "useW2L", "useRl");

                            if (qlchSpell && Champion.Q.IsReady() && minion.IsValidTarget(Champion.Q.Range) &&
                                minionHp <= Champion.Q.GetDamage(minion) && GlobalManager.CheckMinion(minion))
                            {
                                Champion.Q.Cast(minion);
                            }

                            else if (wlchSpell && Champion.W.IsReady() && minion.IsValidTarget(Champion.W.Range) &&
                                     minionHp <= Champion.W.GetDamage(minion) && GlobalManager.CheckMinion(minion))
                            {
                                Champion.W.CastOnUnit(minion);
                            }

                            else if (elchSpell && Champion.E.IsReady() && minion.IsValidTarget(Champion.E.Range) &&
                                     minionHp <= Champion.E.GetDamage(minion) && GlobalManager.CheckMinion(minion))
                            {
                                Champion.E.CastOnUnit(minion);
                            }

                            if (rSpell && Champion.R.IsReady() && minion.IsValidTarget(Champion.Q.Range) &&
                                minionCount.Count() > rSlider && GlobalManager.CheckMinion(minion))
                            {
                                Champion.R.Cast();
                            }
                        }
                    }
                }

                if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit))
                {
                    LaneOptions.LastHit();
                }


                if (getKeyBindItem(itemMenu, "tearS"))
                {
                    ItemManager.TearStack();
                }

                if (getKeyBindItem(passiveMenu, "autoPassive"))
                {
                    var minions = MinionManager.GetMinions(GlobalManager.GetHero.ServerPosition, Champion.Q.Range,
                                                           MinionTypes.All, MinionTeam.Enemy, MinionOrderTypes.MaxHealth);
                    if (ObjectManager.Player.ManaPercent < getSliderItem(passiveMenu, "ManapSlider"))
                    {
                        return;
                    }
                    if (ObjectManager.Player.IsRecalling())
                    {
                        return;
                    }
                    if (minions.Count >= 1)
                    {
                        return;
                    }
                    var stackSliders = getSliderItem(passiveMenu, "stackSlider");
                    if (ObjectManager.Player.InFountain())
                    {
                        return;
                    }

                    if (GlobalManager.GetPassiveBuff >= stackSliders)
                    {
                        return;
                    }

                    if (Utils.TickCount - Champion.Q.LastCastAttemptT >=
                        getSliderItem(passiveMenu, "autoPassiveTimer") * 1000 - (100 + Game.Ping / 2) &&
                        Champion.Q.IsReady())
                    {
                        if (!Game.CursorPos.IsZero)
                        {
                            Champion.Q.Cast(Game.CursorPos);
                        }
                    }
                }

                Orbwalker.DisableAttacking = false;

                if (getCheckBoxItem(mixedMenu, "UseQauto") && target != null)
                {
                    if (Champion.Q.IsReady() && target.IsValidTarget(Champion.Q.Range))
                    {
                        Champion.Q.Cast(target);
                    }
                }

                Champion.KillSteal();
            }
            catch
            {
                // ignored
            }
        }