示例#1
0
        private static void CastEtarget(AIHeroClient target)
        {
            var ePred = Prediction.GetPrediction(target, 1);
            var pos   = target.Position.Extend(ePred.CastPosition, BarrelExplosionRange);

            if (pos.LSDistance(ePos) > 400 && !justE)
            {
                E.Cast(pos, getCheckBoxItem(config, "packets"));
            }
        }
示例#2
0
        private static void AfterAttack(AttackableUnit targetA, EventArgs args)
        {
            var targetO = targetA;

            if (!(targetO is AIHeroClient))
            {
                return;
            }

            var targ             = (AIHeroClient)targetO;
            var passivePositions = GetPassivePositions(targetO);
            var rapid            = player.GetAutoAttackDamage(targ) * 3 + ComboDamage(targ) > targ.Health ||
                                   (player.Health < targ.Health && player.Health < player.MaxHealth / 2);

            if (E.IsReady() && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) &&
                (getCheckBoxItem(comboMenu, "usee") || getKeyBindItem(comboMenu, "RapidAttack") || rapid) &&
                !Orbwalker.CanAutoAttack)
            {
                E.Cast(getCheckBoxItem(config, "packets"));
            }
            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && Q.IsReady() &&
                (getKeyBindItem(comboMenu, "RapidAttack") || rapid) && !Orbwalker.CanAutoAttack &&
                passivePositions.Any())
            {
                var passive = GetClosestPassivePosition(targ);
                var pos     = GetQpoint(targ, passive);
                if (pos.IsValid())
                {
                    Q.Cast(pos, getCheckBoxItem(config, "packets"));
                }
                else
                {
                    var pos2 = GetQpoint(targ, Prediction.GetPrediction(targ, 2).UnitPosition);
                    if (pos2.IsValid())
                    {
                        Q.Cast(pos2, getCheckBoxItem(config, "packets"));
                    }
                }
            }
            //var pos = GetClosestPassivePosition(targetO);
            var target = TargetSelector.GetTarget(W.Range, DamageType.Physical);

            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && targetO.NetworkId == target.NetworkId &&
                R.IsReady() && R.CanCast(target) &&
                HealthPrediction.GetHealthPrediction(target, 1000) > player.GetAutoAttackDamage(target) &&
                ComboDamage(target) + player.GetAutoAttackDamage(target) * 5 > target.Health &&
                ((getSliderItem(comboMenu, "userally") <=
                  HeroManager.Allies.Count(
                      a => a.IsValid && !a.IsDead && a.LSDistance(target) < 600 && a.HealthPercent < 90) &&
                  getCheckBoxItem(comboMenu, "usertf")) ||
                 (player.HealthPercent < 75 && getCheckBoxItem(comboMenu, "user"))))
            {
                R.CastOnUnit(target, getCheckBoxItem(config, "packets"));
            }
        }
示例#3
0
        private void moveClone()
        {
            var Gtarget = TargetSelector.GetTarget(2200, DamageType.Physical);

            switch (getBoxItem(menuM, "ghostTarget"))
            {
            case 0:
                Gtarget = TargetSelector.GetTarget(GhostRange, DamageType.Physical);
                break;

            case 1:
                Gtarget =
                    ObjectManager.Get <AIHeroClient>()
                    .Where(i => i.IsEnemy && !i.IsDead && player.LSDistance(i) <= GhostRange)
                    .OrderBy(i => i.Health)
                    .FirstOrDefault();
                break;

            case 2:
                Gtarget =
                    ObjectManager.Get <AIHeroClient>()
                    .Where(i => i.IsEnemy && !i.IsDead && player.LSDistance(i) <= GhostRange)
                    .OrderBy(i => player.LSDistance(i))
                    .FirstOrDefault();
                break;

            default:
                break;
            }
            var clone = ObjectManager.Get <Obj_AI_Minion>().FirstOrDefault(m => m.Name == player.Name && !m.IsMe);

            if (clone != null && Gtarget != null && Gtarget.IsValid)
            {
                if (clone.CanMove)
                {
                    Player.IssueOrder(GameObjectOrder.MovePet, Gtarget);
                }

                if (clone.LSDistance(Gtarget) < 130 && (CanCloneAttack(clone) || clone.CanAttack))
                {
                    Player.IssueOrder(GameObjectOrder.AutoAttackPet, Gtarget);
                }

                if (player.HealthPercent > 25)
                {
                    var prediction = Prediction.GetPrediction(Gtarget, 2);
                    R.Cast(Gtarget.Position.LSExtend(prediction.UnitPosition, Orbwalking.GetRealAutoAttackRange(Gtarget)), getCheckBoxItem(config, "packets"));
                }

                GhostDelay = true;
                Utility.DelayAction.Add(200, () => GhostDelay = false);
            }
        }
示例#4
0
        private void castQ(AIHeroClient target)
        {
            if (target == null && Q.IsCharging)
            {
                ObjectManager.Player.Spellbook.CastSpell(SpellSlot.Q);
            }
            if (Q.IsCharging)
            {
                var qTarget = TargetSelector.GetTarget(!Q.IsCharging ? Q.ChargedMaxRange / 2 : Q.ChargedMaxRange, DamageType.Physical);
                if (qTarget == null)
                {
                    return;
                }
                if (qTarget == null && Q.IsCharging)
                {
                    ObjectManager.Player.Spellbook.CastSpell(SpellSlot.Q);
                }
                var start     = ObjectManager.Player.ServerPosition.LSTo2D();
                var end       = start.LSExtend(QCastPos, Q.Range);
                var direction = (end - start).Normalized();
                var normal    = direction.Perpendicular();

                var points = new List <Vector2>();
                var hitBox = qTarget.BoundingRadius;
                points.Add(start + normal * (Q.Width + hitBox));
                points.Add(start - normal * (Q.Width + hitBox));
                points.Add(end + Q.ChargedMaxRange * direction - normal * (Q.Width + hitBox));
                points.Add(end + Q.ChargedMaxRange * direction + normal * (Q.Width + hitBox));

                for (var i = 0; i <= points.Count - 1; i++)
                {
                    var A = points[i];
                    var B = points[i == points.Count - 1 ? 0 : i + 1];

                    if (qTarget.ServerPosition.LSTo2D().LSDistance(A, B, true, true) < 50 * 50)
                    {
                        Q.Cast(qTarget, true);
                    }
                }
                checkCastedQ(target);
            }
            else if (Q.CanCast(target) && !Orbwalker.IsAutoAttacking && target != null)
            {
                var qPred  = Prediction.GetPrediction(target, 0.3f);
                var qPred2 = Prediction.GetPrediction(target, 0.6f);
                var poly   = GetPoly(qPred.UnitPosition);
                if (qPred2.Hitchance >= HitChance.High && poly.IsInside(qPred2.UnitPosition.LSTo2D()) && poly.IsInside(target.ServerPosition))
                {
                    Q.StartCharging(qPred.CastPosition);
                }
            }
        }
示例#5
0
        private static void LogicQ()
        {
            var t  = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
            var t1 = TargetSelector.GetTarget(Q1.Range, DamageType.Physical);

            if (t.IsValidTarget(Q.Range))
            {
                if (OktwCommon.GetKsDamage(t, Q) + AaDamage(t) > t.Health)
                {
                    Q.Cast(t);
                }
                else if (Program.Combo && Player.Mana > RMANA + QMANA)
                {
                    Q.Cast(t);
                }
                else if (Program.Farm && getCheckBoxItem(harassMenu, "harras" + t.ChampionName) && Player.Mana > RMANA + QMANA + EMANA + WMANA)
                {
                    Q.Cast(t);
                }
            }
            else if ((Program.Farm || Program.Combo) && getCheckBoxItem(qMenu, "harasQ") && t1.IsValidTarget(Q1.Range) && getCheckBoxItem(harassMenu, "harras" + t1.ChampionName) && Player.LSDistance(t1.ServerPosition) > Q.Range + 100)
            {
                if (Program.Combo && Player.Mana < RMANA + QMANA)
                {
                    return;
                }
                if (Program.Farm && Player.Mana < RMANA + QMANA + EMANA + WMANA)
                {
                    return;
                }
                if (!OktwCommon.CanHarras())
                {
                    return;
                }
                var prepos = Prediction.GetPrediction(t1, Q1.Delay);
                if ((int)prepos.Hitchance < 5)
                {
                    return;
                }
                var distance = Player.LSDistance(prepos.CastPosition);
                var minions  = Cache.GetMinions(Player.ServerPosition, Q.Range);

                foreach (var minion in minions.Where(minion => minion.LSIsValidTarget(Q.Range)))
                {
                    if (prepos.CastPosition.LSDistance(Player.Position.LSExtend(minion.Position, distance)) < 25)
                    {
                        Q.Cast(minion);
                        return;
                    }
                }
            }
        }
