Example #1
0
        private static void Flee()
        {
            #region flee

            ObjectManager.Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
            if (Player.IsMiniGnar())
            {
                var minionCount = MinionManager.GetMinions(Player.Position, GnarSpells.QMini.Range, MinionTypes.All,
                                                           MinionTeam.All);
                foreach (var minion in minionCount)
                {
                    var minionPrediction = GnarSpells.EMini.GetPrediction(minion);

                    var k =
                        ObjectManager.Get <Obj_AI_Minion>().Where(x => Player.IsFacing(x) &&
                                                                  x.IsMinion &&
                                                                  x.Distance(Player) <= GnarSpells.EMini.Range)
                        .OrderByDescending(x => x.Distance(Player))
                        .First();

                    if (k == null)
                    {
                        return;
                    }
                    var edm = Player.ServerPosition.Extend(minionPrediction.CastPosition,
                                                           Player.ServerPosition.Distance(minionPrediction.CastPosition) + GnarSpells.EMini.Range);
                    if (!ObjectManager.Get <Obj_AI_Turret>().Any(type => type.IsMinion &&
                                                                 !type.IsDead &&
                                                                 type.Distance(edm, true) < 775 * 775))
                    {
                        GnarSpells.EMini.Cast(edm.Extend(Game.CursorPos, Player.ServerPosition.Distance(minionPrediction.CastPosition) + GnarSpells.EMini.Range));
                    }
                }

                /*
                 * var target = TargetSelector.GetTarget(GnarSpells.QMini.Range, TargetSelector.DamageType.Magical);
                 * if (target == null)
                 *  return;
                 * var prediction = GnarSpells.EMini.GetPrediction(target);
                 * var ed = Player.ServerPosition.Extend(prediction.CastPosition,
                 *  Player.ServerPosition.Distance(prediction.CastPosition) + GnarSpells.EMini.Range);
                 *
                 * if (!ObjectManager.Get<Obj_AI_Turret>().Any(type => type.Team != Player.Team
                 *                                                  && !type.IsDead
                 *                                                  && type.Distance(ed, true) < 775 * 775))
                 * {
                 *  GnarSpells.EMini.Cast(prediction.CastPosition);
                 * }
                 */
            }
        }
Example #2
0
        public static void Items()
        {
            var target = TargetSelector.GetTarget(1500f, TargetSelector.DamageType.Physical);

            if (menu.Item("reksai.items.hydra").GetValue <bool>())
            {
                if (LeagueSharp.Common.Items.HasItem(Hydra.Id, Player) &&
                    Hydra.IsReady() &&
                    target.IsValidTarget(Hydra.Range))
                {
                    Hydra.Cast();
                }
                else if (LeagueSharp.Common.Items.HasItem(Tiamat.Id, Player) &&
                         Tiamat.IsReady() &&
                         target.IsValidTarget(Tiamat.Range))
                {
                    Tiamat.Cast();
                }
            }
            if (menu.Item("reksai.items.botrk").GetValue <bool>())
            {
                if (LeagueSharp.Common.Items.HasItem(BotRK.Id, Player) &&
                    BotRK.IsReady() &&
                    target.IsValidTarget(BotRK.Range))
                {
                    BotRK.Cast(target);
                }
                else if (LeagueSharp.Common.Items.HasItem(Cutlass.Id, Player) &&
                         Cutlass.IsReady() &&
                         target.IsValidTarget(Cutlass.Range))
                {
                    Cutlass.Cast(target);
                }
            }
            if (menu.Item("reksai.items.omen").GetValue <bool>())
            {
                if (LeagueSharp.Common.Items.HasItem(Omen.Id, Player) &&
                    Omen.IsReady() &&
                    target.IsValidTarget(Omen.Range))
                {
                    if (Player.IsFacing(target) &&
                        !target.IsFacing(Player) ||
                        !Player.IsFacing(target) &&
                        target.IsFacing(Player))
                    {
                        Omen.Cast();
                    }
                }
            }
        }
Example #3
0
        private static void WLogic(Obj_AI_Hero target)
        {
            if (target == null || target.IsDead || !W.IsReady())
            {
                return;
            }

            if (Menu.GetBool("ComboQW") && qStack != 0)
            {
                W.Cast(true);
            }

            if (!Q.IsReady() && qStack == 0)
            {
                W.Cast(true);
            }

            if (Menu.GetBool("ComboEW") && Me.HasBuff("RivenFeint"))
            {
                W.Cast(true);
            }

            if (!target.IsFacing(Me))
            {
                W.Cast(true);
            }
        }
Example #4
0
 private static void MockingShout()
 {
     if (W.IsReady() && !target.IsFacing(Player))
     {
         W.Cast();
     }
 }
Example #5
0
        internal static bool CanE(Obj_AI_Hero target)
        {
            if (Config.Item("eeee").GetValue <StringList>().SelectedIndex == 0)
            {
                return(true);
            }

            var t = KL.TurretCache.Values.FirstOrDefault(x => x.IsEnemy && x.Distance(KL.Player.ServerPosition) <= 1500);

            if (t == null || t.IsDead || !t.IsValid)
            {
                return(true);
            }

            if (KL.Player.Distance(t) <= 1200 && target.Distance(t) <= 1200)
            {
                if (target.Distance(t) > KL.Player.Distance(t))
                {
                    if (target.IsFacing(t))
                    {
                        return(false);
                    }
                }
            }

            return(true);
        }
Example #6
0
        public static Vector3 PredEx(Obj_AI_Hero player, float delay) //creds to JustinT
        {
            float va = 0f;

            if (player.IsFacing(Player))
            {
                va = (50f - player.BoundingRadius);
            }
            else
            {
                va = -(100f - player.BoundingRadius);
            }
            var dis  = delay * player.MoveSpeed + va;
            var path = player.GetWaypoints();

            for (var i = 0; i < path.Count - 1; i++)
            {
                var a = path[i];
                var b = path[i + 1];
                var d = a.Distance(b);

                if (d < dis)
                {
                    dis -= d;
                }
                else
                {
                    return((a + dis * (b - a).Normalized()).To3D());
                }
            }
            return((path[path.Count - 1]).To3D());
        }
Example #7
0
        private static void Mixed()
        {
            var         qSpell   = Config.Item("UseQH").GetValue <bool>();
            var         qrSpell  = Config.Item("UseQrh").GetValue <bool>();
            Obj_AI_Hero target   = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);
            var         minionsQ = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, Q.Range);
            var         qHit     = Q.GetLineFarmLocation(minionsQ, 100);

            if (qSpell &&
                !qrSpell &&
                Q.IsReady() &&
                qHit.MinionsHit <= 4 &&
                target.IsValidTarget(Q.Range))
            {
                Q.Cast(target);
            }
            if (qSpell &&
                qrSpell &&
                Q.IsReady() &&
                Player.Distance(target) > 800 &&
                qHit.MinionsHit <= 4 &&
                target.HealthPercent < Player.HealthPercent &&
                target.IsFacing(Player) &&
                Player.CountEnemiesInRange(1000) == 1 &&
                target.IsValidTarget(Q.Range))
            {
                Q.Cast(target);
            }
        }
Example #8
0
        public static Vector3 PreCastPos(Obj_AI_Hero Hero, float Delay, float Range, float varRange)
        {
            float value = 0f;

            if (Hero.IsFacing(Player))
            {
                value = (Range - varRange - Hero.BoundingRadius);
            }
            else
            {
                value = (Range - varRange - Hero.BoundingRadius);
            }
            var distance = Delay * Hero.MoveSpeed + value;
            var path     = Hero.GetWaypoints();

            for (var i = 0; i < path.Count - 1; i++)
            {
                var a = path[i];
                var b = path[i + 1];
                var d = a.Distance(b);

                if (d < distance)
                {
                    distance -= d;
                }
                else
                {
                    return((a + distance * (b - a).Normalized()).To3D());
                }
            }


            return((path[path.Count - 1]).To3D());
        }
