Exemple #1
0
        protected override void Combo()
        {
            var useQ = Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady();
            var useW = Menu.Item(Menu.Name + ".combo.w").GetValue <bool>() && W.IsReady();
            var useE = Menu.Item(Menu.Name + ".combo.e").GetValue <bool>() && E.IsReady();
            var useR = _ultimate.IsActive(UltimateModeType.Combo) && R.IsReady();

            if (useR)
            {
                var target = TargetSelector.GetTarget(R.Range, R.DamageType);
                if (target != null)
                {
                    if (!RLogic(UltimateModeType.Combo, target))
                    {
                        RLogicSingle(UltimateModeType.Combo);
                    }
                }
            }
            if (useE)
            {
                var target = TargetSelector.GetTarget((E.Range + Player.AttackRange) * 0.9f, E.DamageType);
                if (target != null)
                {
                    var pos = Menu.Item(Menu.Name + ".combo.e-mode").GetValue <StringList>().SelectedIndex == 0
                        ? Utils.GetDashPosition(
                        E, target, Menu.Item(Menu.Name + ".combo.e-safety").GetValue <Slider>().Value)
                        : Player.Position.Extend(
                        Game.CursorPos, Math.Min(E.Range, Player.Position.Distance(Game.CursorPos)));
                    if (!pos.Equals(Vector3.Zero) && !pos.IsUnderTurret(false))
                    {
                        E.Cast(pos);
                    }
                }
            }
            if (useQ)
            {
                Casting.SkillShot(Q, Q.GetHitChance("combo"));
            }
            if (useW)
            {
                var target = TargetSelector.GetTarget(W);
                var best   = CPrediction.Circle(W, target, W.GetHitChance("combo"));
                if (best.TotalHits > 0 && !best.CastPosition.Equals(Vector3.Zero))
                {
                    W.Cast(best.CastPosition);
                }
            }
        }
        private void SetupMenu()
        {
            try
            {
                SFXMenu = new Menu(Global.Name, "sfx", true);

                Menu = new Menu(Global.Prefix + Player.ChampionName, SFXMenu.Name + "." + Player.ChampionName, true);

                DrawingManager.AddToMenu(Menu.AddSubMenu(new Menu("Drawings", Menu.Name + ".drawing")), this);

                TargetSelector.AddToMenu(SFXMenu.AddSubMenu(new Menu("Target Selector", SFXMenu.Name + ".ts")));

                Orbwalker = new Orbwalking.Orbwalker(SFXMenu.AddSubMenu(new Menu("Orbwalker", SFXMenu.Name + ".orb")));

                KillstealManager.AddToMenu(SFXMenu.AddSubMenu(new Menu("Killsteal", SFXMenu.Name + ".killsteal")));

                var itemMenu = SFXMenu.AddSubMenu(new Menu("Items", SFXMenu.Name + ".items"));
                TearStackManager.AddToMenu(
                    itemMenu.AddSubMenu(new Menu("Tear Stacking", SFXMenu.Name + ".tear-stack." + Player.ChampionName)),
                    Spells);
                ItemManager.AddToMenu(itemMenu, ItemFlags);
                SummonerManager.AddToMenu(SFXMenu.AddSubMenu(new Menu("Summoners", SFXMenu.Name + ".summoners")));

                InfoMenu.AddToMenu(SFXMenu.AddSubMenu(new Menu("Info", SFXMenu.Name + ".info")));
                DebugMenu.AddToMenu(SFXMenu, Spells);

                Menu.AddToMainMenu();
                SFXMenu.AddToMainMenu();

                try
                {
                    AddToMenu();
                }
                catch (Exception ex)
                {
                    Global.Logger.AddItem(new LogItem(ex));
                }
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
        }
 public static bool Check(string uniqueId, Spell spell, Obj_AI_Hero hero)
 {
     try
     {
         if (hero == null || !Enabled(uniqueId))
         {
             return(true);
         }
         var bestTarget = TargetSelector.GetTarget(spell);
         if (bestTarget == null || hero.NetworkId.Equals(bestTarget.NetworkId))
         {
             return(true);
         }
     }
     catch (Exception ex)
     {
         Global.Logger.AddItem(new LogItem(ex));
     }
     return(false);
 }
        private void QLogic(HitChance hitChance)
        {
            var target = TargetSelector.GetTarget(Q);

            if (target != null)
            {
                var prediction = CPrediction.Line(Q, target, hitChance, false);
                if (prediction.TotalHits >= 1)
                {
                    var firstHit = prediction.Hits.OrderBy(h => h.Distance(Player)).FirstOrDefault();
                    if (firstHit != null && !Utils.IsWallBetween(Player.Position, firstHit.Position))
                    {
                        if (!GameObjects.EnemyHeroes.Any(e => e.IsValidTarget() && Orbwalking.InAutoAttackRange(e)) ||
                            IsReloading() || Q.IsKillable(target) || prediction.TotalHits >= 2)
                        {
                            Q.Cast(prediction.CastPosition);
                        }
                    }
                }
            }
        }
 protected void ItemsSummonersLogic(Obj_AI_Hero ultimateTarget, bool single = true)
 {
     try
     {
         var range = Math.Max(
             600,
             Math.Max(
                 SummonerManager.SummonerSpells.Where(s => s.CastType == CastType.Target).Max(s => s.Range),
                 ItemManager.Items.Where(
                     i => i.EffectFlags.HasFlag(EffectFlags.Damage) && i.Flags.HasFlag(ItemFlags.Offensive))
                 .Max(i => i.Range)));
         if (ultimateTarget == null || Ultimate == null || !ultimateTarget.IsValidTarget(range))
         {
             var target = TargetSelector.GetTarget(range);
             if (target != null)
             {
                 if (ItemManager.CalculateComboDamage(target) + SummonerManager.CalculateComboDamage(target) >
                     target.Health)
                 {
                     ItemManager.UseComboItems(target);
                     SummonerManager.UseComboSummoners(target);
                 }
             }
         }
         else
         {
             if (Ultimate.GetDamage(ultimateTarget, UltimateModeType.Combo, single ? 1 : 5) >
                 ultimateTarget.Health)
             {
                 ItemManager.UseComboItems(ultimateTarget);
                 SummonerManager.UseComboSummoners(ultimateTarget);
             }
         }
     }
     catch (Exception ex)
     {
         Global.Logger.AddItem(new LogItem(ex));
     }
 }
        protected override void OnPostUpdate()
        {
            if (Ultimate.IsActive(UltimateModeType.Assisted) && R.IsReady())
            {
                if (Ultimate.ShouldMove(UltimateModeType.Assisted))
                {
                    Orbwalking.MoveTo(Game.CursorPos, Orbwalker.HoldAreaRadius);
                }

                if (!RLogic(UltimateModeType.Assisted, TargetSelector.GetTarget(R)))
                {
                    RLogicSingle(UltimateModeType.Assisted);
                }
            }

            if (Ultimate.IsActive(UltimateModeType.Auto) && R.IsReady())
            {
                if (!RLogic(UltimateModeType.Auto, TargetSelector.GetTarget(R)))
                {
                    RLogicSingle(UltimateModeType.Auto);
                }
            }
        }
 public static void TargetSkill(Spell spell)
 {
     TargetSkill(TargetSelector.GetTarget(spell), spell);
 }
 public static void SkillShot(Spell spell, HitChance hitChance, bool boundingRadius = true, bool maxRange = true)
 {
     SkillShot(TargetSelector.GetTarget(spell), spell, hitChance);
 }
        protected override void Combo()
        {
            var useQ = Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady();
            var useW = Menu.Item(Menu.Name + ".combo.w").GetValue <bool>() && W.IsReady();
            var useE = Menu.Item(Menu.Name + ".combo.e").GetValue <bool>() && E.IsReady();
            var useR = Ultimate.IsActive(UltimateModeType.Combo) && R.IsReady();

            if (useR)
            {
                var target = TargetSelector.GetTarget(R.Range, R.DamageType);
                if (target != null)
                {
                    if (!RLogic(UltimateModeType.Combo, target))
                    {
                        RLogicSingle(UltimateModeType.Combo);
                    }
                }
            }
            if (useE && !Player.IsWindingUp && !IsReloading())
            {
                var target = TargetSelector.GetTarget(
                    E.Range + Player.AttackRange + Player.BoundingRadius, E.DamageType);
                if (target != null)
                {
                    var pos = Menu.Item(Menu.Name + ".combo.e-mode").GetValue <StringList>().SelectedIndex == 0
                        ? Utils.GetDashPosition(
                        E, target, Menu.Item(Menu.Name + ".combo.e-safety").GetValue <Slider>().Value)
                        : Player.Position.Extend(
                        Game.CursorPos, Math.Min(E.Range, Player.Position.Distance(Game.CursorPos)));

                    if (!pos.Equals(Vector3.Zero))
                    {
                        if (GetAmmoCount() == 1 && !pos.IsUnderTurret(false) ||
                            (!GameObjects.EnemyHeroes.Any(e => e.IsValidTarget() && Orbwalking.InAutoAttackRange(e)) &&
                             GameObjects.EnemyHeroes.Any(
                                 e =>
                                 e.IsValidTarget() &&
                                 pos.Distance(e.Position) < Orbwalking.GetRealAutoAttackRange(e)) &&
                             target.Health < Player.GetAutoAttackDamage(target) * 2))
                        {
                            E.Cast(pos);
                        }
                    }
                }
            }
            if (useQ)
            {
                QLogic(Q.GetHitChance("combo"));
            }
            if (useW)
            {
                var target = TargetSelector.GetTarget(W);
                if (target != null)
                {
                    var best = CPrediction.Circle(W, target, W.GetHitChance("combo"));
                    if (best.TotalHits > 0 && !best.CastPosition.Equals(Vector3.Zero))
                    {
                        W.Cast(best.CastPosition);
                    }
                }
            }
        }