示例#6
0
        private static void CastQ(AIHeroClient target)
        {
            var distance = Vector3.Distance(BallPos, target.ServerPosition);


            if (E.IsReady() && Player.Mana > RMANA + QMANA + WMANA + EMANA &&
                distance > Player.Distance(target.ServerPosition) + 300)
            {
                E.CastOnUnit(Player);
                return;
            }

            if (Program.getSliderItem("PredictionMODE") == 1)
            {
                var predInput2 = new PredictionInput
                {
                    Aoe       = true,
                    Collision = Q.Collision,
                    Speed     = Q.Speed,
                    Delay     = Q.Delay,
                    Range     = float.MaxValue,
                    From      = BallPos,
                    Radius    = Q.Width,
                    Unit      = target,
                    Type      = SebbyLib.Prediction.SkillshotType.SkillshotCircle
                };
                var prepos5 = SebbyLib.Prediction.Prediction.GetPrediction(predInput2);

                if ((int)prepos5.Hitchance > 5 - Program.getSliderItem("HitChance"))
                {
                    if (prepos5.CastPosition.Distance(prepos5.CastPosition) < Q.Range)
                    {
                        Q.Cast(prepos5.CastPosition);
                    }
                }
            }
            else
            {
                var delay  = distance / Q.Speed + Q.Delay;
                var prepos = Prediction.GetPrediction(target, delay, Q.Width);

                if ((int)prepos.Hitchance > 5 - Program.getSliderItem("HitChance"))
                {
                    if (Q.IsInRange(target))
                    {
                        Q.Cast(target);
                    }
                }
            }
        }
示例#7
0
        public static Vector3 GetQpoint(AIHeroClient target, Vector3 passive)
        {
            var ponts     = new List <Vector3>();
            var predEnemy = Prediction.GetPrediction(target, ObjectManager.Player.Distance(target) / 1600).UnitPosition;

            for (var i = 2; i < 8; i++)
            {
                ponts.Add(predEnemy.To2D().Extend(passive.To2D(), i * 25).To3D());
            }

            return
                (ponts.Where(p => CheckQusage(p, target))
                 .OrderByDescending(p => p.Distance(target.Position))
                 .FirstOrDefault());
        }
示例#8
0
        private static void Clear()
        {
            if (ObjectManager.Player.ManaPercent < getSliderItem(clearMenu, "lucian.clear.mana"))
            {
                return;
            }
            if (LucianSpells.Q.IsReady() && getCheckBoxItem(clearMenu, "lucian.q.clear") &&
                ObjectManager.Player.Buffs.Any(buff => buff.Name != "lucianpassivebuff"))
            {
                foreach (
                    var minion in
                    MinionManager.GetMinions(ObjectManager.Player.ServerPosition, LucianSpells.Q.Range,
                                             MinionTypes.All,
                                             MinionTeam.NotAlly))
                {
                    var prediction = Prediction.GetPrediction(minion, LucianSpells.Q.Delay,
                                                              ObjectManager.Player.Spellbook.GetSpell(SpellSlot.Q).SData.CastRadius);

                    var collision = LucianSpells.Q.GetCollision(ObjectManager.Player.Position.To2D(),
                                                                new List <Vector2> {
                        prediction.UnitPosition.To2D()
                    });

                    foreach (var cs in collision)
                    {
                        if (collision.Count >= getSliderItem(clearMenu, "lucian.q.minion.hit.count"))
                        {
                            if (collision.Last().Distance(ObjectManager.Player) -
                                collision[0].Distance(ObjectManager.Player) <= 600 &&
                                collision[0].Distance(ObjectManager.Player) <= 500)
                            {
                                LucianSpells.Q.Cast(cs);
                            }
                        }
                    }
                }
            }
            if (LucianSpells.W.IsReady() && getCheckBoxItem(clearMenu, "lucian.w.clear") &&
                ObjectManager.Player.Buffs.Any(buff => buff.Name != "lucianpassivebuff"))
            {
                if (LucianSpells.W.GetCircularFarmLocation(MinionManager.GetMinions(ObjectManager.Player.Position, LucianSpells.Q.Range, MinionTypes.All, MinionTeam.NotAlly)).MinionsHit >= getSliderItem(clearMenu, "lucian.w.minion.hit.count"))
                {
                    LucianSpells.W.Cast(
                        LucianSpells.W.GetCircularFarmLocation(MinionManager.GetMinions(ObjectManager.Player.Position,
                                                                                        LucianSpells.Q.Range, MinionTypes.All, MinionTeam.NotAlly)).Position);
                }
            }
        }
示例#9
0
 public static void CastSafePosition(Spell spell, AIHeroClient hero)
 {
     if (
         Geometry.CircleCircleIntersection(ObjectManager.Player.ServerPosition.To2D(),
                                           Prediction.GetPrediction(hero, 0f, hero.AttackRange).UnitPosition.To2D(), spell.Range,
                                           Orbwalking.GetRealAutoAttackRange(hero)).Count() > 0)
     {
         spell.Cast(
             Geometry.CircleCircleIntersection(ObjectManager.Player.ServerPosition.To2D(),
                                               Prediction.GetPrediction(hero, 0f, hero.AttackRange).UnitPosition.To2D(), spell.Range,
                                               Orbwalking.GetRealAutoAttackRange(hero)).MinOrDefault(i => i.Distance(Game.CursorPos)));
     }
     else
     {
         spell.Cast(ObjectManager.Player.ServerPosition.Extend(hero.ServerPosition, -spell.Range));
     }
 }
示例#10
0
 private void castQ(AIHeroClient target)
 {
     if (Q.IsCharging)
     {
         checkCastedQ(target);
     }
     else if (Q.CanCast(target) && !Orbwalker.IsAutoAttacking)
     {
         var qPred  = Prediction.GetPrediction(target, 0.3f);
         var qPred2 = Prediction.GetPrediction(target, 0.6f);
         var poly   = GetPoly(qPred.UnitPosition);
         if (qPred2.Hitchance >= HitChance.High && poly.IsInside(qPred2.UnitPosition.To2D()) &&
             poly.IsInside(target.ServerPosition))
         {
             Q.StartCharging(qPred.CastPosition);
         }
     }
 }
示例#11
0
文件: Program.cs 项目: riwalry1/AIO
        public static void walljump()
        {
            var x = Player.Position.LSExtend(Game.CursorPos, 100);
            var y = Player.Position.LSExtend(Game.CursorPos, 30);

            if (!x.LSIsWall() && !y.LSIsWall())
            {
                EloBuddy.Player.IssueOrder(GameObjectOrder.MoveTo, x);
            }
            if (x.LSIsWall() && !y.LSIsWall())
            {
                EloBuddy.Player.IssueOrder(GameObjectOrder.MoveTo, y);
            }
            if (Prediction.GetPrediction(Player, 500).UnitPosition.LSDistance(Player.Position) <= 10)
            {
                Q.Cast(Game.CursorPos);
            }
        }
示例#12
0
 private void OnInterruptableTarget(Obj_AI_Hero target, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (E.CanCast(target) && config.Item("useEint", true).GetValue <bool>())
     {
         if (Program.IsSPrediction)
         {
             if (E.SPredictionCast(target, HitChance.High))
             {
                 return;
             }
         }
         else
         {
             if (E.CastIfHitchanceEquals(target, HitChance.High))
             {
                 return;
             }
         }
     }
     if (R.CanCast(target) && config.Item("useRint", true).GetValue <bool>())
     {
         if (savedQ != null && !SimpleQ && !target.IsMoving && target.Distance(qPos) > QExplosionRange &&
             target.Distance(player) < R.Range - 100 &&
             target.Position.Distance(savedQ.position) < 550 + QExplosionRange / 2 &&
             !target.HasBuffOfType(BuffType.Knockback))
         {
             var cast = Prediction.GetPrediction(target, 1000f).UnitPosition.Extend(savedQ.position, -100);
             R.Cast(cast);
         }
         else if (target.Distance(player) < R.Range - 100)
         {
             if (player.CountEnemiesInRange(2000) <= player.CountAlliesInRange(2000))
             {
                 var cast = target.Position.Extend(player.Position, -100);
                 R.Cast(cast);
             }
             else
             {
                 var cast = target.Position.Extend(player.Position, 100);
                 R.Cast(cast);
             }
         }
     }
 }
示例#13
0
文件: Zac.cs 项目: soulcrash/PortAIO
        private void CastE(Obj_AI_Base target)
        {
            if (target.LSDistance(player) > eRanges[E.Level - 1])
            {
                return;
            }
            var eFlyPred  = E.GetPrediction(target);
            var enemyPred = Prediction.GetPrediction(
                target, eChannelTimes[E.Level - 1] + target.LSDistance(player) / E.Speed / 1000);

            if (E.IsCharging)
            {
                if (!eFlyPred.CastPosition.IsValid() || eFlyPred.CastPosition.IsWall())
                {
                    return;
                }
                if (eFlyPred.CastPosition.LSDistance(player.Position) < E.Range)
                {
                    E.CastIfHitchanceEquals(target, HitChance.High, getCheckBoxItem(config, "packets"));
                }
                else if (eFlyPred.UnitPosition.LSDistance(player.Position) < E.Range && target.LSDistance(player) < 500f)
                {
                    E.CastIfHitchanceEquals(target, HitChance.Medium, getCheckBoxItem(config, "packets"));
                }
                else if ((eFlyPred.CastPosition.LSDistance(player.Position) < E.Range &&
                          eRanges[E.Level - 1] - eFlyPred.CastPosition.LSDistance(player.Position) < 200) ||
                         (CombatHelper.GetAngle(player, eFlyPred.CastPosition) > 35))
                {
                    E.CastIfHitchanceEquals(target, HitChance.Medium, getCheckBoxItem(config, "packets"));
                }
                else if (eFlyPred.CastPosition.LSDistance(player.Position) < E.Range && zacETime != 0 &&
                         Environment.TickCount - zacETime > 2500)
                {
                    E.CastIfHitchanceEquals(target, HitChance.Medium, getCheckBoxItem(config, "packets"));
                }
            }
            else if (enemyPred.UnitPosition.LSDistance(player.Position) < eRanges[E.Level - 1] &&
                     getSliderItem(menuC, "Emin") < target.LSDistance(player.Position))
            {
                E.SetCharged("ZacE", "ZacE", 300, eRanges[E.Level - 1], eChannelTimes[E.Level - 1]);
                E.StartCharging(eFlyPred.UnitPosition);
            }
        }