Example #9
0
        public static Vector3 GetTumblePos(this Obj_AI_Hero target)
        {
            //if the target is not a melee and he's alone he's not really a danger to us, proceed to 1v1 him :^ )
            if (!target.IsMelee && Heroes.Player.CountEnemiesInRange(800) == 1)
            {
                return(Game.CursorPos);
            }

            var flash         = Program.Flash;
            var flashedAtTick = Program.FlashTime;

            if (!flash.IsReady())
            {
                if (Environment.TickCount - flashedAtTick < 500)
                {
                    return(Vector3.Zero);
                }
            }

            var aRC   = new Geometry.Circle(Heroes.Player.ServerPosition.To2D(), 300).ToPolygon().ToClipperPath();
            var cP    = Game.CursorPos;
            var tP    = target.ServerPosition;
            var pList = new List <Vector3>();
            var additionalDistance = (0.106 + Game.Ping / 2000f) * target.MoveSpeed;

            if ((!cP.IsWall() && !cP.UnderTurret(true) && cP.Distance(tP) > 325 && cP.Distance(tP) < 550 &&
                 (cP.CountEnemiesInRange(425) <= cP.CountAlliesInRange(325))))
            {
                return(cP);
            }

            foreach (var p in aRC)
            {
                var v3 = new Vector2(p.X, p.Y).To3D();

                if (target.IsFacing(Heroes.Player))
                {
                    if (!v3.IsWall() && !v3.UnderTurret(true) && v3.Distance(tP) > 325 && v3.Distance(tP) < 550 &&
                        (v3.CountEnemiesInRange(425) <= v3.CountAlliesInRange(325)))
                    {
                        pList.Add(v3);
                    }
                }
                else
                {
                    if (!v3.IsWall() && !v3.UnderTurret(true) && v3.Distance(tP) > 325 &&
                        v3.Distance(tP) < (550 - additionalDistance) &&
                        (v3.CountEnemiesInRange(425) <= v3.CountAlliesInRange(325)))
                    {
                        pList.Add(v3);
                    }
                }
            }
            if (Heroes.Player.UnderTurret() || Heroes.Player.CountEnemiesInRange(800) == 1)
            {
                return(pList.Count > 1 ? pList.OrderBy(el => el.Distance(cP)).FirstOrDefault() : Vector3.Zero);
            }
            return(pList.Count > 1 ? pList.OrderByDescending(el => el.Distance(tP)).FirstOrDefault() : Vector3.Zero);
        }
Example #10
0
        private static void OnDoCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs Args)
        {
            if (sender.IsMe && !IsHumanizer && Orbwalking.IsAutoAttack(Args.SData.Name))
            {
                switch (Orbwalker.ActiveMode)
                {
                case Orbwalking.OrbwalkingMode.Combo:
                    var hero = (Obj_AI_Hero)Args.Target;

                    if (hero != null)
                    {
                        if (Menu.Item("ComboECougar", true).GetValue <bool>() && E.Level > 0 && E1Cd == 0 &&
                            hero.IsValidTarget(E1.Range) && Me.IsFacing(hero))
                        {
                            E1.Cast(hero.Position, true);
                        }
                        else if (Menu.Item("ComboQCougar", true).GetValue <bool>() && Q.Level > 0 && Q1Cd == 0 &&
                                 hero.IsValidTarget(Q1.Range))
                        {
                            Q1.Cast(hero);
                        }
                    }
                    break;

                case Orbwalking.OrbwalkingMode.LaneClear:
                    var mob  = (Obj_AI_Base)Args.Target;
                    var mobs = MinionManager.GetMinions(Me.Position, Q1.Range, MinionTypes.All, MinionTeam.Neutral,
                                                        MinionOrderTypes.MaxHealth);

                    if (mob != null && mobs.Contains(mob))
                    {
                        if (Menu.Item("JungleClearECougar", true).GetValue <bool>() && E1Cd == 0 &&
                            mob.IsValidTarget(E1.Range) && Me.IsFacing(mob))
                        {
                            E1.Cast(mob.Position, true);
                        }
                        else if (Menu.Item("JungleClearQCougar", true).GetValue <bool>() && Q.Level > 0 && Q1Cd == 0 &&
                                 mob.IsValidTarget(Q1.Range))
                        {
                            Q1.Cast(mob);
                        }
                    }
                    break;
                }
            }
        }
Example #11
0
        public static void Combo()
        {
            var target = TargetSelector.GetTarget(900f, TargetSelector.DamageType.Magical);

            if (!target.IsValidTarget())
            {
                return;
            }
            if (Z.Item("combo.q").GetValue <bool>())
            {
                if ((target.Health + 50 < Q.GetDamage(target) && Q.IsReady())
                    ||
                    (!target.HasBuffOfType(BuffType.Poison) && E.IsInRange(target) && E.IsReady() && Q.IsReady() &&
                     Player.Mana >= Q.Instance.ManaCost + 2 * E.Instance.ManaCost) ||
                    (!target.HasBuffOfType(BuffType.Poison) && E.Level < 1 && Q.IsReady() && Q.IsInRange(target))
                    ||
                    (Q.IsReady() && E.IsReady() && E.IsInRange(target) &&
                     target.Health + 25 < Q.GetDamage(target) + E.GetDamage(target) &&
                     Player.Mana >= Q.Instance.ManaCost + E.Instance.ManaCost))
                {
                    Q.Cast(target);
                }
            }
            if (Z.Item("combo.w").GetValue <bool>())
            {
                if ((Player.HealthPercent <= 25 && !Player.IsFacing(target) && target.IsFacing(Player) &&
                     target.IsValidTarget((W.Range / 3) * 2) && W.IsReady() && target.MoveSpeed >= Player.MoveSpeed)
                    ||
                    (!target.HasBuffOfType(BuffType.Poison) && Q.Delay * 1000 + LastQ < Environment.TickCount &&
                     !Q.IsReady() && W.IsReady() && E.IsReady() && E.IsInRange(target) &&
                     Player.Mana >= W.Instance.ManaCost + 2 * E.Instance.ManaCost)
                    ||
                    (!target.HasBuffOfType(BuffType.Poison) && Q.Delay * 1000 + LastQ < Environment.TickCount &&
                     !Q.IsReady() && W.IsReady() && E.IsReady() && E.IsInRange(target) &&
                     Player.Mana >= W.Instance.ManaCost + E.Instance.ManaCost &&
                     W.GetDamage(target) + E.GetDamage(target) > target.Health + 25)
                    ||
                    (!target.HasBuffOfType(BuffType.Poison) && Q.Delay * 1000 + LastQ < Environment.TickCount &&
                     (!Q.IsReady() || Q.GetDamage(target) < target.Health + 25) && W.IsReady() && W.IsInRange(target) &&
                     W.GetDamage(target) > target.Health + 25))
                {
                    W.Cast(target);
                }
            }
            if (Z.Item("combo.e").GetValue <bool>())
            {
                if ((target.HasBuffOfType(BuffType.Poison) && E.IsReady() && target.IsValidTarget(E.Range) &&
                     Environment.TickCount > LastE + Z.Item("misc.edelay").GetValue <Slider>().Value) ||
                    (E.IsReady() && target.IsValidTarget(E.Range) && target.Health + 25 < E.GetDamage(target)))
                {
                    E.CastOnUnit(target);
                }
            }

            EasyRLogic();
            SmartR();
        }
Example #12
0
        private static void Combo()
        {
            var vTarget = SimpleTs.GetTarget(E.Range, SimpleTs.DamageType.Physical);

            if (!IsValorMode() && R.IsReady() && vTarget.Distance(Player) <= E.Range + 200 && CountEnemies(vTarget.Position) < 3 && Config.Item("UseR").GetValue <bool>())
            {
                R.Cast(true);
            }

            if (!IsValorMode())
            {
                if (Config.Item("UseE").GetValue <bool>() && E.IsReady() && CountEnemies(vTarget.Position) < 3)
                {
                    if (Config.Item("Double").GetValue <bool>())
                    {
                        if (!vTarget.HasBuff("QuinnW"))
                        {
                            E.CastOnUnit(vTarget, true);
                        }
                    }
                    else
                    {
                        E.CastOnUnit(vTarget, true);
                    }
                }
                if (Q.IsReady() && Config.Item("UseQ").GetValue <bool>())
                {
                    Q.Cast(vTarget, true);
                }
            }
            else // if IN valor mode do this
            {
                if (Config.Item("UseER").GetValue <bool>()) // will use E BEFORE R to return to human form
                {
                    E.CastOnUnit(vTarget, true);
                    if (Player.Distance(vTarget) <= 200)
                    {
                        Q.Cast();
                        R.Cast(true);
                    }
                }
                else if (Config.Item("UseE").GetValue <bool>() && E.IsReady())
                {
                    E.CastOnUnit(vTarget);
                }

                if (Player.Distance(vTarget) <= 350 && Config.Item("UseQ").GetValue <bool>() && Q.IsReady())
                {
                    Q.Cast(true);
                }

                if (!E.IsReady() && !Q.IsReady() && Player.IsFacing(vTarget) && vTarget.IsFacing(Player) && R.IsReady() && Config.Item("cooldown").GetValue <bool>()) //is facing just so you wont cancel valor if you are trying to run away :S
                {
                    R.Cast();
                }
            }
        }
Example #13
0
        /// <summary>
        ///     Called when there is an interruptible target.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="args">The <see cref="Interrupter2.InterruptableTargetEventArgs" /> instance containing the event data.</param>
        private void OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            if (!Config.Instance["Interrupter"] || !sender.IsFacing(this.Player) || !sender.IsValidTarget(this.R.Range))
            {
                return;
            }

            this.R.Cast(sender);
        }