示例#14
0
        private Vector3 GetVectorE(AIHeroClient target)
        {
            var pos  = Vector3.Zero;
            var pred = Prediction.GetPrediction(target, 0.28f);

            if (!target.IsMoving)
            {
                return(pos);
            }
            var distW  = E.Width / 2 + target.BoundingRadius;
            var points = CombatHelper.PointsAroundTheTarget(pred.UnitPosition, distW);
            var walls  =
                points.Where(p => p.IsWall() && player.Distance(target) > target.BoundingRadius)
                .OrderBy(p => p.Distance(pred.UnitPosition));
            var wall = walls.FirstOrDefault();

            if (wall.IsValid() && wall.Distance(target.Position) < 350 &&
                walls.Any(w => w.Distance(target.Position) < distW))
            {
                pos = wall.Extend(pred.UnitPosition, (target.BoundingRadius + distW));
            }
            if (config.Item("useeWall", true).GetValue <bool>())
            {
                return(pos);
            }
            if (pred.Hitchance < HitChance.Medium || target.Distance(player) < Orbwalking.GetRealAutoAttackRange(target))
            {
                return(pos);
            }
            if (pred.UnitPosition.Distance(player.Position) > player.Distance(target))
            {
                var dist    = target.BoundingRadius + E.Width;
                var predPos = pred.UnitPosition;
                if (target.Distance(predPos) < dist)
                {
                    predPos = target.Position.Extend(predPos, dist);
                }
                pos = predPos.Extend(target.Position, -dist);
            }
            return(pos);
        }
示例#15
0
        private void HandeR(Obj_AI_Base target, Vector3 toVector3, bool toBarrel)
        {
            if (target == null || !toVector3.IsValid())
            {
                return;
            }
            var pred = Prediction.GetPrediction(target, target.Distance(player.ServerPosition) / R.Speed);

            if (pred.Hitchance >= HitChance.VeryHigh && !justE && !target.IsDashing())
            {
                var cast = pred.UnitPosition.Extend(toVector3, -100);
                if (player.Distance(cast) < R.Range && checkBuffs(target, player.Distance(cast)) &&
                    pred.UnitPosition.Distance(target.Position) < 15 &&
                    ((!CombatHelper.CheckWalls(target.Position, toVector3)) ||
                     (toBarrel && savedQ.position.Distance(target.Position) < QExplosionRange)))
                {
                    if (toBarrel &&
                        4000 - savedQ.deltaT() > (player.Distance(cast) + cast.Distance(savedQ.position)) / R.Speed)
                    {
                        R.Cast(cast);
                        return;
                    }
                    else if (!toBarrel)
                    {
                        R.Cast(cast);
                    }
                }
            }

            /*
             * if (!config.Item("insecOnlyStun", true).GetValue<bool>())
             * {
             *  var cast = R.GetPrediction(target, true, 90);
             *  if (cast.Hitchance >= HitChance.VeryHigh)
             *  {
             *      R.Cast(cast.CastPosition.Extend(savedQ.position, -100));
             *  }
             * }*/
        }
示例#16
0
        private static void CastE(AIHeroClient target, List <Obj_AI_Minion> barrels)
        {
            if (barrels.Count(b => b.CountEnemiesInRange(BarrelConnectionRange) > 0) < 1)
            {
                if (getCheckBoxItem(comboMenu, "useeAlways"))
                {
                    CastEtarget(target);
                }
                return;
            }
            var enemies =
                HeroManager.Enemies.Where(e => e.LSIsValidTarget() && e.LSDistance(player) < E.Range)
                .Select(e => Prediction.GetPrediction(e, 0.35f));
            var points = new List <Vector3>();

            foreach (var barrel in
                     barrels.Where(b => b.LSDistance(player) < Q.Range && KillableBarrel(b)))
            {
                if (barrel != null)
                {
                    var newP = GetBarrelPoints(barrel.Position).Where(p => !p.IsWall());
                    if (newP.Any())
                    {
                        points.AddRange(newP.Where(p => p.LSDistance(player.Position) < E.Range));
                    }
                }
            }
            var bestPoint =
                points.Where(b => enemies.Count(e => e.UnitPosition.LSDistance(b) < BarrelExplosionRange) > 0)
                .OrderByDescending(b => enemies.Count(e => e.UnitPosition.LSDistance(b) < BarrelExplosionRange))
                .FirstOrDefault();

            if (bestPoint.IsValid() &&
                !savedBarrels.Any(b => b.barrel.Position.LSDistance(bestPoint) < BarrelConnectionRange))
            {
                E.Cast(bestPoint, getCheckBoxItem(config, "packets"));
            }
        }
示例#17
0
 private static void BeforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
 {
     try
     {
         if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && !HasPassive &&
             spells[Spells.Q].IsReady() &&
             !(MenuInit.getBoxItem(MenuInit.comboMenu, "Combo.Prio") == 0 ||
               MenuInit.getBoxItem(MenuInit.comboMenu, "Combo.Prio") == 1 && Ferocity == 5))
         {
             var x = Prediction.GetPrediction(args.Target as Obj_AI_Base, Player.AttackCastDelay + 0.04f);
             if (Player.Position.To2D().Distance(x.UnitPosition.To2D())
                 >= Player.BoundingRadius + Player.AttackRange + args.Target.BoundingRadius)
             {
                 args.Process = false;
                 spells[Spells.Q].Cast();
             }
         }
     }
     catch (Exception e)
     {
         Console.WriteLine(e);
     }
 }
示例#18
0
        public static void EComboHarasscast(string name, AIHeroClient target, Type type)
        {
            if (!GetBool(name, type))
            {
                return;
            }

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

            var pred      = Prediction.GetPrediction(target, 0.2f, target.BoundingRadius);
            var pos       = pred.UnitPosition;
            var extendpos = pos.Extend(Player.ServerPosition, 360);

            switch (GetStringValue("useemode"))
            {
            case 0:
                E.Cast(extendpos);
                break;
            }
        }
示例#19
0
        private static void Combo(AIHeroClient targ = null, bool force = false)
        {
            if (Q.LastCastedDelay(Delay) || R.LastCastedDelay(Delay))
            {
                return;
            }

            if (!force && CastSecondW())
            {
                return;
            }

            var target = targ ??
                         TargetSelector.GetTarget(
                EFirst && E.IsReady() ? E.Range : W.Range + WRadius - 10, DamageType.Magical);

            if (!target.IsValidTarget())
            {
                //Console.WriteLine("BAD TARG");
                return;
            }

            if (CastEFirst(target))
            {
                Console.WriteLine("Combo: Cast E FIRST");
                return;
            }

            if (Q.CanCast(target) && Q.IsActive(force) && Q.CastOnUnit(target))
            {
                Console.WriteLine("Combo: Cast Q");
                return;
            }

            SpellManager.UpdateUltimate();
            if (R.CanCast(target) && R.IsActive(force) && R.GetSpellSlot() == SpellSlot.Q && R.CastOnUnit(target))
            {
                Console.WriteLine("Combo: Cast R(Q)");
                return;
            }

            if (W.IsReady() && target.IsValidTarget(W.Range + WRadius - 10) && W.IsActive(force) && W.IsFirstW())
            {
                if (!force ||
                    (target.CountEnemiesInRange(300) <= getSliderItem(ksMenu, "KSEnemies") &&
                     Player.HealthPercent >= getSliderItem(ksMenu, "KSHealth")))
                {
                    var pos = Prediction.GetPrediction(target, W.Delay, W.Range + WRadius, W.Speed);
                    if (pos.CastPosition.Distance(target.ServerPosition) < WRadius && W.Cast(pos.CastPosition))
                    {
                        Console.WriteLine("Combo: Cast W");
                        return;
                    }
                }
            }

            if (E.CanCast(target) && E.IsActive(force) && target.DistanceToPlayer() > 50 && E.Cast(target).IsCasted())
            {
                Console.WriteLine("Combo: Cast E");
            }
        }
示例#20
0
 private static int CountEnemiesInRangeDeley(Vector3 position, float range, float delay)
 {
     return(Program.Enemies.Where(t => t.IsValidTarget()).Select(t => Prediction.GetPrediction(t, delay).CastPosition).Count(prepos => position.Distance(prepos) < range));
 }