Example #14
0
        private void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            var Rint = MenuProvider.Champion.Misc.getBoolValue("UseInterrupter");

            if (!MenuProvider.Champion.Misc.getBoolValue("UseInterrupter") || Player.IsDead)
                return;

            if (Rint && args.DangerLevel >= Interrupter2.DangerLevel.High && sender.IsValidTarget(R.Range) && sender.IsFacing(Player))
                R.CastOnBestTarget(0f, false, true);
        }
Example #15
0
        protected override void Interrupter_OnPosibleToInterrupt(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs spell)
        {
            if (!Menu.Item("UseInt", true).GetValue <bool>())
            {
                return;
            }

            if (sender.IsValidTarget())
            {
                if (Player.Distance(sender) <= R.Range && sender.IsFacing(Player))
                {
                    var pred = R.GetPrediction(sender);
                    if (pred.Hitchance >= HitChance.VeryHigh && sender.IsFacing(Player))
                    {
                        R.Cast(pred.CastPosition);
                    }
                }
            }
        }
Example #16
0
 void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (MenuHelper.isMenuEnabled("dzaio.cassiopeia.misc.antigp") && _spells[SpellSlot.R].IsReady())
     {
         if (args.DangerLevel >= Interrupter2.DangerLevel.High && sender.IsFacing(ObjectManager.Player))
         {
             _spells[SpellSlot.R].CastIfHitchanceEquals(sender, MenuHelper.GetHitchance());
         }
     }
 }
Example #17
0
        public static float MsBonus(Obj_AI_Hero target)
        {
            float msBonus = 1f;

            if (Q.IsReady() && !QEnabled)
            {
                if (
                    ObjectManager.Get <Obj_AI_Hero>()
                    .FirstOrDefault(h => h.IsEnemy && player.Distance(h) < 2000 && player.IsFacing(h)) != null)
                {
                    msBonus += MsBuff[Q.Level - 1];
                }
                else
                {
                    msBonus += 0.15f;
                }
            }
            return(msBonus);
        }
Example #18
0
 private static void castR(Obj_AI_Hero target)
 {
     if (Config.Item("hitchanceR").GetValue <bool>() && !target.IsFacing(ObjectManager.Player))
     {
         CastSpell(R, target, 3);
     }
     else
     {
         R.Cast(target, true);
     }
 }
Example #19
0
 public static void Insec(Obj_AI_Hero target)
 {
     Rpos = Player.Position.To2D().Extend(target.Position.To2D(), Player.Distance(target) + 250);
     if (Rpos.Distance(Player.Position) <= R.Range)
     {
         if (Player.Distance(Rpos.Extend(target.Position.To2D(), 700 - target.Distance(Rpos))) < E.Range && !IsWall(Rpos.To3D()) && target.IsFacing(Player))
         {
             R.Cast(Rpos);
         }
     }
 }
Example #20
0
        static void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            if (!AIO_Menu.Champion.Misc.UseInterrupter || Player.IsDead)
            {
                return;
            }

            if (R.CanCast(sender) && sender.IsFacing(Player))
            {
                R.Cast(sender);
            }
        }
Example #21
0
        /// <summary>
        ///     Called on interruptable spell.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="args">The <see cref="Interrupter2.InterruptableTargetEventArgs" /> instance containing the event data.</param>
        public static void OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            if (ObjectManager.Player.IsDead
                || TargetSelector.IsInvulnerable(sender, TargetSelector.DamageType.Magical, false))
            {
                return;
            }

            if (Variables.R.IsReady() && sender.IsValidTarget(Variables.R.Range)
                && sender.IsFacing(ObjectManager.Player) && Variables.RMenu.Item("interrupter").IsActive())
            {
                Variables.R.Cast(sender.ServerPosition);
            }
        }
Example #22
0
        public static bool IsRunningAway(this Obj_AI_Hero target)
        {
            var runningDirection = (target.Position.ToVector2() +
                                    200 * target.Direction.Perpendicular().ToVector2()).ToVector3();

            if (ObjectManager.Player.ServerPosition.DistanceSquared(runningDirection) >
                ObjectManager.Player.ServerPosition.DistanceSquared(target.ServerPosition) &&
                target.ServerPosition.DistanceSquared(runningDirection) > 200 * 200 &&
                !target.IsFacing(ObjectManager.Player))
            {
                return(true);
            }
            return(false);
        }
Example #23
0
 private void OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     try
     {
         if (sender.IsEnemy && args.DangerLevel == Interrupter2.DangerLevel.High &&
             Ultimate.IsActive(UltimateModeType.Interrupt, sender) && sender.IsFacing(Player))
         {
             Casting.SkillShot(sender, R, HitChance.High);
         }
     }
     catch (Exception ex)
     {
         Global.Logger.AddItem(new LogItem(ex));
     }
 }
Example #24
0
        private float CalcComboDamage(Obj_AI_Hero target, bool q, bool w, bool e, bool r)
        {
            try
            {
                if (target == null)
                {
                    return(0);
                }
                var manaCost = (w && W.IsReady() ? W.Instance.ManaCost : (q ? Q.Instance.ManaCost : 0)) * 2;
                var damage   = (w && W.IsReady() ? W.GetDamage(target) : (q ? Q.GetDamage(target) : 0)) * 2;

                if (e)
                {
                    var eMana   = E.Instance.ManaCost;
                    var eDamage = E.GetDamage(target);
                    var count   = target.IsNearTurret() && !target.IsFacing(Player) ||
                                  target.IsNearTurret() && Player.HealthPercent <= 35 || !R.IsReady()
                        ? 5
                        : 10;
                    for (var i = 0; i < count; i++)
                    {
                        if (manaCost + eMana > Player.Mana)
                        {
                            break;
                        }
                        manaCost += eMana;
                        damage   += eDamage;
                    }
                }
                if (r)
                {
                    if (manaCost + R.Instance.ManaCost - 10 > Player.Mana)
                    {
                        return(damage);
                    }
                    return(damage + (R.IsReady() ? R.GetDamage(target) : 0));
                }
                damage += ItemManager.CalculateComboDamage(target);
                damage += SummonerManager.CalculateComboDamage(target);
                return(damage);
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
            return(0);
        }
Example #25
0
 static void OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (Player.IsDead)
     {
         return;
     }
     if (sender.IsValidTarget())
     {
         if (CassioUtils.Active("Interrupter.UseR") && Vector3.Distance(sender.ServerPosition, Player.ServerPosition) <= Spells[SpellSlot.R].Range && sender.IsFacing(Player))
         {
             var pred = Spells[SpellSlot.R].GetPrediction(sender);
             if (pred.Hitchance >= HitChance.VeryHigh && sender.IsFacing(Player))
             {
                 Spells[SpellSlot.R].Cast(pred.CastPosition);
             }
         }
     }
 }
Example #26
0
        public static bool CastQ(Obj_AI_Hero target)
        {
            var qPrediction = Q.GetPrediction(target);

            if (qPrediction.Hitchance < HitChance.VeryHigh)
            {
                return(false);
            }

            if (EIsReady)
            {
                var directTravelTime = BallManager.BallPosition.Distance(qPrediction.CastPosition) / Q.Speed;
                var bestEQTravelTime = float.MaxValue;

                Obj_AI_Hero eqTarget = null;

                foreach (var ally in HeroManager.Allies.Where(h => h.IsValidTarget(E.Range, false)))
                {
                    var t = BallManager.BallPosition.Distance(ally.ServerPosition) / E.Speed + ally.Distance(qPrediction.CastPosition) / Q.Speed;
                    if (t < bestEQTravelTime)
                    {
                        eqTarget         = ally;
                        bestEQTravelTime = t;
                    }
                }

                if (eqTarget != null && bestEQTravelTime < directTravelTime * 1.3f && (BallManager.BallPosition.Distance(eqTarget.ServerPosition, true) > 10000))
                {
                    E.CastOnUnit(eqTarget, true);
                    return(true);
                }
            }

            if (!target.IsFacing(Player) && target.Path.Count() >= 1) // target is running
            {
                var targetBehind = Q.GetPrediction(target).CastPosition +
                                   Vector3.Normalize(target.ServerPosition - BallManager.BallPosition) * target.MoveSpeed / 2;
                Q.Cast(targetBehind, true);
                return(true);
            }

            Q.Cast(qPrediction.CastPosition, true);
            return(true);
        }
Example #27
0
        public static Vector3 GetTumblePos(this Obj_AI_Hero target)
        {
            //if the target is not a melee and he's alone he's not really a danger to us, proceed to 1v1 him :^ )
            if (!target.IsMelee && Heroes.Player.CountEnemiesInRange(800) == 1)
            {
                return(Game.CursorPos);
            }

            var aRC                = new Geometry.Circle(Heroes.Player.ServerPosition.To2D(), 300).ToPolygon().ToClipperPath();
            var cursorPos          = Game.CursorPos;
            var targetPosition     = target.ServerPosition;
            var pList              = new List <Vector3>();
            var additionalDistance = (0.106 + Game.Ping / 2000f) * target.MoveSpeed;

            if (!cursorPos.IsDangerousPosition())
            {
                return(cursorPos);
            }

            foreach (var p in aRC)
            {
                var v3 = new Vector2(p.X, p.Y).To3D();

                if (target.IsFacing(Heroes.Player))
                {
                    if (!v3.IsDangerousPosition() && v3.Distance(targetPosition) < 550)
                    {
                        pList.Add(v3);
                    }
                }
                else
                {
                    if (!v3.IsDangerousPosition() && v3.Distance(targetPosition) < 550 - additionalDistance)
                    {
                        pList.Add(v3);
                    }
                }
            }
            if (Heroes.Player.UnderTurret() || Heroes.Player.CountEnemiesInRange(800) == 1)
            {
                return(pList.Count > 1 ? pList.OrderBy(el => el.Distance(cursorPos)).FirstOrDefault() : Vector3.Zero);
            }
            return(pList.Count > 1 ? pList.OrderByDescending(el => el.Distance(cursorPos)).FirstOrDefault() : Vector3.Zero);
        }
Example #28
0
        public static void Combo()
        {
            if (!CanKillTarget() && Target != null)
            {
                if (Q.IsReady() && W.IsReady() && E.IsReady() && R.IsReady() &&
                    Config.Item("combo.r").GetValue <bool>() &&
                    Target != null &&
                    Player.CountEnemiesInRange(Q.Range) >= Config.Item("combo.r.count").GetValue <Slider>().Value)
                {
                    R.Cast();
                }

                if (W.IsReady() &&
                    W.IsInRange(Target) &&
                    Config.Item("combo.w").GetValue <bool>())
                {
                    if (W.GetDamage(Target) > Target.Health + 50 ||
                        !Target.IsFacing(Player) ||
                        (Q.IsReady() && E.IsReady()))
                    {
                        W.Cast(Target);
                    }
                }

                if (Q.IsReady() &&
                    Target != null &&
                    Config.Item("combo.q").GetValue <bool>())
                {
                    Q.CastIfHitchanceEquals(Target, QHC);
                    Q.CastIfHitchanceEquals(Target, HitChance.Immobile);
                }


                if (E.IsReady() &&
                    E.IsInRange(Target) &&
                    Config.Item("combo.e").GetValue <bool>())
                {
                    E.CastOnUnit(Target);
                }
            }
        }
Example #29
0
 public static void OnEnemyGapcloser(ActiveGapcloser gapcloser)
 {
     Game.PrintChat("1"); //debugging
     if (Player.Distance(gapcloser.End) <= 200)
     {
         if (Player.IsFacing(gapcloser.Sender))
         {
             Game.PrintChat("2"); //debugging
             _W.Cast(true);
             _R.Cast(gapcloser.End, true);
         }
         else
         {
             Game.PrintChat("3"); //debugging
             _R.Cast(Player.Position + (Player.Direction * 150), true);
         }
     }
     if (Player.Distance(gapcloser.End) <= 600)
     {
         Game.PrintChat("4"); //debugging
         _R.Cast(Player.Position + (Player.Direction * 150), true);
     }
 }
Example #30
0
 private static void OnPossibleToInterrupt(Obj_AI_Hero unit, InterruptableSpell spell)
 {
     if (Player.IsDead || !GetValue <bool>("Interrupt", "EQ") ||
         !GetValue <bool>("Interrupt", unit.ChampionName + "_" + spell.Slot) || !Q.IsReady())
     {
         return;
     }
     if (E.CanCast(unit) && Player.Mana >= Q.Instance.ManaCost + E.Instance.ManaCost)
     {
         var predE = E.GetPrediction(unit);
         if (predE.Hitchance >= E.MinHitChance &&
             E.Cast(
                 predE.UnitPosition.Extend(Player.ServerPosition, -E.Width / (unit.IsFacing(Player) ? 2 : 1)),
                 PacketCast) && Q.Cast(predE.UnitPosition, PacketCast))
         {
             return;
         }
     }
     foreach (var flag in
              Flag.Where(i => Q2.WillHit(unit, i.ServerPosition)))
     {
         Q.Cast(flag.ServerPosition, PacketCast);
     }
 }
Example #31
0
        private static void CastSpell(Spell QWER, Obj_AI_Hero target, int HitChanceNum)
        {
            //HitChance 0 - 2
            // example CastSpell(Q, ts, 2);
            var poutput = QWER.GetPrediction(target);
            var col     = poutput.CollisionObjects.Count(ColObj => ColObj.IsEnemy && ColObj.IsMinion && !ColObj.IsDead);

            if (QWER.Collision && col > 0)
            {
                return;
            }
            if (HitChanceNum == 0)
            {
                QWER.Cast(target, true);
            }
            else if (HitChanceNum == 1)
            {
                if ((int)poutput.Hitchance > 4)
                {
                    QWER.Cast(poutput.CastPosition);
                }
            }
            else if (HitChanceNum == 2)
            {
                if ((target.IsFacing(ObjectManager.Player) && (int)poutput.Hitchance == 5) || (target.Path.Count() == 0 && target.Position == target.ServerPosition))
                {
                    if (ObjectManager.Player.Distance(target.Position) < QWER.Range - ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.Position) / QWER.Speed) + (target.BoundingRadius * 2)))
                    {
                        QWER.Cast(poutput.CastPosition);
                    }
                }
                else if ((int)poutput.Hitchance == 5)
                {
                    QWER.Cast(poutput.CastPosition);
                }
            }
            else if (HitChanceNum == 3)
            {
                List <Vector2> waypoints   = target.GetWaypoints();
                float          SiteToSite  = ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.ServerPosition) / QWER.Speed)) * 6 - QWER.Width;
                float          BackToFront = ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.ServerPosition) / QWER.Speed));
                if (ObjectManager.Player.Distance(waypoints.Last <Vector2>().To3D()) < SiteToSite || ObjectManager.Player.Distance(target.Position) < SiteToSite)
                {
                    QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                }
                else if (target.Path.Count() < 2 &&
                         (target.ServerPosition.Distance(waypoints.Last <Vector2>().To3D()) > SiteToSite ||
                          Math.Abs(ObjectManager.Player.Distance(waypoints.Last <Vector2>().To3D()) - ObjectManager.Player.Distance(target.Position)) > BackToFront ||
                          target.HasBuffOfType(BuffType.Slow) || target.HasBuff("Recall") ||
                          (target.Path.Count() == 0 && target.Position == target.ServerPosition)
                         ))
                {
                    if (target.IsFacing(ObjectManager.Player) || target.Path.Count() == 0)
                    {
                        if (ObjectManager.Player.Distance(target.Position) < QWER.Range - ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.Position) / QWER.Speed) + (target.BoundingRadius * 2)))
                        {
                            QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                        }
                    }
                    else
                    {
                        QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                    }
                }
            }
            else if (HitChanceNum == 4 && (int)poutput.Hitchance > 4)
            {
                List <Vector2> waypoints   = target.GetWaypoints();
                float          SiteToSite  = ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.ServerPosition) / QWER.Speed)) * 6 - QWER.Width;
                float          BackToFront = ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.ServerPosition) / QWER.Speed));
                if (ObjectManager.Player.Distance(waypoints.Last <Vector2>().To3D()) < SiteToSite || ObjectManager.Player.Distance(target.Position) < SiteToSite)
                {
                    QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                }
                else if (target.Path.Count() < 2 &&
                         (target.ServerPosition.Distance(waypoints.Last <Vector2>().To3D()) > SiteToSite ||
                          Math.Abs(ObjectManager.Player.Distance(waypoints.Last <Vector2>().To3D()) - ObjectManager.Player.Distance(target.Position)) > BackToFront ||
                          target.HasBuffOfType(BuffType.Slow) || target.HasBuff("Recall") ||
                          (target.Path.Count() == 0 && target.Position == target.ServerPosition)
                         ))
                {
                    if (target.IsFacing(ObjectManager.Player) || target.Path.Count() == 0)
                    {
                        if (ObjectManager.Player.Distance(target.Position) < QWER.Range - ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.Position) / QWER.Speed) + (target.BoundingRadius * 2)))
                        {
                            QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                        }
                    }
                    else
                    {
                        QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                    }
                }
            }
        }