示例#21
0
        private static void Game_OnGameUpdate(EventArgs args)
        {
            var targetf = TargetSelector.GetTarget(1000, DamageType.Magical);

            if (getKeyBindItem(menuC, "useeflashforced"))
            {
                if (targetf == null)
                {
                    Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                }
                else
                {
                    var bestpos  = CombatHelper.bestVectorToPoppyFlash2(targetf);
                    var hasFlash = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerFlash")) ==
                                   SpellState.Ready;
                    if (E.IsReady() && hasFlash && !CheckWalls(player, targetf) && bestpos.IsValid())
                    {
                        player.Spellbook.CastSpell(player.GetSpellSlot("SummonerFlash"), bestpos);
                        Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                    }
                    else if (!hasFlash)
                    {
                        Combo();
                        Orbwalker.OrbwalkTo(Game.CursorPos);
                        //Orbwalking.Orbwalk(targetf, Game.CursorPos, 90, 90);
                    }
                }
            }

            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
            {
                Combo();
            }

            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
            {
                Harass();
            }

            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) ||
                Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
            {
                Clear();
            }

            if (!player.IsDead)
            {
                foreach (var dashingEnemy in
                         HeroManager.Enemies.Where(
                             e =>
                             e.IsValidTarget() && e.LSDistance(player) < 1600 &&
                             getSliderItem(menuM, "useAutoW" + e.BaseSkinName) > 0)
                         .OrderByDescending(e => getSliderItem(menuM, "useAutoW" + e.BaseSkinName))
                         .ThenBy(e => e.LSDistance(player)))
                {
                    var nextpos = Prediction.GetPrediction(dashingEnemy, 0.1f).UnitPosition;
                    if (dashingEnemy.IsDashing() && !dashingEnemy.HasBuffOfType(BuffType.SpellShield) &&
                        !dashingEnemy.HasBuff("poppyepushenemy") && dashingEnemy.LSDistance(player) <= W.Range &&
                        (nextpos.LSDistance(player.Position) > W.Range || (player.LSDistance(dashingEnemy) < W.Range - 100)) &&
                        dashingEnemy.IsTargetable && !NotDash.Contains(dashingEnemy.ChampionName))
                    {
                        W.Cast();
                    }
                    if (
                        CombatHelper.DashDatas.Any(
                            d => d.ChampionName == dashingEnemy.ChampionName && d.IsReady(dashingEnemy)))
                    {
                        break;
                    }
                }
            }
        }
示例#22
0
        private void Combo()
        {
            if (getCheckBoxItem(menuC, "user") && R.IsReady())
            {
                var rTarget = TargetSelector.GetTarget(2500, DamageType.Physical);
                if (rTarget == null)
                {
                    return;
                }
                if (!activatedR && !Orbwalker.IsAutoAttacking)
                {
                    if (rTarget != null && !rTarget.IsInvulnerable && !rTarget.MagicImmune && rTarget.LSDistance(Game.CursorPos) < 300)
                    {
                        if (player.LSDistance(rTarget) + 100 > Environment.Map.GetPath(player, rTarget.Position) && ComboDamage(rTarget) > rTarget.Health && !CombatHelper.IsCollidingWith(player, rTarget.Position.LSExtend(player.Position, player.BoundingRadius + 15), player.BoundingRadius, new[] { CollisionableObjects.Heroes, CollisionableObjects.Walls }) && (ComboDamage(rTarget) - R.GetDamage(rTarget) < rTarget.Health || rTarget.LSDistance(player) > 400 || player.HealthPercent < 25) && rTarget.CountAlliesInRange(2500) + 1 >= rTarget.CountEnemiesInRange(2500))
                        {
                            R.Cast(rTarget.Position);
                        }
                    }
                }
            }

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

            if (target == null || target.IsInvulnerable || target.MagicImmune)
            {
                return;
            }
            var data = IncDamages.GetAllyData(player.NetworkId);

            if (!activatedW && W.IsReady() && getCheckBoxItem(menuC, "usew"))
            {
                if (data.DamageTaken > player.Health ||
                    (data.DamageTaken > getWShield() / 100 * getSliderItem(menuC, "shieldDmg")) ||
                    (target.LSDistance(player) < W.Range && getCheckBoxItem(menuC, "usewir")))
                {
                    W.Cast(getCheckBoxItem(config, "packets"));
                }
            }
            if (activatedW && getCheckBoxItem(menuC, "usew") && W.IsReady() &&
                player.LSDistance(target) < W.Range &&
                (target.Health < W.GetDamage(target) ||
                 (W.IsInRange(target) && !W.IsInRange(Prediction.GetPrediction(target, 0.2f).UnitPosition))))
            {
                W.Cast(getCheckBoxItem(config, "packets"));
            }

            var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            var hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (getCheckBoxItem(menuC, "useIgnite") &&
                ignitedmg > HealthPrediction.GetHealthPrediction(target, 700) && hasIgnite &&
                !CombatHelper.CheckCriticalBuffs(target))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (activatedP)
            {
                if (Q.IsReady() && player.LSDistance(target) > Orbwalking.GetRealAutoAttackRange(target))
                {
                    Q.Cast(getCheckBoxItem(config, "packets"));
                }
                return;
            }

            var qTarget = TargetSelector.GetTarget(!Q.IsCharging ? Q.ChargedMaxRange / 2 : Q.ChargedMaxRange, DamageType.Physical);

            if (qTarget == null && Q.IsCharging)
            {
                ObjectManager.Player.Spellbook.CastSpell(SpellSlot.Q);
            }
            if (Q.IsCharging)
            {
                var start     = ObjectManager.Player.ServerPosition.LSTo2D();
                var end       = start.LSExtend(QCastPos, Q.Range);
                var direction = (end - start).Normalized();
                var normal    = direction.Perpendicular();

                var points = new List <Vector2>();
                var hitBox = qTarget.BoundingRadius;
                points.Add(start + normal * (Q.Width + hitBox));
                points.Add(start - normal * (Q.Width + hitBox));
                points.Add(end + Q.ChargedMaxRange * direction - normal * (Q.Width + hitBox));
                points.Add(end + Q.ChargedMaxRange * direction + normal * (Q.Width + hitBox));

                for (var i = 0; i <= points.Count - 1; i++)
                {
                    var A = points[i];
                    var B = points[i == points.Count - 1 ? 0 : i + 1];

                    if (qTarget.ServerPosition.LSTo2D().LSDistance(A, B, true, true) < 50 * 50)
                    {
                        Q.Cast(qTarget, true);
                    }
                }
                checkCastedQ(target);
                return;
            }
            if (activatedR)
            {
                return;
            }
            if (getCheckBoxItem(menuC, "usee") && E.IsReady() && !Orbwalker.IsAutoAttacking)
            {
                CastEHero(target);
                return;
            }
            if (getCheckBoxItem(menuC, "useq") && !Orbwalker.IsAutoAttacking)
            {
                castQ(target);
            }
            if (!activatedW && W.IsReady() && data.AnyCC)
            {
                W.Cast(getCheckBoxItem(config, "packets"));
            }

            if (getCheckBoxItem(menuC, "userCC") && player.LSDistance(target) < Q.Range &&
                HeroManager.Enemies.FirstOrDefault(e => e.LSDistance(Game.CursorPos) < 300) != null && data.AnyCC)
            {
                R.Cast(Game.CursorPos, getCheckBoxItem(config, "packets"));
            }
        }
示例#23
0
        private static void LogicR()
        {
            if (getCheckBoxItem(rMenu, "autoR"))
            {
                if (SebbyLib.Program.LagFree(4) && SebbyLib.Program.Combo && RMissile != null && RMissile.IsValid)
                {
                    if (RMissile.Position.CountEnemiesInRange(R.Range) >= getSliderItem(rMenu, "rCount") &&
                        getSliderItem(rMenu, "rCount") > 0)
                    {
                        R.Cast();
                    }

                    foreach (
                        var t in
                        SebbyLib.Program.Enemies.Where(
                            t =>
                            t.IsValidTarget() &&
                            RMissile.Position.LSDistance(Prediction.GetPrediction(t, R.Delay).CastPosition) <
                            R.Range && RMissile.Position.LSDistance(t.ServerPosition) < R.Range))
                    {
                        var comboDMG = OktwCommon.GetKsDamage(t, R);

                        if (Q.IsReady())
                        {
                            comboDMG += Q.GetDamage(t);
                        }

                        if (E.IsReady())
                        {
                            comboDMG += E.GetDamage(t);
                        }

                        if (W.IsReady())
                        {
                            comboDMG += W.GetDamage(t);
                        }

                        if (t.Health < comboDMG && OktwCommon.ValidUlt(t))
                        {
                            R.Cast();
                        }

                        SebbyLib.Program.debug("ks");
                    }
                }

                var dmg    = OktwCommon.GetIncomingDamage(Player, 1);
                var enemys = Player.CountEnemiesInRange(800);

                if (dmg > 0 || enemys > 0)
                {
                    if (dmg > Player.Level * 50)
                    {
                        R.Cast();
                    }
                    else if (Player.Health - dmg < enemys * Player.Level * 20)
                    {
                        R.Cast();
                    }
                    else if (Player.Health - dmg < Player.Level * 10)
                    {
                        R.Cast();
                    }
                }
            }
        }