Example #32
0
 public static bool IsRunningAway(this Obj_AI_Hero target)
 {
     return(ObjectManager.Player.Distance(target.GetPositionInFront(300)) >
            ObjectManager.Player.Distance(target.ServerPosition) && !target.IsFacing(ObjectManager.Player));
 }
Example #33
0
 private static void OnPossibleToInterrupt(Obj_AI_Hero unit, InterruptableSpell spell)
 {
     if (Player.IsDead || !GetValue<bool>("Interrupt", "EQ") ||
         !GetValue<bool>("Interrupt", unit.ChampionName + "_" + spell.Slot) || !Q.IsReady())
     {
         return;
     }
     if (E.CanCast(unit) && Player.Mana >= Q.Instance.ManaCost + E.Instance.ManaCost)
     {
         var predE = E.GetPrediction(unit);
         if (predE.Hitchance >= E.MinHitChance &&
             E.Cast(
                 predE.UnitPosition.Extend(Player.ServerPosition, -E.Width / (unit.IsFacing(Player) ? 2 : 1)),
                 PacketCast) && Q.Cast(predE.UnitPosition, PacketCast))
         {
             return;
         }
     }
     foreach (var flag in
         Flag.Where(i => Q2.WillHit(unit, i.ServerPosition)))
     {
         Q.Cast(flag.ServerPosition, PacketCast);
     }
 }
Example #34
0
        private static void CastSpell(Spell QWER, Obj_AI_Hero target, int HitChanceNum)
        {
            //HitChance 0 - 2
            // example CastSpell(Q, ts, 2);
            if (HitChanceNum == 0)
                QWER.Cast(target, true);
            else if (HitChanceNum == 1)
                QWER.CastIfHitchanceEquals(target, HitChance.VeryHigh, true);
            else if (HitChanceNum == 2)
            {
                if (QWER.Delay < 0.3)
                    QWER.CastIfHitchanceEquals(target, HitChance.Dashing, true);
                QWER.CastIfHitchanceEquals(target, HitChance.Immobile, true);
                QWER.CastIfWillHit(target, 2, true);
                if (target.Path.Count() < 2)
                    QWER.CastIfHitchanceEquals(target, HitChance.VeryHigh, true);
            }
            else if (HitChanceNum == 3)
            {
                List<Vector2> waypoints = target.GetWaypoints();
                //debug("" + target.Path.Count() + " " + (target.Position == target.ServerPosition) + (waypoints.Last<Vector2>().To3D() == target.ServerPosition));
                if (QWER.Delay < 0.3)
                    QWER.CastIfHitchanceEquals(target, HitChance.Dashing, true);
                QWER.CastIfHitchanceEquals(target, HitChance.Immobile, true);
                QWER.CastIfWillHit(target, 2, true);

                float SiteToSite = ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.ServerPosition) / QWER.Speed)) * 6 - QWER.Width;
                float BackToFront = ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.ServerPosition) / QWER.Speed));
                if (ObjectManager.Player.Distance(waypoints.Last<Vector2>().To3D()) < SiteToSite || ObjectManager.Player.Distance(target.Position) < SiteToSite)
                    QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                else if (target.Path.Count() < 2
                    && (target.ServerPosition.Distance(waypoints.Last<Vector2>().To3D()) > SiteToSite
                    || Math.Abs(ObjectManager.Player.Distance(waypoints.Last<Vector2>().To3D()) - ObjectManager.Player.Distance(target.Position)) > BackToFront
                    || target.HasBuffOfType(BuffType.Slow) || target.HasBuff("Recall")
                    || (target.Path.Count() == 0 && target.Position == target.ServerPosition)
                    ))
                {
                    if (target.IsFacing(ObjectManager.Player) || target.Path.Count() == 0)
                    {
                        if (ObjectManager.Player.Distance(target.Position) < QWER.Range - ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.Position) / QWER.Speed)))
                            QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                    }
                    else
                    {
                        QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                    }
                }
            }
            else if (HitChanceNum == 4 && (int)QWER.GetPrediction(target).Hitchance > 4)
            {
                List<Vector2> waypoints = target.GetWaypoints();
                //debug("" + target.Path.Count() + " " + (target.Position == target.ServerPosition) + (waypoints.Last<Vector2>().To3D() == target.ServerPosition));
                if (QWER.Delay < 0.3)
                    QWER.CastIfHitchanceEquals(target, HitChance.Dashing, true);
                QWER.CastIfHitchanceEquals(target, HitChance.Immobile, true);
                QWER.CastIfWillHit(target, 2, true);

                float SiteToSite = ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.ServerPosition) / QWER.Speed)) * 6 - QWER.Width;
                float BackToFront = ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.ServerPosition) / QWER.Speed));
                if (ObjectManager.Player.Distance(waypoints.Last<Vector2>().To3D()) < SiteToSite || ObjectManager.Player.Distance(target.Position) < SiteToSite)
                    QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                else if (target.Path.Count() < 2
                    && (target.ServerPosition.Distance(waypoints.Last<Vector2>().To3D()) > SiteToSite
                    || Math.Abs(ObjectManager.Player.Distance(waypoints.Last<Vector2>().To3D()) - ObjectManager.Player.Distance(target.Position)) > BackToFront
                    || target.HasBuffOfType(BuffType.Slow) || target.HasBuff("Recall")
                    || (target.Path.Count() == 0 && target.Position == target.ServerPosition)
                    ))
                {
                    if (target.IsFacing(ObjectManager.Player) || target.Path.Count() == 0)
                    {
                        if (ObjectManager.Player.Distance(target.Position) < QWER.Range - ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.Position) / QWER.Speed)))
                            QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                    }
                    else
                    {
                        QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                    }
                }
            }
        }
Example #35
0
 private void OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     try
     {
         if (sender.IsEnemy && args.DangerLevel == Interrupter2.DangerLevel.High &&
             Menu.Item(Menu.Name + ".ultimate.auto.enabled").GetValue<bool>() &&
             Menu.Item(Menu.Name + ".ultimate.auto.interrupt." + sender.ChampionName).GetValue<bool>() &&
             sender.IsFacing(Player))
         {
             Casting.SkillShot(sender, R, R.GetHitChance("combo"));
         }
     }
     catch (Exception ex)
     {
         Global.Logger.AddItem(new LogItem(ex));
     }
 }
Example #36
0
        static void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            if (!AIO_Menu.Champion.Misc.UseInterrupter || Player.IsDead)
                return;

            if (R.CanCast(sender) && sender.IsFacing(Player))
                R.Cast(sender);
        }
Example #37
0
        static void OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            if (Player.IsDead)
            {
                return;
            }
            if (sender.IsValidTarget())
            {
                if (CassioUtils.Active("Interrupter.UseR") && Vector3.Distance(sender.ServerPosition, Player.ServerPosition) <= Spells[SpellSlot.R].Range && sender.IsFacing(Player))
                {
					Spells[SpellSlot.R].SPredictionCast(sender, CassioUtils.GetHitChance("Hitchance.R"));
					/*
                    var pred = Spells[SpellSlot.R].GetPrediction(sender);
                    if (pred.Hitchance >= HitChance.VeryHigh && sender.IsFacing(Player))
                    {
                        Spells[SpellSlot.R].Cast(pred.CastPosition);
                    }
					*/
				}
            }
        }
Example #38
0
        internal static bool CanE(Obj_AI_Hero target)
        {
            if (Config.Item("eeee").GetValue<StringList>().SelectedIndex == 0)
                return true;

            var t = KL.TurretCache.Values.FirstOrDefault(x => x.IsEnemy && x.Distance(KL.Player.ServerPosition) <= 1500);
            if (t == null || t.IsDead || !t.IsValid)
                return true;

            if (KL.Player.Distance(t) <= 1200 && target.Distance(t) <= 1200)
            {
                if (target.Distance(t) > KL.Player.Distance(t))
                {
                    if (target.IsFacing(t))
                        return false;
                }
            }

            return true;
        }
Example #39
0
        private static void CastSpell(Spell QWER, Obj_AI_Hero target, int HitChanceNum)
        {
            //HitChance 0 - 2
            // example CastSpell(Q, ts, 2);
            var poutput = QWER.GetPrediction(target);
            var col = poutput.CollisionObjects.Count(ColObj => ColObj.IsEnemy && ColObj.IsMinion && !ColObj.IsDead);
            if (QWER.Collision && col > 0)
                return;
            if (HitChanceNum == 0)
                QWER.Cast(target, true);
            else if (HitChanceNum == 1)
            {
                if ((int)poutput.Hitchance > 4)
                    QWER.Cast(poutput.CastPosition);
            }
            else if (HitChanceNum == 2)
            {
                if ((target.IsFacing(ObjectManager.Player) && (int)poutput.Hitchance == 5) || (target.Path.Count() == 0 && target.Position == target.ServerPosition))
                {
                    if (ObjectManager.Player.Distance(target.Position) < QWER.Range - ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.Position) / QWER.Speed) + (target.BoundingRadius * 2)))
                    {
                        QWER.Cast(poutput.CastPosition);
                    }
                }
                else if ((int)poutput.Hitchance == 5)
                {
                    QWER.Cast(poutput.CastPosition);
                }
            }
            else if (HitChanceNum == 3)
            {
                List<Vector2> waypoints = target.GetWaypoints();
                float SiteToSite = ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.ServerPosition) / QWER.Speed)) * 6 - QWER.Width;
                float BackToFront = ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.ServerPosition) / QWER.Speed));
                if (ObjectManager.Player.Distance(waypoints.Last<Vector2>().To3D()) < SiteToSite || ObjectManager.Player.Distance(target.Position) < SiteToSite)
                    QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                else if (target.Path.Count() < 2
                    && (target.ServerPosition.Distance(waypoints.Last<Vector2>().To3D()) > SiteToSite
                    || Math.Abs(ObjectManager.Player.Distance(waypoints.Last<Vector2>().To3D()) - ObjectManager.Player.Distance(target.Position)) > BackToFront
                    || target.HasBuffOfType(BuffType.Slow) || target.HasBuff("Recall")
                    || (target.Path.Count() == 0 && target.Position == target.ServerPosition)
                    ))
                {
                    if (target.IsFacing(ObjectManager.Player) || target.Path.Count() == 0)
                    {
                        if (ObjectManager.Player.Distance(target.Position) < QWER.Range - ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.Position) / QWER.Speed) + (target.BoundingRadius * 2)))
                            QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                    }
                    else
                    {
                        QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                    }
                }
            }
            else if (HitChanceNum == 4 && (int)poutput.Hitchance > 4)
            {

                List<Vector2> waypoints = target.GetWaypoints();
                float SiteToSite = ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.ServerPosition) / QWER.Speed)) * 6 - QWER.Width;
                float BackToFront = ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.ServerPosition) / QWER.Speed));
                if (ObjectManager.Player.Distance(waypoints.Last<Vector2>().To3D()) < SiteToSite || ObjectManager.Player.Distance(target.Position) < SiteToSite)
                    QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                else if (target.Path.Count() < 2
                    && (target.ServerPosition.Distance(waypoints.Last<Vector2>().To3D()) > SiteToSite
                    || Math.Abs(ObjectManager.Player.Distance(waypoints.Last<Vector2>().To3D()) - ObjectManager.Player.Distance(target.Position)) > BackToFront
                    || target.HasBuffOfType(BuffType.Slow) || target.HasBuff("Recall")
                    || (target.Path.Count() == 0 && target.Position == target.ServerPosition)
                    ))
                {
                    // max range fix
                    if (target.IsFacing(ObjectManager.Player) || target.Path.Count() == 0)
                    {
                        if (ObjectManager.Player.Distance(target.Position) < QWER.Range - ((target.MoveSpeed * QWER.Delay) + (Player.Distance(target.Position) / QWER.Speed) + (target.BoundingRadius * 2)))
                            QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                    }
                    else
                    {
                        QWER.CastIfHitchanceEquals(target, HitChance.High, true);
                    }
                }
            }
        }
Example #40
0
 private static bool TargetRunningAway(Obj_AI_Hero hero)
 {
     var isfacingplayer = hero.IsFacing(_player);
     var ismoving = hero.IsMoving;
     return !isfacingplayer && ismoving && !hero.IsMovementImpaired();
 }
Example #41
0
 void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (MenuHelper.isMenuEnabled("dzaio.cassiopeia.misc.antigp") && _spells[SpellSlot.R].IsReady())
     {
         if (args.DangerLevel >= Interrupter2.DangerLevel.High && sender.IsFacing(ObjectManager.Player))
         {
             _spells[SpellSlot.R].CastIfHitchanceEquals(sender, MenuHelper.GetHitchance());
         }
     }
 }
Example #42
0
        protected override void Interrupter_OnPosibleToInterrupt(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs spell)
        {
            if (!menu.Item("UseInt", true).GetValue<bool>()) return;

            if (sender.IsValidTarget())
            {
                if (Player.Distance(sender) <= R.Range && sender.IsFacing(Player))
                {
                    var pred = R.GetPrediction(sender);
                    if (pred.Hitchance >= HitChance.VeryHigh && sender.IsFacing(Player))
                    {
                        R.Cast(pred.CastPosition);
                    }
                }
            }
        }
        private float CalcComboDamage(Obj_AI_Hero target,
            float resMulti,
            bool rangeCheck,
            bool q,
            bool w,
            bool e,
            bool r)
        {
            try
            {
                if (target == null)
                {
                    return 0;
                }

                var damage = 0f;
                var totalMana = 0f;

                if (r && R.IsReady() && (!rangeCheck || R.IsInRange(target)))
                {
                    var rMana = R.ManaCost * resMulti;
                    if (totalMana + rMana <= Player.Mana)
                    {
                        totalMana += rMana;
                        damage += R.GetDamage(target);
                    }
                }

                if (q && Q.IsReady() && (!rangeCheck || Q.IsInRange(target)))
                {
                    var qMana = Q.ManaCost * resMulti;
                    if (totalMana + qMana <= Player.Mana)
                    {
                        totalMana += qMana;
                        damage += Q.GetDamage(target);
                    }
                }
                else if (w && W.IsReady() && (!rangeCheck || W.IsInRange(target)))
                {
                    var wMana = W.ManaCost * resMulti;
                    if (totalMana + wMana <= Player.Mana)
                    {
                        totalMana += wMana;
                        damage += W.GetDamage(target);
                    }
                }
                if (e && E.IsReady(3000) && (!rangeCheck || E.IsInRange(target)))
                {
                    var eMana = E.ManaCost * resMulti;
                    var eDamage = E.GetDamage(target);
                    var count = target.IsNearTurret() && !target.IsFacing(Player) ||
                                target.IsNearTurret() && Player.HealthPercent <= 35 || !R.IsReady()
                        ? 5
                        : 8;
                    for (var i = 0; i < count; i++)
                    {
                        if (totalMana + eMana > Player.Mana)
                        {
                            break;
                        }
                        totalMana += eMana;
                        damage += eDamage;
                    }
                }

                damage += ItemManager.CalculateComboDamage(target, rangeCheck);
                damage += SummonerManager.CalculateComboDamage(target, rangeCheck);
                return damage;
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
            return 0;
        }
Example #44
0
        Vector3 GetTumblePos(Obj_AI_Hero target)
        {
            //if the target is not a melee and he's alone he's not really a danger to us, proceed to 1v1 him :^ )
            if (!target.IsMelee && Heroes.Player.CountEnemiesInRange(800) == 1) return Game.CursorPos;

            var aRC = new Utils.Geometry.Circle(Heroes.Player.ServerPosition.To2D(), 300).ToPolygon().ToClipperPath();
            var cP = Game.CursorPos;
            var tP = target.ServerPosition;
            var pList = new List<Vector3>();
            var additionalDistance = (0.106 + Game.Ping / 2000f) * target.MoveSpeed;

            if ((!cP.IsWall() && !cP.UnderTurret(true) && cP.Distance(tP) > 325 && cP.Distance(tP) < 550 &&
                 (cP.CountEnemiesInRange(425) <= cP.CountAlliesInRange(325)))) return cP;

            foreach (var p in aRC)
            {
                var v3 = new Vector2(p.X, p.Y).To3D();

                if (target.IsFacing(Heroes.Player))
                {
                    if (!v3.IsWall() && !v3.UnderTurret(true) && v3.Distance(tP) > 325 && v3.Distance(tP) < 550 &&
                        (v3.CountEnemiesInRange(425) <= v3.CountAlliesInRange(325))) pList.Add(v3);
                }
                else
                {
                    if (!v3.IsWall() && !v3.UnderTurret(true) && v3.Distance(tP) > 325 &&
                        v3.Distance(tP) < (550 - additionalDistance) &&
                        (v3.CountEnemiesInRange(425) <= v3.CountAlliesInRange(325))) pList.Add(v3);
                }
            }
            if (Heroes.Player.UnderTurret() || Heroes.Player.CountEnemiesInRange(800) == 1)
            {
                return pList.Count > 1 ? pList.OrderBy(el => el.Distance(cP)).FirstOrDefault() : Vector3.Zero;
            }
            return pList.Count > 1 ? pList.OrderByDescending(el => el.Distance(tP)).FirstOrDefault() : Vector3.Zero;
        }
 private void OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     try
     {
         if (sender.IsEnemy && args.DangerLevel == Interrupter2.DangerLevel.High &&
             Ultimate.IsActive(UltimateModeType.Interrupt, sender) && sender.IsFacing(Player))
         {
             Casting.SkillShot(sender, R, HitChance.High);
         }
     }
     catch (Exception ex)
     {
         Global.Logger.AddItem(new LogItem(ex));
     }
 }