示例#24
0
文件: Gnar.cs 项目: Burbb/Portaio
        /// <summary>
        ///     Combo
        /// </summary>
        private static void Combo()
        {
            #region Mini Gnar

            if (Player.IsMiniGnar())
            {
                var target  = TargetSelector.GetTarget(GnarSpells.QMini.Range, DamageType.Physical);
                var qSpell  = getCheckBoxItem(comboMenu, "UseQMini");
                var qsSpell = getCheckBoxItem(comboMenu, "UseQs");
                var eSpell  = getCheckBoxItem(comboMenu, "eGap");
                if (target == null)
                {
                    return;
                }
                var qpred     = GnarSpells.QMini.GetPrediction(target);
                var collision = GnarSpells.QMini.GetCollision(Player.Position.LSTo2D(), new List <Vector2> {
                    qpred.CastPosition.LSTo2D()
                });
                var mincol = collision.Where(obj => obj != null && obj.LSIsValidTarget() && !obj.IsDead && obj.IsMinion);

                var aiBases    = mincol as Obj_AI_Base[] ?? mincol.ToArray();
                var objAiBases = mincol as IList <Obj_AI_Base> ?? aiBases.ToList();
                var count      = objAiBases.Count();

                var firstcol = objAiBases.OrderBy(m => m.LSDistance(Player.ServerPosition, true)).FirstOrDefault();

                if (qSpell && target.LSIsValidTarget(GnarSpells.QMini.Range) && Player.LSDistance(target) > 450)
                {
                    if (!aiBases.Any())
                    {
                        if (!qsSpell)
                        {
                            GnarSpells.QnMini.Cast(qpred.CastPosition);
                        }

                        else if (target.Buffs.Any(buff => buff.Name == "gnarwproc" && buff.Count == 2))
                        {
                            GnarSpells.QnMini.Cast(qpred.CastPosition);
                        }
                    }
                    else
                    {
                        if (objAiBases.Any(minc => count >= 1 && firstcol.LSDistance(target) <= 350))
                        {
                            if (!qsSpell)
                            {
                                GnarSpells.QMini.Cast(qpred.CastPosition);
                            }

                            else if (target.Buffs.Any(buff => buff.Name == "gnarwproc" && buff.Count == 2))
                            {
                                GnarSpells.QnMini.Cast(qpred.CastPosition);
                            }
                        }
                    }
                }

                if (eSpell && GnarSpells.EMini.IsReady() && Player.IsAboutToTransform())
                {
                    var targetA = GnarSpells.EMini.GetTarget(GnarSpells.EMini.Width / 2f);
                    if (targetA != null)
                    {
                        var prediction = GnarSpells.EMini.GetPrediction(targetA);

                        if (prediction.Hitchance >= HitChance.High)
                        {
                            var arrivalPoint = Player.ServerPosition.LSExtend(prediction.CastPosition, Player.ServerPosition.LSDistance(prediction.CastPosition) + GnarSpells.EMini.Range);
                            if (!ObjectManager.Get <Obj_AI_Turret>().Any(t => t.Team != Player.Team && !t.IsDead && t.LSDistance(arrivalPoint, true) < 775 * 775))
                            {
                                if (GnarSpells.EMini.Cast(prediction.CastPosition))
                                {
                                    return;
                                }
                            }
                        }
                    }
                }
            }
            else

            #endregion

            #region Mega Gnar

            {
                var target  = TargetSelector.GetTarget(GnarSpells.QMega.Range, DamageType.Physical);
                var rSlider = getSliderItem(comboMenu, "useRSlider");
                var emSpell = getCheckBoxItem(comboMenu, "UseEMega");
                var qmSpell = getCheckBoxItem(comboMenu, "UseQMega");
                var wSpell  = getCheckBoxItem(comboMenu, "UseWMega");
                if (target == null)
                {
                    return;
                }
                if (GnarSpells.RMega.IsReady() && getCheckBoxItem(comboMenu, "UseRMega"))
                {
                    if (Player.CountEnemiesInRange(420) >= rSlider)
                    {
                        var prediction = Prediction.GetPrediction(target, GnarSpells.RMega.Delay);
                        if (GnarSpells.RMega.IsInRange(prediction.UnitPosition))
                        {
                            var direction    = (Player.ServerPosition - prediction.UnitPosition).Normalized();
                            var maxAngle     = 180f;
                            var step         = maxAngle / 6f;
                            var currentAngle = 0f;
                            var currentStep  = 0f;
                            while (true)
                            {
                                if (currentStep > maxAngle && currentAngle < 0)
                                {
                                    break;
                                }

                                if ((currentAngle == 0 || currentAngle < 0) && currentStep != 0)
                                {
                                    currentAngle = currentStep * (float)Math.PI / 180;
                                    currentStep += step;
                                }
                                else if (currentAngle > 0)
                                {
                                    currentAngle = -currentAngle;
                                }

                                Vector3 checkPoint;
                                if (currentStep == 0)
                                {
                                    currentStep = step;
                                    checkPoint  = prediction.UnitPosition + 500 * direction;
                                }
                                else
                                {
                                    checkPoint = prediction.UnitPosition + 500 * direction.Rotated(currentAngle);
                                }

                                if (prediction.UnitPosition.GetFirstWallPoint(checkPoint).HasValue &&
                                    !target.IsStunned
                                    &&
                                    target.Health >=
                                    GnarSpells.QMega.GetDamage(target) + Player.GetAutoAttackDamage(target))
                                {
                                    GnarSpells.RMega.Cast(Player.Position +
                                                          500 * (checkPoint - prediction.UnitPosition).Normalized());
                                    rcast = Environment.TickCount;
                                    break;
                                }
                            }
                        }
                    }
                }

                if (GnarSpells.EMega.IsReady() && target.LSDistance(Player) > 500 && emSpell && target.HealthPercent <= Player.HealthPercent)
                {
                    GnarSpells.EMega.Cast(target);
                }

                if (wSpell && Environment.TickCount - rcast >= 600)
                {
                    GnarSpells.WMega.Cast(target);
                }

                if (qmSpell && Environment.TickCount - rcast >= 700)
                {
                    if (target.LSDistance(Player) <= 130)
                    {
                        if (GnarSpells.QnMega.IsReady())
                        {
                            GnarSpells.QnMega.Cast(target);
                        }
                    }
                    else if (GnarSpells.QMega.IsReady())
                    {
                        GnarSpells.QMega.Cast(target);
                    }
                }
            }
            #endregion
        }
示例#25
0
文件: Program.cs 项目: riwalry1/AIO
 private static void Combo()
 {
     if (Q.IsReady() && QGap && !Player.LSIsDashing())
     {
         var target = HeroManager.Enemies.Where(x => x.LSIsValidTarget()).OrderByDescending(x => 1 - x.LSDistance(Player.Position)).FirstOrDefault();
         if (!Player.LSIsDashing() && Utils.GameTimeTickCount - cQ >= 1000 && target.LSIsValidTarget())
         {
             if (Prediction.GetPrediction(Player, 100).UnitPosition.LSDistance(target.Position) <= Player.LSDistance(target.Position))
             {
                 Q.Cast(Game.CursorPos);
             }
         }
     }
     if (W.IsReady())
     {
         var targets = HeroManager.Enemies.Where(x => x.LSIsValidTarget() && !x.IsZombie && InWRange(x));
         if (targets.Any())
         {
             W.Cast();
         }
     }
     if (E.IsReady() && Ecombo)
     {
         var target = TargetSelector.GetTarget(325 + Player.AttackRange + 70, DamageType.Physical);
         if (target.LSIsValidTarget() && !target.IsZombie)
         {
             E.Cast(target.Position);
         }
     }
     if (R.IsReady())
     {
         if (R.Instance.Name == R1name)
         {
             if (Rcomboalways)
             {
                 var target = TargetSelector.GetTarget(325 + Player.AttackRange + 70, DamageType.Physical);
                 if (target.LSIsValidTarget() && !target.IsZombie && E.IsReady())
                 {
                     R.Cast();
                 }
                 else
                 {
                     var targetR = TargetSelector.GetTarget(200 + Player.BoundingRadius + 70, DamageType.Physical);
                     if (targetR.LSIsValidTarget() && !targetR.IsZombie)
                     {
                         R.Cast();
                     }
                 }
             }
             if (RcomboKillable)
             {
                 var targetR = TargetSelector.GetTarget(200 + Player.BoundingRadius + 70, DamageType.Physical);
                 if (targetR.LSIsValidTarget() && !targetR.IsZombie && basicdmg(targetR) <= targetR.Health && totaldame(targetR) >= targetR.Health)
                 {
                     R.Cast();
                 }
                 if (targetR.LSIsValidTarget() && !targetR.IsZombie && Player.CountEnemiesInRange(800) >= 2)
                 {
                     R.Cast();
                 }
             }
         }
         else if (R.Instance.Name == R2name)
         {
             if (R2comboKS)
             {
                 var targets = HeroManager.Enemies.Where(x => x.LSIsValidTarget(R.Range) && !x.IsZombie);
                 foreach (var target in targets)
                 {
                     if (target.Health < Rdame(target, target.Health))
                     {
                         R.Cast(target);
                     }
                 }
             }
             if (R2comboMaxdmg)
             {
                 var targets = HeroManager.Enemies.Where(x => x.LSIsValidTarget(R.Range) && !x.IsZombie);
                 foreach (var target in targets)
                 {
                     if (target.Health / target.MaxHealth <= 0.25)
                     {
                         R.Cast(target);
                     }
                 }
             }
             if (R2BadaoStyle && !Q.IsReady())
             {
                 var target = TargetSelector.GetTarget(R.Range, DamageType.Physical);
                 if (target.LSIsValidTarget() && !target.IsZombie)
                 {
                     R.Cast(target);
                 }
             }
             var targethits = TargetSelector.GetTarget(R.Range, DamageType.Physical);
             if (targethits.LSIsValidTarget() && !targethits.IsZombie)
             {
                 R.CastIfWillHit(targethits, 4);
             }
         }
     }
 }
示例#26
0
        private void moveGhost()
        {
            var ghost =
                (Obj_AI_Minion)
                MinionManager.GetMinions(3000, MinionTypes.All, MinionTeam.Ally)
                .FirstOrDefault(m => m.HasBuff("yorickunholysymbiosis"));
            var Gtarget = TargetSelector.GetTarget(GhostRange, DamageType.Magical);

            switch (getBoxItem(menuM, "ghostTarget"))
            {
            case 0:
                Gtarget = TargetSelector.GetTarget(R.Range, DamageType.Magical);
                break;

            case 1:
                Gtarget =
                    HeroManager.Enemies.Where(i => player.Distance(i) <= R.Range)
                    .OrderBy(i => i.Health)
                    .FirstOrDefault();
                break;

            case 2:
                Gtarget =
                    HeroManager.Enemies.Where(i => player.Distance(i) <= R.Range)
                    .OrderBy(i => player.Distance(i))
                    .FirstOrDefault(); break;

            default:
                break;
            }
            if (ghost != null && Gtarget != null && Gtarget.IsValid && ghost.CanAttack) // BERB @ not sure
            {
                if (ghost.IsMelee)
                {
                    if (CanCloneAttack(ghost) || player.HealthPercent < 25)
                    {
                        R.CastOnUnit(Gtarget, getCheckBoxItem(config, "packets"));
                    }
                    else
                    {
                        var prediction = Prediction.GetPrediction(Gtarget, 2);
                        R.Cast(
                            Gtarget.Position.Extend(prediction.UnitPosition, Orbwalking.GetRealAutoAttackRange(Gtarget)),
                            getCheckBoxItem(config, "packets"));
                    }
                }
                else
                {
                    if (CanCloneAttack(ghost) || player.HealthPercent < 25)
                    {
                        R.CastOnUnit(Gtarget, getCheckBoxItem(config, "packets"));
                    }
                    else
                    {
                        var pred  = Prediction.GetPrediction(Gtarget, 0.5f);
                        var point =
                            CombatHelper.PointsAroundTheTargetOuterRing(pred.UnitPosition, Gtarget.AttackRange / 2)
                            .Where(p => !p.IsWall())
                            .OrderBy(p => p.CountEnemiesInRange(500))
                            .ThenBy(p => p.LSDistance(player.Position))
                            .FirstOrDefault();

                        if (point.IsValid())
                        {
                            R.Cast(point, getCheckBoxItem(config, "packets"));
                        }
                    }
                }
                GhostDelay = true;
                Utility.DelayAction.Add(200, () => GhostDelay = false);
            }
        }
示例#27
0
        private void Combo(AIHeroClient target, float cmbDmg, bool canKill, bool bush)
        {
            if (target == null || !target.IsValidTarget())
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, cmbDmg);
            }
            if (config.Item("usew", true).GetValue <bool>() && W.IsReady() && W.CanCast(target))
            {
                var tarPered = W.GetPrediction(target);
                if (justE && !Estun && ePos.IsValid() && target.Distance(ePos) < 375)
                {
                    if (W.Range - 80 > tarPered.CastPosition.Distance(player.Position) &&
                        tarPered.Hitchance >= HitChance.High)
                    {
                        W.Cast(target.Position);
                    }
                }
                else
                {
                    if (W.Range - 80 > tarPered.CastPosition.Distance(player.Position) &&
                        tarPered.Hitchance >= HitChance.VeryHigh && !config.Item("startWithE", true).GetValue <bool>())
                    {
                        W.Cast(tarPered.CastPosition);
                    }
                }
            }
            if (config.Item("usee", true).GetValue <bool>() && E.IsReady() &&
                (((canKill && config.Item("useekill", true).GetValue <bool>()) ||
                  (!config.Item("useekill", true).GetValue <bool>() && CheckMana())) ||
                 config.Item("startWithE", true).GetValue <bool>()))
            {
                switch (config.Item("eType", true).GetValue <StringList>().SelectedIndex)
                {
                case 0:
                    CastE(target);
                    return;

                case 1:
                    CastE(target, false);
                    return;

                    break;
                }
            }
            if (config.Item("usee", true).GetValue <bool>() && E.IsReady())
            {
                if (config.Item("useemin", true).GetValue <Slider>().Value > 1 &&
                    player.CountEnemiesInRange(E.Range + 175) >= config.Item("useemin", true).GetValue <Slider>().Value)
                {
                    switch (config.Item("eType", true).GetValue <StringList>().SelectedIndex)
                    {
                    case 0:
                        CastE(target, true, config.Item("useemin", true).GetValue <Slider>().Value);
                        return;
                    }
                }
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() && Q.CanCast(target) && target.IsValidTarget() &&
                !bush && !Estun)
            {
                CastQHero(target);
            }
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (config.Item("useIgnite", true).GetValue <bool>() &&
                ((ignitedmg > target.Health && hasIgnite && !player.IsChannelingImportantSpell() && !justQ &&
                  !Q.CanCast(target) && !justR && !R.CanCast(target) && CheckW(target)) || IgniteTarget != null))
            {
                if (IgniteTarget != null)
                {
                    player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), IgniteTarget);
                    return;
                }
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            var castR = false;

            if (target.CountEnemiesInRange(2000) == 1)
            {
                castR = true;
            }
            else if (!config.Item("ult" + target.BaseSkinName, true).GetValue <bool>())
            {
                castR = true;
            }
            if (R.IsReady() && R.CanCast(target) && CheckUltBlock(target) && config.Item("user", true).GetValue <bool>() &&
                castR && R.Instance.SData.Mana < player.Mana &&
                !target.Buffs.Any(b => CombatHelper.invulnerable.Contains(b.Name)) &&
                !CombatHelper.CheckCriticalBuffs(target))
            {
                if (config.Item("userPred", true).GetValue <bool>())
                {
                    var Whit = wPos.IsValid() && System.Environment.TickCount - wTime > 700 &&
                               Prediction.GetPrediction(target, 0.55f).UnitPosition.Distance(wPos) < W.Width;
                    var targetHP = target.Health -
                                   Program.IncDamages.GetEnemyData(target.NetworkId).ProjectileDamageTaken;
                    var killWithIgnite = hasIgnite && config.Item("useIgnite", true).GetValue <bool>() &&
                                         R.GetDamage(target) + ignitedmg > targetHP && targetHP > R.GetDamage(target);

                    var killWithW = wPos != null && Whit && R.GetDamage(target) + W.GetDamage(target) > targetHP &&
                                    target.Health > R.GetDamage(target);

                    var killWithIgniteAndW = !killWithW && Whit && hasIgnite &&
                                             config.Item("useIgnite", true).GetValue <bool>() &&
                                             R.GetDamage(target) + W.GetDamage(target) + ignitedmg > targetHP &&
                                             targetHP > R.GetDamage(target) + W.GetDamage(target);

                    if (killWithW || (targetHP < R.GetDamage(target) && !justQ && CheckW(target)))
                    {
                        R.CastOnUnit(target);
                    }

                    if ((killWithIgnite || killWithIgniteAndW) && CheckW(target) && player.Distance(target) < 600)
                    {
                        R.CastOnUnit(target);
                        IgniteTarget = target;
                        LeagueSharp.Common.Utility.DelayAction.Add(
                            200, () =>
                        {
                            IgniteTarget = null;
                            player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
                        });
                    }
                }
                else
                {
                    if (target.Health < R.GetDamage(target))
                    {
                        R.CastOnUnit(target);
                    }
                }
            }
        }
示例#28
0
        private void Combo()
        {
            AIHeroClient target = DrawHelper.GetBetterTarget(1700, TargetSelector.DamageType.Magical, true);

            if (target == null || target.IsInvulnerable || target.MagicImmune)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, ComboDamage(target));
            }
            var  edmg      = getEdamage(target);
            var  qdmg      = getQdamage(target);
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (config.Item("useIgnite", true).GetValue <bool>() &&
                ignitedmg > HealthPrediction.GetHealthPrediction(target, 700) && hasIgnite &&
                !CombatHelper.CheckCriticalBuffs(target) &&
                (!ActiveQ ||
                 (!(CombatHelper.IsFacing(player, target.Position, 30) && target.Distance(player) < Q.Range))))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (Q.CanCast(target) && config.Item("useq", true).GetValue <bool>() && Qhit(target.Position) &&
                (preventSilence(Q) ||
                 (target.Health < PassiveDmg(target) * 2 || qdmg > target.Health) &&
                 target.Distance(player) < Orbwalking.GetRealAutoAttackRange(target)))
            {
                Q.Cast(target.Position);
            }
            if (config.Item("usee", true).GetValue <bool>() && E.CanCast(target) &&
                (((preventSilence(E) ||
                   (target.Health < PassiveDmg(target) * 2 &&
                    target.Distance(player) < Orbwalking.GetRealAutoAttackRange(target))) &&
                  (!ActiveE ||
                   System.Environment.TickCount - lastE > config.Item("eDelay", true).GetValue <Slider>().Value)) ||
                 edmg > target.Health))
            {
                E.CastIfHitchanceEquals(target, HitChance.High);
            }
            if (W.IsReady() && config.Item("wSpeed", true).GetValue <bool>() && ActiveQ && preventSilence(W) &&
                target.Distance(player) < Q.Range &&
                Prediction.GetPrediction(target, 0.2f).UnitPosition.Distance(player.Position) > Q.Range)
            {
                W.Cast();
            }
            var canR = ComboDamage(target) > target.Health && qdmg < target.Health && target.Distance(player) < Q.Range &&
                       !Silenced;

            if (R.IsReady() &&
                (((target.Health <
                   getRdamage(target) * ((target.CountAlliesInRange(600) > 0 && target.HealthPercent > 15) ? 5 : 3) &&
                   target.Distance(player) > Q.Range) ||
                  (target.Distance(player) < Q.Range && target.Health < getRdamage(target) * 3 + edmg &&
                   target.Health > qdmg)) ||
                 player.CountEnemiesInRange(R.Range) >= config.Item("Rmin", true).GetValue <Slider>().Value))
            {
                HandleR(target, canR);
            }
        }