Example #46
0
        private float CalcComboDamage(Obj_AI_Hero target, bool q, bool w, bool e, bool r)
        {
            try
            {
                if (target == null)
                {
                    return 0;
                }
                var manaCost = (w && W.IsReady() ? W.Instance.ManaCost : (q ? Q.Instance.ManaCost : 0)) * 2;
                var damage = (w && W.IsReady() ? W.GetDamage(target) : (q ? Q.GetDamage(target) : 0)) * 2;

                if (e)
                {
                    var eMana = E.Instance.ManaCost;
                    var eDamage = E.GetDamage(target);
                    var count = target.IsNearTurret() && !target.IsFacing(Player) ||
                                target.IsNearTurret() && Player.HealthPercent <= 35 || !R.IsReady()
                        ? 5
                        : 10;
                    for (var i = 0; i < count; i++)
                    {
                        if (manaCost + eMana > Player.Mana)
                        {
                            break;
                        }
                        manaCost += eMana;
                        damage += eDamage;
                    }
                }
                if (r)
                {
                    if (manaCost + R.Instance.ManaCost - 10 > Player.Mana)
                    {
                        return damage;
                    }
                    return damage + (R.IsReady() ? R.GetDamage(target) : 0);
                }
                damage += ItemManager.CalculateComboDamage(target);
                damage += SummonerManager.CalculateComboDamage(target);
                return damage;
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
            return 0;
        }
 private bool ELogicHero(Obj_AI_Hero mainTarget, HitChance hitChance)
 {
     try
     {
         if (mainTarget == null)
         {
             return false;
         }
         var input = new PredictionInput
         {
             Range = ELength,
             Delay = E.Delay,
             Radius = E.Width,
             Speed = E.Speed,
             Type = E.Type,
             UseBoundingRadius = true
         };
         var input2 = new PredictionInput
         {
             Range = E.Range + ELength,
             Delay = E.Delay,
             Radius = E.Width,
             Speed = E.Speed,
             Type = E.Type,
             UseBoundingRadius = true
         };
         var startPosition = Vector3.Zero;
         var endPosition = Vector3.Zero;
         var targets =
             GameObjects.EnemyHeroes.Where(t => t.IsValidTarget((E.Range + ELength + E.Width) * 1.25f)).ToList();
         if (mainTarget.ServerPosition.Distance(Player.ServerPosition) <= E.Range)
         {
             var castPosition = mainTarget.ServerPosition;
             var maxAdditionalHits = 0;
             foreach (var target in targets.Where(t => t.NetworkId != mainTarget.NetworkId))
             {
                 var lTarget = target;
                 var additionalHits = 0;
                 input.Unit = lTarget;
                 input.From = castPosition;
                 input.RangeCheckFrom = castPosition;
                 var pred = Prediction.GetPrediction(input);
                 if (pred.Hitchance >= HitChance.High)
                 {
                     additionalHits++;
                     var rect = new Geometry.Polygon.Rectangle(
                         castPosition, castPosition.Extend(pred.CastPosition, ELength), E.Width);
                     foreach (var target2 in
                         targets.Where(
                             t => t.NetworkId != mainTarget.NetworkId && t.NetworkId != lTarget.NetworkId))
                     {
                         input.Unit = target2;
                         var pred2 = Prediction.GetPrediction(input);
                         if (!pred2.UnitPosition.Equals(Vector3.Zero) &&
                             new Geometry.Polygon.Circle(pred2.UnitPosition, target2.BoundingRadius * 0.9f)
                                 .Points.Any(p => rect.IsInside(p)))
                         {
                             additionalHits++;
                         }
                     }
                 }
                 if (additionalHits > maxAdditionalHits)
                 {
                     maxAdditionalHits = additionalHits;
                     endPosition = pred.CastPosition;
                 }
             }
             startPosition = castPosition;
             if (endPosition.Equals(Vector3.Zero))
             {
                 if (startPosition.Distance(Player.ServerPosition) > E.Range)
                 {
                     startPosition = Player.ServerPosition.Extend(startPosition, E.Range);
                 }
                 if (mainTarget.Path.Length > 0)
                 {
                     var newPos = mainTarget.Path[0];
                     if (mainTarget.Path.Length > 1 &&
                         newPos.Distance(mainTarget.ServerPosition) <= mainTarget.BoundingRadius * 4f)
                     {
                         var nnPos = newPos.Extend(
                             mainTarget.Path[1],
                             Math.Min(mainTarget.BoundingRadius * 1.5f, newPos.Distance(mainTarget.Path[1])));
                         if (startPosition.To2D().AngleBetween(nnPos.To2D()) < 30)
                         {
                             newPos = nnPos;
                         }
                     }
                     endPosition = startPosition.Extend(newPos, ELength);
                 }
                 else if (mainTarget.IsFacing(Player))
                 {
                     endPosition = startPosition.Extend(Player.ServerPosition, ELength);
                 }
                 else
                 {
                     endPosition = Player.ServerPosition.Extend(
                         startPosition, startPosition.Distance(Player.ServerPosition) + ELength);
                 }
             }
         }
         else
         {
             var totalHits = 0;
             input2.Unit = mainTarget;
             var pred = Prediction.GetPrediction(input2);
             if (!pred.UnitPosition.Equals(Vector3.Zero) && !pred.CastPosition.Equals(Vector3.Zero))
             {
                 var ranges =
                     new[] { E.Range }.Concat(
                         targets.Where(
                             t =>
                                 t.ServerPosition.Distance(Player.ServerPosition) < E.Range &&
                                 t.ServerPosition.Distance(mainTarget.ServerPosition) < ELength * 1.25f)
                             .Select(t => t.ServerPosition.Distance(Player.ServerPosition)));
                 var maxDistance = (ELength + E.Width + mainTarget.BoundingRadius) * 1.1f;
                 foreach (var range in ranges)
                 {
                     var circle =
                         new Geometry.Polygon.Circle(Player.ServerPosition, Math.Min(E.Range, range), 50).Points
                             .Where(p => p.Distance(pred.UnitPosition) <= maxDistance)
                             .Select(p => p.To3D())
                             .OrderBy(p => p.Distance(pred.CastPosition));
                     foreach (var point in circle)
                     {
                         var hits = 0;
                         input.From = point;
                         input.RangeCheckFrom = point;
                         input.Unit = mainTarget;
                         var pred2 = Prediction.GetPrediction(input);
                         if (pred2.Hitchance >= hitChance)
                         {
                             hits++;
                             var rect = new Geometry.Polygon.Rectangle(
                                 point, point.Extend(pred2.CastPosition, ELength), E.Width);
                             foreach (var target in targets.Where(t => t.NetworkId != mainTarget.NetworkId))
                             {
                                 input.Unit = target;
                                 var pred3 = Prediction.GetPrediction(input);
                                 if (!pred3.UnitPosition.Equals(Vector3.Zero) &&
                                     new Geometry.Polygon.Circle(
                                         pred3.UnitPosition, target.BoundingRadius * 0.9f).Points.Any(
                                             p => rect.IsInside(p)))
                                 {
                                     hits++;
                                 }
                             }
                             if (hits > totalHits ||
                                 hits > 0 && hits == totalHits &&
                                 point.Distance(mainTarget.ServerPosition) <
                                 startPosition.Distance(mainTarget.ServerPosition))
                             {
                                 totalHits = hits;
                                 startPosition = point;
                                 endPosition = point.Extend(pred2.CastPosition, ELength);
                             }
                             if (totalHits == targets.Count)
                             {
                                 break;
                             }
                         }
                     }
                     if (totalHits == targets.Count)
                     {
                         break;
                     }
                 }
             }
         }
         if (!startPosition.Equals(Vector3.Zero) && !endPosition.Equals(Vector3.Zero))
         {
             if (startPosition.Distance(Player.ServerPosition) > E.Range)
             {
                 startPosition = Player.ServerPosition.Extend(startPosition, E.Range);
             }
             if (endPosition.Distance(startPosition) > ELength)
             {
                 endPosition = startPosition.Extend(endPosition, ELength);
             }
             E.Cast(startPosition, endPosition);
             return true;
         }
     }
     catch (Exception ex)
     {
         Global.Logger.AddItem(new LogItem(ex));
     }
     return false;
 }
Example #48
0
        public static bool CastQ(Obj_AI_Hero target)
        {
            var qPrediction = Q.GetPrediction(target);

            if(qPrediction.Hitchance < HitChance.VeryHigh)
            {
                return false;
            }

            if(EIsReady)
            {
                var directTravelTime = BallManager.BallPosition.Distance(qPrediction.CastPosition) / Q.Speed;
                var bestEQTravelTime = float.MaxValue;

                Obj_AI_Hero eqTarget = null;

                foreach (var ally in HeroManager.Allies.Where(h => h.IsValidTarget(E.Range, false)))
                {
                    var t = BallManager.BallPosition.Distance(ally.ServerPosition) / E.Speed + ally.Distance(qPrediction.CastPosition) / Q.Speed;
                    if(t < bestEQTravelTime)
                    {
                        eqTarget = ally;
                        bestEQTravelTime = t;
                    }
                }

                if (eqTarget != null && bestEQTravelTime < directTravelTime * 1.3f && (BallManager.BallPosition.Distance(eqTarget.ServerPosition, true) > 10000))
                {
                    E.CastOnUnit(eqTarget, true);
                    return true;
                }
            }

            if (!target.IsFacing(Player) && target.Path.Count() >= 1) // target is running
            {
                var targetBehind = Q.GetPrediction(target).CastPosition +
                                   Vector3.Normalize(target.ServerPosition - BallManager.BallPosition) * target.MoveSpeed / 2;
                Q.Cast(targetBehind, true);
                return true;
            }

            Q.Cast(qPrediction.CastPosition, true);
            return true;
        }
Example #49
0
        private static Vector3 PreCastPos(Obj_AI_Hero Hero ,float Delay)
        {
            float value = 0f;
            if (Hero.IsFacing(Player))
            {
                value = (10f - Hero.BoundingRadius);
            }
            else
            {
                value = -(120f - Hero.BoundingRadius);
            }
            var distance = Delay * Hero.MoveSpeed + value;
            var path = Hero.GetWaypoints();

            for (var i = 0; i < path.Count - 1; i++)
            {
                var a = path[i];
                var b = path[i + 1];
                var d = a.Distance(b);

                if (d < distance)
                {
                    distance -= d;
                }
                else
                {
                    return (a + distance * (b - a).Normalized()).To3D();
                }
            }

            return (path[path.Count - 1]).To3D();
        }
Example #50
0
        private void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(700, TargetSelector.DamageType.Physical);

            if (target == null)
            {
                return;
            }
            var combodamage = ComboDamage(target);

            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, combodamage);
            }
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);

            if (config.Item("useIgnite").GetValue <bool>() && hasIgnite &&
                ((R.IsReady() && ignitedmg + R.GetDamage(target) > target.Health) || ignitedmg > target.Health) &&
                (target.Distance(player) > E.Range || player.HealthPercent < 20))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() &&
                player.Distance(target) > player.AttackRange && !GarenE && !GarenQ &&
                CombatHelper.IsPossibleToReachHim(
                    target, 0.35f, new float[5] {
                1.5f, 2.25f, 3f, 3.75f, 4.5f
            }[Q.Level - 1]))
            {
                Q.Cast(config.Item("packets").GetValue <bool>());
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() && !GarenQ &&
                (!GarenE || (Q.IsReady() && Damage.GetSpellDamage(player, target, SpellSlot.Q) > target.Health)))
            {
                if (GarenE)
                {
                    E.Cast(config.Item("packets").GetValue <bool>());
                }
                Q.Cast(config.Item("packets").GetValue <bool>());
                player.IssueOrder(GameObjectOrder.AutoAttack, target);
            }
            if (config.Item("usee", true).GetValue <bool>() && E.IsReady() && !Q.IsReady() && !GarenQ && !GarenE &&
                player.CountEnemiesInRange(E.Range) > 0)
            {
                E.Cast(config.Item("packets").GetValue <bool>());
            }
            var targHP = target.Health + 20 - CombatHelper.IgniteDamage(target);
            var rLogic = config.Item("user", true).GetValue <bool>() && R.IsReady() &&
                         (!config.Item("ult" + target.SkinName, true).GetValue <bool>() ||
                          player.CountEnemiesInRange(1500) == 1) &&
                         Damage.GetSpellDamage(player, target, SpellSlot.R) > targHP && targHP > 0;

            if (rLogic && target.Distance(player) < R.Range)
            {
                if (GarenE)
                {
                    E.Cast(config.Item("packets").GetValue <bool>());
                }
                else
                {
                    R.Cast(target, config.Item("packets").GetValue <bool>());
                }
            }
            if (config.Item("usew", true).GetValue <bool>() && W.IsReady() && player.CountEnemiesInRange(E.Range) > 0 &&
                target.IsFacing(player))
            {
                W.Cast(config.Item("packets").GetValue <bool>());
            }
            bool hasFlash = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerFlash")) == SpellState.Ready;

            if (config.Item("useFlash", true).GetValue <bool>() && hasFlash && rLogic &&
                target.Distance(player) < R.Range + 425 && target.Distance(player) > R.Range && !Q.IsReady() &&
                !CombatHelper.IsFacing(target, player.Position) && !GarenQ)
            {
                if (GarenE)
                {
                    E.Cast(config.Item("packets").GetValue <bool>());
                }
                else if (!player.Position.Extend(target.Position, 425f).IsWall())
                {
                }
                {
                    player.Spellbook.CastSpell(
                        player.GetSpellSlot("SummonerFlash"), player.Position.Extend(target.Position, 425f));
                }
            }
        }