示例#29
0
        private static void Combo()
        {
            var target = TargetSelector.GetTarget(E.Range, DamageType.Physical);

            if (target == null)
            {
                return;
            }
            var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            var hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (getCheckBoxItem(comboMenu, "useIgnite") &&
                ignitedmg > target.Health - IncDamages.GetEnemyData(target.NetworkId).DamageTaken&& hasIgnite &&
                !CombatHelper.CheckCriticalBuffs(target) && !Q.IsReady() && !justQ)
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (getSliderItem(comboMenu, "usew") > player.HealthPercent &&
                player.CountEnemiesInRange(500) > 0)
            {
                W.Cast();
            }
            if (R.IsReady() && getCheckBoxItem(comboMenu, "user"))
            {
                var Rtarget =
                    HeroManager.Enemies.FirstOrDefault(e => e.HealthPercent < 50 && e.CountAlliesInRange(660) > 0);
                if (Rtarget != null)
                {
                    R.CastIfWillHit(Rtarget, getSliderItem(comboMenu, "Rmin"));
                }
            }
            var dontQ   = false;
            var barrels =
                GetBarrels()
                .Where(
                    o =>
                    o.IsValid && !o.IsDead && o.LSDistance(player) < 1600 && o.BaseSkinName == "GangplankBarrel" &&
                    o.GetBuff("gangplankebarrellife").Caster.IsMe)
                .ToList();

            if (getCheckBoxItem(comboMenu, "useq") && Q.IsReady() && getCheckBoxItem(comboMenu, "usee") &&
                E.IsReady() && !justE)
            {
                var pred = Prediction.GetPrediction(target, 0.5f);
                if (pred.Hitchance >= HitChance.High)
                {
                    var Qbarrels = GetBarrels().Where(o => o.LSDistance(player) < Q.Range && KillableBarrel(o));
                    foreach (var Qbarrel in Qbarrels.OrderByDescending(b => b.LSDistance(target) < BarrelExplosionRange))
                    {
                        var targPred = Prediction.GetPrediction(target, GetQTime(Qbarrel));
                        if (Qbarrel.LSDistance(targPred.UnitPosition) < BarrelExplosionRange)
                        {
                            if (getCheckBoxItem(comboMenu, "useeAOE") && barrels.Count < 2)
                            {
                                var enemies =
                                    HeroManager.Enemies.Where(
                                        e => e.LSDistance(player) < 1600 && e.LSDistance(Qbarrel) > BarrelExplosionRange)
                                    .Select(e => Prediction.GetPrediction(e, 05f));
                                var pos =
                                    GetBarrelPoints(Qbarrel.Position)
                                    .Where(p => p.LSDistance(Qbarrel.Position) < BarrelConnectionRange)
                                    .OrderByDescending(
                                        p => enemies.Count(e => e.UnitPosition.LSDistance(p) < BarrelExplosionRange))
                                    .ThenBy(p => p.LSDistance(target.Position))
                                    .FirstOrDefault();
                                if (pos.IsValid() && pos.CountEnemiesInRange(BarrelExplosionRange) > 0 &&
                                    enemies.Count(e => e.UnitPosition.LSDistance(pos) < BarrelExplosionRange) > 0)
                                {
                                    dontQ = true;
                                    E.Cast(pos);
                                }
                            }
                            break;
                        }
                        var point =
                            GetBarrelPoints(Qbarrel.Position)
                            .Where(
                                p =>
                                p.IsValid() && !p.IsWall() && p.LSDistance(player.Position) < E.Range &&
                                target.LSDistance(p) < BarrelExplosionRange &&
                                p.LSDistance(targPred.UnitPosition) < BarrelExplosionRange &&
                                Qbarrel.LSDistance(p) < BarrelConnectionRange &&
                                savedBarrels.Count(b => b.barrel.Position.LSDistance(p) < BarrelExplosionRange) <
                                1)
                            .OrderBy(p => p.LSDistance(pred.UnitPosition))
                            .FirstOrDefault();
                        if (point.IsValid())
                        {
                            dontQ = true;
                            E.Cast(point);
                            Utility.DelayAction.Add(1, () => Q.CastOnUnit(Qbarrel));
                            return;
                        }
                    }
                }
            }
            var meleeRangeBarrel =
                barrels.FirstOrDefault(
                    b =>
                    (b.Health < 2 || (b.Health == 2 && !KillableBarrel(b, true) && Q.IsReady() && !justQ)) &&
                    KillableBarrel(b, true) && b.LSDistance(player) < Orbwalking.GetRealAutoAttackRange(b));
            var secondb =
                barrels.Where(
                    b =>
                    b.LSDistance(meleeRangeBarrel) < BarrelConnectionRange &&
                    HeroManager.Enemies.Count(
                        o =>
                        o.LSIsValidTarget() && o.LSDistance(b) < BarrelExplosionRange &&
                        b.LSDistance(Prediction.GetPrediction(o, 500).UnitPosition) < BarrelExplosionRange) > 0);

            if (meleeRangeBarrel != null &&
                ((HeroManager.Enemies.Count(
                      o =>
                      o.LSIsValidTarget() && o.LSDistance(meleeRangeBarrel) < BarrelExplosionRange &&
                      meleeRangeBarrel.LSDistance(Prediction.GetPrediction(o, 500).UnitPosition) < BarrelExplosionRange) >
                  0) || secondb != null) && !Q.IsReady() && !justQ && Orbwalker.CanAutoAttack)
            {
                Orbwalker.DisableAttacking = true;
                Player.IssueOrder(GameObjectOrder.AttackUnit, meleeRangeBarrel);
            }
            if (Q.IsReady())
            {
                if (barrels.Any())
                {
                    var detoneateTargetBarrels = barrels.Where(b => b.LSDistance(player) < Q.Range);
                    if (getCheckBoxItem(comboMenu, "detoneateTarget"))
                    {
                        if (detoneateTargetBarrels.Any())
                        {
                            foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
                            {
                                if (!KillableBarrel(detoneateTargetBarrel))
                                {
                                    continue;
                                }
                                if (
                                    detoneateTargetBarrel.LSDistance(
                                        Prediction.GetPrediction(target, GetQTime(detoneateTargetBarrel)).UnitPosition) <
                                    BarrelExplosionRange &&
                                    target.LSDistance(detoneateTargetBarrel.Position) < BarrelExplosionRange)
                                {
                                    dontQ = true;
                                    Q.CastOnUnit(detoneateTargetBarrel, getCheckBoxItem(config, "packets"));
                                    return;
                                }
                                var detoneateTargetBarrelSeconds =
                                    barrels.Where(b => b.LSDistance(detoneateTargetBarrel) < BarrelConnectionRange);
                                if (detoneateTargetBarrelSeconds.Any())
                                {
                                    if (detoneateTargetBarrelSeconds.Any(detoneateTargetBarrelSecond => detoneateTargetBarrelSecond.LSDistance(
                                                                             Prediction.GetPrediction(
                                                                                 target, GetQTime(detoneateTargetBarrel) + 0.15f).UnitPosition) <
                                                                         BarrelExplosionRange &&
                                                                         target.LSDistance(detoneateTargetBarrelSecond.Position) < BarrelExplosionRange))
                                    {
                                        dontQ = true;
                                        Q.CastOnUnit(detoneateTargetBarrel, getCheckBoxItem(config, "packets"));
                                        return;
                                    }
                                }
                            }
                        }

                        if (getSliderItem(comboMenu, "detoneateTargets") > 1)
                        {
                            var enemies =
                                HeroManager.Enemies.Where(e => e.LSIsValidTarget() && e.LSDistance(player) < 600)
                                .Select(e => Prediction.GetPrediction(e, 0.25f));
                            var enemies2 =
                                HeroManager.Enemies.Where(e => e.LSIsValidTarget() && e.LSDistance(player) < 600)
                                .Select(e => Prediction.GetPrediction(e, 0.35f));
                            if (detoneateTargetBarrels.Any())
                            {
                                foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
                                {
                                    if (!KillableBarrel(detoneateTargetBarrel))
                                    {
                                        continue;
                                    }
                                    var enemyCount =
                                        enemies.Count(
                                            e =>
                                            e.UnitPosition.LSDistance(detoneateTargetBarrel.Position) <
                                            BarrelExplosionRange);
                                    if (enemyCount >= getSliderItem(comboMenu, "detoneateTargets") &&
                                        detoneateTargetBarrel.CountEnemiesInRange(BarrelExplosionRange) >=
                                        getSliderItem(comboMenu, "detoneateTargets"))
                                    {
                                        dontQ = true;
                                        Q.CastOnUnit(detoneateTargetBarrel, getCheckBoxItem(config, "packets"));
                                        return;
                                    }
                                    var detoneateTargetBarrelSeconds =
                                        barrels.Where(b => b.LSDistance(detoneateTargetBarrel) < BarrelConnectionRange);
                                    if (detoneateTargetBarrelSeconds.Any())
                                    {
                                        if (detoneateTargetBarrelSeconds.Any(detoneateTargetBarrelSecond => enemyCount +
                                                                             enemies2.Count(
                                                                                 e =>
                                                                                 e.UnitPosition.LSDistance(detoneateTargetBarrelSecond.Position) <
                                                                                 BarrelExplosionRange) >=
                                                                             getSliderItem(comboMenu, "detoneateTargets") &&
                                                                             detoneateTargetBarrelSecond.CountEnemiesInRange(BarrelExplosionRange) >=
                                                                             getSliderItem(comboMenu, "detoneateTargets")))
                                        {
                                            dontQ = true;
                                            Q.CastOnUnit(
                                                detoneateTargetBarrel, getCheckBoxItem(config, "packets"));
                                            return;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if (getCheckBoxItem(comboMenu, "useeAlways") && E.IsReady() && player.LSDistance(target) < E.Range &&
                    !justE && target.Health > Q.GetDamage(target) + player.GetAutoAttackDamage(target) &&
                    getSliderItem(comboMenu, "eStacksC") < E.Instance.Ammo)
                {
                    CastE(target, barrels);
                }
                var Qbarrels = GetBarrels().FirstOrDefault(o => o.LSDistance(player) < Q.Range);
                if (Qbarrels != null && E.Instance.Ammo > 0 && Q.IsReady() && getCheckBoxItem(comboMenu, "usee") &&
                    target.Health > Q.GetDamage(target))
                {
                    dontQ = true;
                }
                if (getCheckBoxItem(comboMenu, "useq") && Q.CanCast(target) && !justE &&
                    !dontQ)
                {
                    CastQonHero(target, barrels);
                }
            }
        }
示例#30
0
        private static void Game_OnGameUpdate(EventArgs args)
        {
            Orbwalker.DisableMovement  = false;
            Orbwalker.DisableAttacking = false;

            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
            {
                Combo();
            }

            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
            {
                Harass();
            }

            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) ||
                Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
            {
                Clear();
            }

            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit))
            {
                if (getCheckBoxItem(harassMenu, "useqLHH") && !justE)
                {
                    Lasthit();
                }
            }

            if (getCheckBoxItem(miscMenu, "AutoW"))
            {
                CleanserManager();
            }

            if (getCheckBoxItem(miscMenu, "AutoR") && R.IsReady())
            {
                foreach (
                    var enemy in
                    HeroManager.Enemies.Where(
                        e =>
                        ((e.UnderTurret(true) &&
                          e.MaxHealth / 100 * getSliderItem(miscMenu, "Rhealt") * 0.75f >
                          e.Health - IncDamages.GetEnemyData(e.NetworkId).DamageTaken) ||
                         (!e.UnderTurret(true) &&
                          e.MaxHealth / 100 * getSliderItem(miscMenu, "Rhealt") >
                          e.Health - IncDamages.GetEnemyData(e.NetworkId).DamageTaken)) &&
                        e.HealthPercent > getSliderItem(miscMenu, "RhealtMin") && e.LSIsValidTarget() &&
                        e.LSDistance(player) > 1500))
                {
                    var pred = IncDamages.GetEnemyData(enemy.NetworkId);
                    if (pred != null && pred.DamageTaken < enemy.Health)
                    {
                        var ally =
                            HeroManager.Allies.OrderBy(a => a.Health).FirstOrDefault(a => enemy.LSDistance(a) < 1000);
                        if (ally != null)
                        {
                            var pos = Prediction.GetPrediction(enemy, 0.75f);
                            if (pos.CastPosition.LSDistance(enemy.Position) < 450 && pos.Hitchance >= HitChance.VeryHigh)
                            {
                                if (enemy.IsMoving)
                                {
                                    R.Cast(enemy.Position.LSExtend(pos.CastPosition, 450));
                                }
                                else
                                {
                                    R.Cast(enemy.ServerPosition);
                                }
                            }
                        }
                    }
                }
            }
            if (getKeyBindItem(comboMenu, "EQtoCursor") && E.IsReady() && Q.IsReady())
            {
                Orbwalker.DisableMovement = true;
                var barrel =
                    GetBarrels()
                    .Where(
                        o =>
                        o.IsValid && !o.IsDead && o.LSDistance(player) < Q.Range &&
                        o.BaseSkinName == "GangplankBarrel" && o.GetBuff("gangplankebarrellife").Caster.IsMe&&
                        KillableBarrel(o))
                    .OrderBy(o => o.LSDistance(Game.CursorPos))
                    .FirstOrDefault();
                if (barrel != null)
                {
                    var cp        = Game.CursorPos;
                    var cursorPos = barrel.LSDistance(cp) > BarrelConnectionRange
                        ? barrel.Position.LSExtend(cp, BarrelConnectionRange)
                        : cp;

                    var points =
                        CombatHelper.PointsAroundTheTarget(player.Position, E.Range - 200)
                        .Where(p => p.LSDistance(player.Position) < E.Range);
                    var middle      = GetMiddleBarrel(barrel, points, cursorPos);
                    var threeBarrel = cursorPos.LSDistance(cp) > BarrelExplosionRange && E.Instance.Ammo >= 2 &&
                                      Game.CursorPos.LSDistance(player.Position) < E.Range && middle.IsValid();
                    var firsDelay = threeBarrel ? 500 : 1;
                    if (cursorPos.IsValid() && cursorPos.LSDistance(player.Position) < E.Range)
                    {
                        E.Cast(threeBarrel ? middle : cursorPos);
                        Utility.DelayAction.Add(firsDelay, () => Q.CastOnUnit(barrel));
                        if (threeBarrel)
                        {
                            if (player.IsMoving)
                            {
                                Player.IssueOrder(GameObjectOrder.Stop, player.Position);
                            }
                            Utility.DelayAction.Add(801, () => E.Cast(middle.LSExtend(cp, BarrelConnectionRange)));
                        }
                        else
                        {
                            Orbwalker.DisableMovement = false;
                            Orbwalker.OrbwalkTo(Game.CursorPos);
                        }
                    }
                    else
                    {
                        Orbwalker.DisableMovement = false;
                        Orbwalker.OrbwalkTo(Game.CursorPos);
                    }
                }
            }
            else if (getKeyBindItem(comboMenu, "EQtoCursor"))
            {
                Orbwalker.DisableMovement = false;
                Orbwalker.OrbwalkTo(Game.CursorPos);
            }
            if (getKeyBindItem(comboMenu, "QbarrelCursor") && Q.IsReady())
            {
                var meleeRangeBarrel =
                    GetBarrels()
                    .OrderBy(o => o.LSDistance(Game.CursorPos))
                    .FirstOrDefault(
                        o =>
                        o.Health > 1 && o.LSDistance(player) < Orbwalking.GetRealAutoAttackRange(o) &&
                        !KillableBarrel(o, true));
                if (meleeRangeBarrel != null && Orbwalker.CanAutoAttack)
                {
                    Orbwalker.DisableAttacking = true;
                    Player.IssueOrder(GameObjectOrder.AttackUnit, meleeRangeBarrel);
                    return;
                }
                var barrel =
                    GetBarrels()
                    .Where(
                        o =>
                        o.IsValid && !o.IsDead && o.LSDistance(player) < Q.Range &&
                        o.BaseSkinName == "GangplankBarrel" && o.GetBuff("gangplankebarrellife").Caster.IsMe&&
                        KillableBarrel(o))
                    .OrderBy(o => o.LSDistance(Game.CursorPos))
                    .FirstOrDefault();
                if (barrel != null)
                {
                    Q.CastOnUnit(barrel);
                }
            }

            if (getCheckBoxItem(miscMenu, "AutoQBarrel") && Q.IsReady())
            {
                var barrel =
                    GetBarrels()
                    .FirstOrDefault(
                        o =>
                        o.IsValid && !o.IsDead && o.LSDistance(player) < Q.Range &&
                        o.BaseSkinName == "GangplankBarrel" && o.GetBuff("gangplankebarrellife").Caster.IsMe&&
                        KillableBarrel(o) &&
                        (o.CountEnemiesInRange(BarrelExplosionRange - 50) > 0 ||
                         HeroManager.Enemies.Count(
                             e =>
                             e.LSIsValidTarget() &&
                             Prediction.GetPrediction(e, 0.1f).UnitPosition.LSDistance(o.Position) <
                             BarrelExplosionRange - 20) > 0));

                if (barrel != null)
                {
                    Q.Cast(barrel);
                }
            }
        }