Example #51
0
 private bool ShouldR(Obj_AI_Hero target)
 {
     return !menu.Item("faceCheck", true).GetValue<bool>() || target.IsFacing(Player);
 }
Example #52
0
        static void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            if (!menu.Item("interruptR").GetValue<bool>()) return;

            if (sender.IsValidTarget(R.Range) && args.DangerLevel >= Interrupter2.DangerLevel.High && menu.Item(sender.ChampionName + "interrupt").GetValue<bool>() && sender.IsFacing(player))
                R.CastIfHitchanceEquals(sender, HitChance.High, menu.Item("PacketCast").GetValue<bool>());
        }
Example #53
0
 public static bool IsHeRunAway(Obj_AI_Hero target)
 {
     return (!target.IsFacing(player) &&
             Prediction.GetPrediction(target, 600, 100f).CastPosition.Distance(player.Position) >
             target.Position.Distance(player.Position));
 }
Example #54
0
        public static bool SpellPrediction(Spell spell, Obj_AI_Hero target,bool collisionable)
        {
            //
            var dist = ObjectManager.Player.Distance(target.Position);
            var pos1 = LeagueSharp.Common.Prediction.GetPrediction(target, dist / spell.Speed).UnitPosition;
            var e = pos1.Distance(target.GetWaypoints()[1].To3D());

            pos1.Extend(target.GetWaypoints()[1].To3D(), -e);
            Render.Circle.DrawCircle(pos1, 10, System.Drawing.Color.BlueViolet, 2);
            //
            var point = PointsAroundTheTarget(target.Position, target.BoundingRadius + 50).FirstOrDefault(t => t.IsWall());
            if (point.X != 0 && point.Y != 0 && point.Z != 0)
            {
                if (MinionCollideLine(ObjectManager.Player.Position, ExtendWallpos(target, point), spell,collisionable)) return false;

                Render.Circle.DrawCircle(ExtendWallpos(target, point), 10, System.Drawing.Color.Brown, 2);
                spell.Cast(ExtendWallpos(target, point));
                return true;
            }
            else
            {
                var range = spell.Range;
                if (target.Position.Distance(ObjectManager.Player.Position) < target.GetWaypoints()[1].Distance(ObjectManager.Player.Position))
                {
                    range -= 100;
                }

                if (!spell.IsInRange(target, range)) return false;

                if (target.IsFacing(ObjectManager.Player) && target.Position.Distance(ObjectManager.Player.Position) > target.GetWaypoints()[1].Distance(ObjectManager.Player.Position))
                {
                  if (MinionCollideLine(ObjectManager.Player.Position, target.Position, spell,collisionable)) return false;
                        spell.Cast(target.Position);
                        return true;

                }
               // float speed =
                if (target.IsImmovable) // check for cc guys
                {
                    if (MinionCollideLine(ObjectManager.Player.Position, target.Position, spell,collisionable)) return false;
                    spell.Cast(target.Position);
                    return true;
                }

              //  if(target.IsChannelingImportantSpell())
                if (target.IsWindingUp && !target.IsMelee())
                {
                    if (MinionCollideLine(ObjectManager.Player.Position, target.Position, spell,collisionable)) return false;
                    spell.Cast(target.Position);
                    return true;
                }

                if (target.Position.Distance(ObjectManager.Player.Position) <= 300)
                {
                    CastToDirection( target, spell,collisionable);
                }
                else
                {
                    var oldPos = target.GetWaypoints()[0].To3D();
                   var h = false;
                    Utility.DelayAction.Add(Game.Ping + 1000, () => h = Next(target, oldPos, spell,collisionable));
                    return h;
                }
            }
            return false;
        }