/// <summary>
        /// Determines whether the specified position is Safe using AA ranges logic.
        /// </summary>
        /// <param name="position">The position.</param>
        /// <returns></returns>
        public static bool IsSafeEx(Vector3 position)
        {
            var closeEnemies =
                    HeroManager.Enemies.FindAll(en => en.IsValidTarget(1500f) && !(en.Distance(ObjectManager.Player.ServerPosition) < en.AttackRange + 65f))
                    .OrderBy(en => en.Distance(position));

            return closeEnemies.All(
                                enemy =>
                                    position.CountEnemiesInRange(enemy.AttackRange) <= 1);
        }
Beispiel #2
0
        public static Vector3 IsSafe(AIHeroClient target, Vector3 vec)
        {
            if (target.ServerPosition.To2D().Distance(vec) <= target.AttackRange && vec.CountEnemiesInRange(1000) > 1)
            {
                return(Vector3.Zero);
            }

            if (HeroManager.Enemies.Any(p => p.NetworkId != target.NetworkId && p.ServerPosition.To2D().Distance(vec) <= p.AttackRange) || vec.UnderTurret(true))
            {
                return(Vector3.Zero);
            }

            return(vec);
        }
Beispiel #3
0
 public bool InAARange(Vector3 point)
 {
     if (!Config.Item("AAcheck", true).GetValue <bool>())
     {
         return(true);
     }
     else if (Orbwalker.GetTarget() != null && Orbwalker.GetTarget().Type == GameObjectType.AIHeroClient)
     {
         return(point.Distance(Orbwalker.GetTarget().Position) < Player.AttackRange);
     }
     else
     {
         return(point.CountEnemiesInRange(Player.AttackRange) > 0);
     }
 }
Beispiel #4
0
 public bool InAARange(Vector3 point)
 {
     if (!getCheckBoxItem("AAcheck"))
     {
         return(true);
     }
     else if (Orbwalker.LastTarget != null && Orbwalker.LastTarget.Type == GameObjectType.AIHeroClient)
     {
         return(point.Distance(Orbwalker.LastTarget.Position) < Player.AttackRange);
     }
     else
     {
         return(point.CountEnemiesInRange(Player.AttackRange) > 0);
     }
 }
Beispiel #5
0
        public static bool IsSafePosition(this Vector3 position)
        {
            var enemyTurrets =
                EntityManager.Turrets.Enemies.Count(turret => !turret.IsDead && turret.Distance(position) <= 950);
            var alliedTurrets =
                EntityManager.Turrets.Allies.Count(turret => !turret.IsDead && turret.Distance(position) <= 950);
            var allies    = position.CountAlliesInRange(800);
            var lowAllies =
                EntityManager.Heroes.Enemies.Count(ally => ally.Distance(position) <= 800 && ally.HealthPercent < 30);
            var enemies    = position.CountEnemiesInRange(1000);
            var lowEnemies =
                EntityManager.Heroes.Enemies.Count(enemy => enemy.Distance(position) <= 1000 && enemy.HealthPercent < 30);

            return(allies + alliedTurrets - lowAllies + 1 > enemies - lowEnemies + enemyTurrets);
        }
Beispiel #6
0
        private bool ShouldE(Vector3 pos)
        {
            var maxEnemies = Menu.Item("Do_Not_E", true).GetValue <Slider>().Value;

            if (!Menu.Item("E_If_UnderTurret", true).GetValue <KeyBind>().Active&& pos.UnderTurret(true))
            {
                return(false);
            }

            if (Player.HealthPercent <= Menu.Item("Do_Not_E_HP", true).GetValue <Slider>().Value)
            {
                return(false);
            }

            return(pos.CountEnemiesInRange(600) < maxEnemies);
        }
Beispiel #7
0
        public static bool IsSafePosition(Vector3 position)
        {
            if (position.UnderTurret(true) && !ObjectManager.Player.UnderTurret(true))
                return false;
            var allies = position.CountAlliesInRange(ObjectManager.Player.AttackRange);
            var enemies = position.CountEnemiesInRange(ObjectManager.Player.AttackRange);
            var lhEnemies = GetLhEnemiesNearPosition(position, ObjectManager.Player.AttackRange).Count();

            if (enemies == 1) //It's a 1v1, safe to assume I can E
            {
                return true;
            }

            //Adding 1 for the Player
            return (allies + 1 > enemies - lhEnemies);
        }
Beispiel #8
0
        private static bool ShouldE(Vector3 vec)
        {
            var maxEnemies = HarassMenu["DontE"].Cast <Slider>().CurrentValue;

            if (Player.HealthPercent <= HarassMenu["EHP"].Cast <Slider>().CurrentValue)
            {
                return(false);
            }

            if (vec.CountEnemiesInRange(600) >= maxEnemies)
            {
                return(false);
            }

            return(true);
        }
Beispiel #9
0
        public static Vector3 IsSafe(AIHeroClient target, Vector3 vec, bool checkTarget = true)
        {
            if (Program.DontSafeCheck)
            {
                return(vec);
            }

            if (checkTarget)
            {
                if (target.ServerPosition.LSTo2D().LSDistance(vec) <= target.AttackRange)
                {
                    if (vec.CountEnemiesInRange(1000) > 1)
                    {
                        return(Vector3.Zero);
                    }
                    if (target.ServerPosition.LSTo2D().LSDistance(vec) <= target.AttackRange / 2f)
                    {
                        return
                            (SCommon.Maths.Geometry.Deviation(ObjectManager.Player.ServerPosition.LSTo2D(),
                                                              target.ServerPosition.LSTo2D(), 60).To3D());
                    }
                }

                if (((Program.DontQIntoEnemies || target.IsMelee) &&
                     HeroManager.Enemies.Any(
                         p =>
                         p.ServerPosition.LSTo2D().LSDistance(vec) <=
                         p.AttackRange + ObjectManager.Player.BoundingRadius + (p.IsMelee ? 100 : 0))) ||
                    Utility.UnderTurret(vec, true))
                {
                    return(Vector3.Zero);
                }
            }
            if (
                HeroManager.Enemies.Any(
                    p =>
                    p.NetworkId != target.NetworkId &&
                    p.ServerPosition.LSTo2D().LSDistance(vec) <= p.AttackRange + (p.IsMelee ? 50 : 0)) ||
                Utility.UnderTurret(vec, true))
            {
                return(Vector3.Zero);
            }

            return(vec);
        }
Beispiel #10
0
        private void LogicR()
        {
            var Rturrent   = Config.Item("Rturrent").GetValue <bool>();
            var Rks        = Config.Item("Rks").GetValue <bool>();
            var Rlifesaver = Config.Item("Rlifesaver").GetValue <bool>();

            foreach (var t in Program.Enemies.Where(t => t.IsValidTarget() && BallPos.Distance(Prediction.GetPrediction(t, R.Delay).CastPosition) < R.Width && BallPos.Distance(t.ServerPosition) < R.Width))
            {
                if (Rks)
                {
                    var comboDmg = R.GetDamage(t);

                    if (t.IsValidTarget(Q.Range))
                    {
                        comboDmg += Q.GetDamage(t);
                    }
                    if (W.IsReady())
                    {
                        comboDmg += W.GetDamage(t);
                    }
                    if (t.Health < comboDmg)
                    {
                        R.Cast();
                    }
                    Program.debug("ks");
                }
                if (Rturrent && BallPos.UnderTurret(false) && !BallPos.UnderTurret(true))
                {
                    R.Cast();
                    Program.debug("Rturrent");
                }
                if (Rlifesaver && Player.Health < Player.CountEnemiesInRange(800) * Player.Level * 20 && Player.Distance(BallPos) > t.Distance(Player.Position))
                {
                    R.Cast();
                    Program.debug("ls");
                }
            }

            int countEnemies = CountEnemiesInRangeDeley(BallPos, R.Width, R.Delay);

            if (countEnemies >= Config.Item("rCount").GetValue <Slider>().Value&& BallPos.CountEnemiesInRange(R.Width) == countEnemies)
            {
                R.Cast();
            }
        }
Beispiel #11
0
        public static bool OkToQ(this Vector3 position)
        {
            if (position.UnderTurret(true) && !ObjectManager.Player.UnderTurret(true))
            {
                return(false);
            }
            var allies    = position.CountAlliesInRange(ObjectManager.Player.AttackRange);
            var enemies   = position.CountEnemiesInRange(ObjectManager.Player.AttackRange);
            var lhEnemies = GetLhEnemiesNearPosition(position, ObjectManager.Player.AttackRange).Count();

            if (enemies == 1) //It's a 1v1, safe to assume I can E
            {
                return(true);
            }

            //Adding 1 for the Player
            return(allies + 1 > enemies - lhEnemies);
        }
Beispiel #12
0
        public static bool IsSafePosition(Vector3 position) // cradits to Asuna & ijabba
        {
            if (position.UnderTurret(true) && !Player.UnderTurret(true))
            {
                return(false);
            }
            var allies    = position.CountAlliesInRange(Orbwalking.GetRealAutoAttackRange(Player));
            var enemies   = position.CountEnemiesInRange(Orbwalking.GetRealAutoAttackRange(Player));
            var lhEnemies = GetLhEnemiesNearPosition(position, Orbwalking.GetRealAutoAttackRange(Player)).Count();

            if (enemies == 1)
            {
                return(true);
            }


            return(allies + 1 > enemies - lhEnemies);
        }
Beispiel #13
0
        /// <summary>
        /// Gets the average distance of a specified position to the enemies.
        /// </summary>
        /// <param name="from">From.</param>
        /// <returns></returns>
        public static float GetAvgDistance(Vector3 from)
        {
            var numberOfEnemies = from.CountEnemiesInRange(1200f);

            if (numberOfEnemies != 0)
            {
                var enemies   = LS.HeroManager.Enemies.Where(en => en.IsValidTarget(1200f, true, from) && en.Health > ObjectManager.Player.GetAutoAttackDamage(en) * 3 + ObjectManager.Player.GetSpellDamage(en, SpellSlot.W) + ObjectManager.Player.GetSpellDamage(en, SpellSlot.Q)).ToList();
                var enemiesEx = LS.HeroManager.Enemies.Where(en => en.IsValidTarget(1200f, true, from)).ToList();
                var LHEnemies = enemiesEx.Count() - enemies.Count();

                var totalDistance = (LHEnemies > 1 && enemiesEx.Count() > 2) ?
                                    enemiesEx.Sum(en => en.Distance(ObjectManager.Player.ServerPosition)) :
                                    enemies.Sum(en => en.Distance(ObjectManager.Player.ServerPosition));

                return(totalDistance / numberOfEnemies);
            }
            return(-1);
        }
Beispiel #14
0
        public static bool IsSafePosition(Vector3 position)
        {
            var enemies    = position.CountEnemiesInRange(800);
            var allies     = CountAlliesInRange(position);
            var turrets    = EntityManager.Turrets.Allies.Count(x => Player.Distance(x) < 800 && x.IsValid && !x.IsDead);
            var lowEnemies = GetLowaiAiHeroClients(position, 800).Count();

            if (UnderEnemyTurret(position))
            {
                return(false);
            }

            if (enemies == 1)
            {
                return(true);
            }
            return(allies + turrets > enemies - lowEnemies);
        }
Beispiel #15
0
        public static bool IsSafeQPosition(this Vector3 position)
        {
            if (position.UnderTurret(true) && !ObjectManager.Player.UnderTurret(true))
            {
                return(false);
            }

            var allies    = position.CountAlliesInRange(AutoAttackRange);
            var enemies   = position.CountEnemiesInRange(AutoAttackRange);
            var lhEnemies = position.GetNearbyLowHealthEnemies(AutoAttackRange).Count;

            if (enemies == 1)
            {
                return(true);
            }

            return(allies + 1 > enemies - lhEnemies);
        }
        public static bool IsSafe(this Vector3 position, bool noQIntoEnemiesCheck = false)
        {
            if (position.UnderTurret(true) && !ObjectManager.Player.UnderTurret(true))
            {
                return(false);
            }

            var allies    = position.CountAlliesInRange(ObjectManager.Player.AttackRange);
            var enemies   = position.CountEnemiesInRange(ObjectManager.Player.AttackRange);
            var lhEnemies = position.GetLhEnemiesNear(ObjectManager.Player.AttackRange, 15).Count();

            if (enemies <= 1) ////It's a 1v1, safe to assume I can Q
            {
                return(true);
            }

            if (position.UnderAllyTurret())
            {
                var nearestAllyTurret = ObjectManager.Get <Obj_AI_Turret>().Where(a => a.IsAlly).OrderBy(d => d.Distance(position, true)).FirstOrDefault();

                if (nearestAllyTurret != null)
                {
                    ////We're adding more allies, since the turret adds to the firepower of the team.
                    allies += 2;
                }
            }

            ////Adding 1 for my Player
            var normalCheck   = (allies + 1 > enemies - lhEnemies);
            var QEnemiesCheck = true;

            if (MenuExtensions.GetItemValue <bool>("dz191.vhr.misc.tumble.noqenemies") && noQIntoEnemiesCheck)
            {
                var Vector2Position = position.To2D();
                var enemyPoints     = MenuExtensions.GetItemValue <bool>("dz191.vhr.misc.tumble.dynamicqsafety") ? GetEnemyPoints() : GetEnemyPoints(false);
                if (enemyPoints.Contains(Vector2Position) &&
                    !MenuExtensions.GetItemValue <bool>("dz191.vhr.misc.tumble.qspam"))
                {
                    QEnemiesCheck = false;
                }
            }

            return(normalCheck && QEnemiesCheck);
        }
Beispiel #17
0
        public static bool IsSafePosition(Vector3 position)
        {
            var underTurret =
                EntityManager.Turrets.Enemies.FirstOrDefault(
                    turret => !turret.IsDead && turret.Distance(position) <= 950);
            var allies = EntityManager.Heroes.Allies.Count(
                allied => !allied.IsDead && allied.Distance(position) <= 800);
            var enemies   = position.CountEnemiesInRange(1000);
            var lhEnemies = GetLowaiAiHeroClients(position, 800).Count();

            if (underTurret != null)
            {
                return(false);
            }

            if (enemies == 1)
            {
                return(true);
            }
            return(allies > enemies - lhEnemies);
        }
Beispiel #18
0
        static bool IsNotIntoEnemies(this Vector3 position)
        {
            var enemyPoints = GetEnemyPoints();

            if (enemyPoints.ToList().Contains(position.To2D()) && !enemyPoints.Contains(ObjectManager.Player.ServerPosition.To2D()))
            {
                return(false);
            }

            var closeEnemies =
                EntityManager.Heroes.Enemies.FindAll(
                    en =>
                    en.IsValidTarget(1500f) &&
                    !(en.Distance(ObjectManager.Player.ServerPosition) < en.AttackRange + 65f));

            if (!closeEnemies.All(enemy => position.CountEnemiesInRange(enemy.AttackRange) <= 1))
            {
                return(false);
            }

            return(true);
        }
Beispiel #19
0
        public bool IsGoodPosition(Vector3 dashPos)
        {
            if (getCheckBoxItem("WallCheck"))
            {
                var segment = DashSpell.Range / 5;
                for (var i = 1; i <= 5; i++)
                {
                    if (Player.Position.LSExtend(dashPos, i * segment).LSIsWall())
                    {
                        return(false);
                    }
                }
            }

            if (getCheckBoxItem("TurretCheck"))
            {
                if (dashPos.UnderTurret(true))
                {
                    return(false);
                }
            }

            var enemyCheck        = getSliderItem("EnemyCheck");
            var enemyCountDashPos = dashPos.CountEnemiesInRange(600);

            if (enemyCheck > enemyCountDashPos)
            {
                return(true);
            }

            var enemyCountPlayer = Player.CountEnemiesInRange(400);

            if (enemyCountDashPos <= enemyCountPlayer)
            {
                return(true);
            }

            return(false);
        }
Beispiel #20
0
        private static bool IsGoodPosition(Vector3 dashPos)
        {
            if (Manager.MenuManager.QNWall)
            {
                float segment = Manager.SpellManager.Q.Range / 5;
                for (int i = 1; i <= 5; i++)
                {
                    if (Variables._Player.Position.Extend(dashPos, i * segment).IsWall())
                    {
                        return(false);
                    }
                }
            }

            if (Manager.MenuManager.QNTurret)
            {
                if (Variables.UnderEnemyTower(dashPos.To2D()))
                {
                    return(false);
                }
            }

            var enemyCheck        = Manager.MenuManager.QNEnemies;
            var enemyCountDashPos = dashPos.CountEnemiesInRange(600);

            if (enemyCheck > enemyCountDashPos)
            {
                return(true);
            }

            var enemyCountPlayer = Variables._Player.CountEnemiesInRange(400);

            if (enemyCountDashPos <= enemyCountPlayer)
            {
                return(true);
            }

            return(false);
        }
Beispiel #21
0
        public static bool IsGoodPosition(Vector3 dashPos)
        {
            if (MenuManager.Qsettings["QNWall"].Cast <CheckBox>().CurrentValue)
            {
                float segment = Program.Q.Range / 5;
                for (int i = 1; i <= 5; i++)
                {
                    if (Variables._Player.Position.Extend(dashPos, i * segment).IsWall())
                    {
                        return(false);
                    }
                }
            }

            if (MenuManager.Qsettings["QNTurret"].Cast <CheckBox>().CurrentValue)
            {
                if (other.UnderEnemyTower(dashPos.To2D()))
                {
                    return(false);
                }
            }

            var enemyCheck        = MenuManager.Qsettings["QNenemies"].Cast <Slider>().CurrentValue;
            var enemyCountDashPos = dashPos.CountEnemiesInRange(600);

            if (enemyCheck > enemyCountDashPos)
            {
                return(true);
            }

            var enemyCountPlayer = Variables._Player.CountEnemiesInRange(400);

            if (enemyCountDashPos <= enemyCountPlayer)
            {
                return(true);
            }

            return(false);
        }
Beispiel #22
0
        public bool IsGoodPosition(Vector3 dashPos)
        {
            if (Config.Item("WallCheck", true).GetValue <bool>())
            {
                float segment = DashSpell.Range / 5;
                for (int i = 1; i <= 5; i++)
                {
                    if (Player.Position.Extend(dashPos, i * segment).IsWall())
                    {
                        return(false);
                    }
                }
            }

            if (Config.Item("TurretCheck", true).GetValue <bool>())
            {
                if (dashPos.UnderTurret(true))
                {
                    return(false);
                }
            }

            var enemyCheck        = Config.Item("EnemyCheck", true).GetValue <Slider>().Value;
            var enemyCountDashPos = dashPos.CountEnemiesInRange(600);

            if (enemyCheck > enemyCountDashPos)
            {
                return(true);
            }

            var enemyCountPlayer = Player.CountEnemiesInRange(400);

            if (enemyCountDashPos <= enemyCountPlayer)
            {
                return(true);
            }

            return(false);
        }
Beispiel #23
0
        public static float GetAvgDistance(Vector3 from)
        {
            var numberOfEnemies = from.CountEnemiesInRange(1000f);
            if (numberOfEnemies != 0)
            {
                var enemies = HeroManager.Enemies.Where(en => en.LSIsValidTarget(1000f, true, from)
                                                    &&
                                                    en.Health >
                                                    ObjectManager.Player.GetAutoAttackDamage(en)*3 +
                                                    Variables.spells[SpellSlot.W].GetDamage(en) +
                                                    Variables.spells[SpellSlot.Q].GetDamage(en)).ToList();
                var enemiesEx = HeroManager.Enemies.Where(en => en.LSIsValidTarget(1000f, true, from)).ToList();
                var LHEnemies = enemiesEx.Count() - enemies.Count();
                var totalDistance = 0f;

                totalDistance = (LHEnemies > 1 && enemiesEx.Count() > 2) ?
                    enemiesEx.Sum(en => en.LSDistance(ObjectManager.Player.ServerPosition)) :
                    enemies.Sum(en => en.LSDistance(ObjectManager.Player.ServerPosition));

                return totalDistance / numberOfEnemies;
            }
            return -1;
        }
Beispiel #24
0
        /// <summary>
        ///     Gets the average distance of a specified position to the enemies.
        /// </summary>
        /// <param name="from">From.</param>
        /// <returns></returns>
        public static float GetAvgDistance(Vector3 from)
        {
            var numberOfEnemies = from.CountEnemiesInRange(1200f);
            if (numberOfEnemies != 0)
            {
                var enemies = EntityManager.Heroes.Enemies.Where(en => en.IsValidTarget(1200f, true, from)
                                                              &&
                                                              en.Health >
                                                              ObjectManager.Player.GetAutoAttackDamage(en) * 3 +
                                                              ObjectManager.Player.GetSpellDamage(en, SpellSlot.W) +
                                                              ObjectManager.Player.GetSpellDamage(en, SpellSlot.Q))
                    ;
                var enemiesEx = EntityManager.Heroes.Enemies.Where(en => en.IsValidTarget(1200f, true, from));
                var LHEnemies = enemiesEx.Count() - enemies.Count();

                var totalDistance = (LHEnemies > 1 && enemiesEx.Count() > 2)
                    ? enemiesEx.Sum(en => en.Distance(ObjectManager.Player.ServerPosition))
                    : enemies.Sum(en => en.Distance(ObjectManager.Player.ServerPosition));

                return totalDistance / numberOfEnemies;
            }
            return -1;
        }
Beispiel #25
0
        /// <summary>
        /// Returns if this passes the 'No Q into enemies mode'
        /// </summary>
        /// <param name="Position">The Position</param>
        /// <returns></returns>
        public static bool PassesNoQIntoEnemiesCheck(this Vector3 Position)
        {
            if (!VHR.VHRMenu["dz191.vhr.misc"]["dz191.vhr.misc.tumble"]["noqenemies"].GetValue <MenuBool>().Value || VHR.VHRMenu["dz191.vhr.misc"]["dz191.vhr.misc.tumble"]["qspam"].GetValue <MenuBool>().Value)
            {
                return(true);
            }

            if (!VHR.VHRMenu["dz191.vhr.misc"]["dz191.vhr.misc.general"]["lightweight"].GetValue <MenuBool>().Value)
            {
                var Vector2Position = Position.ToVector2();
                if (EnemiesClose.Count() <= 1)
                {
                    return(true);
                }

                if (GetEnemyPoints().Contains(Vector2Position) &&
                    !VHR.VHRMenu["dz191.vhr.misc"]["dz191.vhr.misc.tumble"]["qspam"].GetValue <MenuBool>().Value)
                {
                    return(false);
                }
                return(true);
            }

            var closeEnemies = GameObjects.EnemyHeroes.Where(en => en.IsValidTarget(1500f)).OrderBy(en => en.Distance(Position));

            if (closeEnemies.Any())
            {
                if (closeEnemies.Count() <= 1)
                {
                    return(true);
                }

                return(closeEnemies.All(enemy => Position.CountEnemiesInRange(VHR.VHRMenu["dz191.vhr.misc"]["dz191.vhr.misc.tumble"]["dynamicqsafety"].GetValue <MenuBool>().Value ? enemy.AttackRange : 405f) < 1));
            }
            return(true);
        }
Beispiel #26
0
        static internal bool ShouldJump(Vector3 position)
        {
            if (!SafetyEnabled || Override)
            {
                return(true);
            }
            if (SafetyTowerJump && position.PointUnderEnemyTurret())
            {
                return(false);
            }
            else if (SafetyEnabled)
            {
                if (myHero.HealthPercent < SafetyMinHealth)
                {
                    return(false);
                }

                if (SafetyCountCheck)
                {
                    var enemies = position.CountEnemiesInRange(400);
                    var allies  = position.CountAlliesInRange(400);

                    var   ec       = enemies;
                    var   ac       = allies;
                    float setratio = SafetyRatio / 5;


                    if (ec != 0 && !(ac / ec >= setratio))
                    {
                        return(false);
                    }
                }
                return(true);
            }
            return(true);
        }
Beispiel #27
0
        private void Cast_E()
        {
            if (!E.IsReady() || !PassiveCheck())
            {
                return;
            }

            var target = TargetSelector.GetTarget(E.Range + Player.AttackRange, TargetSelector.DamageType.Physical);

            if (target == null)
            {
                return;
            }

            Vector3 vec = Player.ServerPosition + Vector3.Normalize(Game.CursorPos - Player.ServerPosition) * E.Range;

            if (Player.Distance(Game.CursorPos) < E.Range & Player.Distance(Game.CursorPos) > 150)
            {
                vec = Game.CursorPos;
            }

            if (vec.CountEnemiesInRange(500) >= 3 && vec.CountAlliesInRange(400) < 3)
            {
                return;
            }

            if (Player.HealthPercent <= menu.Item("E_If_HP", true).GetValue <Slider>().Value)
            {
                return;
            }

            if (vec.Distance(target.ServerPosition) < Player.AttackRange)
            {
                E.Cast(vec);
            }
        }
Beispiel #28
0
        public static bool IsSafe(this Vector3 position, bool noQIntoEnemiesCheck = false)
        {
            if (position.UnderTurret(true) && !ObjectManager.Player.UnderTurret(true))
            {
                return(false);
            }

            var allies    = position.CountAlliesInRange(ObjectManager.Player.AttackRange);
            var enemies   = position.CountEnemiesInRange(ObjectManager.Player.AttackRange);
            var lhEnemies = position.GetLhEnemiesNear(ObjectManager.Player.AttackRange, 15).Count();

            if (enemies <= 1) ////It's a 1v1, safe to assume I can Q
            {
                return(true);
            }

            if (position.UnderAllyTurret_Ex())
            {
                var nearestAllyTurret = ObjectManager.Get <Obj_AI_Turret>().Where(a => a.IsAlly).OrderBy(d => d.Distance(position, true)).FirstOrDefault();

                if (nearestAllyTurret != null)
                {
                    ////We're adding more allies, since the turret adds to the firepower of the team.
                    allies += 2;
                }
            }

            ////Adding 1 for my Player
            var normalCheck   = (allies + 1 > enemies - lhEnemies);
            var QEnemiesCheck = true;

            if (getCheckBoxItem(MenuGenerator.miscMenu, "dz191.vhr.misc.tumble.noqenemies") && noQIntoEnemiesCheck)
            {
                if (!getCheckBoxItem(MenuGenerator.miscMenu, "dz191.vhr.misc.tumble.noqenemies.old"))
                {
                    var Vector2Position = position.To2D();
                    var enemyPoints     = getCheckBoxItem(MenuGenerator.miscMenu, "dz191.vhr.misc.tumble.dynamicqsafety")
                        ? GetEnemyPoints()
                        : GetEnemyPoints(false);
                    if (enemyPoints.Contains(Vector2Position) &&
                        !getCheckBoxItem(MenuGenerator.miscMenu, "dz191.vhr.misc.tumble.qspam"))
                    {
                        QEnemiesCheck = false;
                    }

                    var closeEnemies =
                        HeroManager.Enemies.FindAll(en => en.IsValidTarget(1500f) && !(en.Distance(ObjectManager.Player.ServerPosition) < en.AttackRange + 65f))
                        .OrderBy(en => en.Distance(position));

                    if (
                        !closeEnemies.All(
                            enemy =>
                            position.CountEnemiesInRange(
                                getCheckBoxItem(MenuGenerator.miscMenu, "dz191.vhr.misc.tumble.dynamicqsafety")
                                        ? enemy.AttackRange
                                        : 405f) <= 1))
                    {
                        QEnemiesCheck = false;
                    }
                }
                else
                {
                    var closeEnemies =
                        HeroManager.Enemies.FindAll(en => en.IsValidTarget(1500f)).OrderBy(en => en.Distance(position));
                    if (closeEnemies.Any())
                    {
                        QEnemiesCheck =
                            !closeEnemies.All(
                                enemy =>
                                position.CountEnemiesInRange(
                                    getCheckBoxItem(MenuGenerator.miscMenu, "dz191.vhr.misc.tumble.dynamicqsafety")
                                            ? enemy.AttackRange
                                            : 405f) <= 1);
                    }
                }
            }

            return(normalCheck && QEnemiesCheck);
        }
Beispiel #29
0
        public static bool IsSafe(this Vector3 position, bool noQIntoEnemiesCheck = false)
        {
            if (other.UnderEnemyTower((Vector2)position) && !other.UnderEnemyTower((Vector2)Variables._Player.Position))
            {
                return(false);
            }

            var allies    = position.CountAlliesInRange(Variables._Player.AttackRange);
            var enemies   = position.CountEnemiesInRange(Variables._Player.AttackRange);
            var lhEnemies = position.GetLhEnemiesNear(Variables._Player.AttackRange, 15).Count();

            if (enemies <= 1) ////It's a 1v1, safe to assume I can Q
            {
                return(true);
            }

            if (position.UnderAllyTurret_Ex())
            {
                var nearestAllyTurret = ObjectManager.Get <Obj_AI_Turret>().Where(a => a.IsAlly).OrderBy(d => d.Distance(position, true)).FirstOrDefault();

                if (nearestAllyTurret != null)
                {
                    ////We're adding more allies, since the turret adds to the firepower of the team.
                    allies += 2;
                }
            }

            ////Adding 1 for my Player
            var normalCheck   = (allies + 1 > enemies - lhEnemies);
            var QEnemiesCheck = true;

            if (MenuManager.Qsettings["UseQE"].Cast <CheckBox>().CurrentValue&& noQIntoEnemiesCheck)
            {
                if (!MenuManager.Qsettings["UseQE"].Cast <CheckBox>().CurrentValue)
                {
                    var Vector2Position = position.To2D();
                    var enemyPoints     = MenuManager.Qsettings["UseSafeQ"].Cast <CheckBox>().CurrentValue
                        ? GetEnemyPoints()
                        : GetEnemyPoints(false);
                    if (enemyPoints.Contains(Vector2Position) &&
                        !MenuManager.Qsettings["UseQspam"].Cast <CheckBox>().CurrentValue)
                    {
                        QEnemiesCheck = false;
                    }

                    var closeEnemies =
                        EntityManager.Heroes.Enemies.FindAll(en => en.IsValidTarget(1500f) && !(en.Distance(Variables._Player.ServerPosition) < en.AttackRange + 65f))
                        .OrderBy(en => en.Distance(position));

                    if (
                        !closeEnemies.All(
                            enemy =>
                            position.CountEnemiesInRange(
                                MenuManager.Qsettings["UseSafeQ"].Cast <CheckBox>().CurrentValue
                                        ? enemy.AttackRange
                                        : 405f) <= 1))
                    {
                        QEnemiesCheck = false;
                    }
                }
                else
                {
                    var closeEnemies =
                        EntityManager.Heroes.Enemies.FindAll(en => en.IsValidTarget(1500f)).OrderBy(en => en.Distance(position));
                    if (closeEnemies.Any())
                    {
                        QEnemiesCheck =
                            !closeEnemies.All(
                                enemy =>
                                position.CountEnemiesInRange(
                                    MenuManager.Qsettings["UseSafeQ"].Cast <CheckBox>().CurrentValue
                                            ? enemy.AttackRange
                                            : 405f) <= 1);
                    }
                }
            }

            return(normalCheck && QEnemiesCheck);
        }
Beispiel #30
0
 public static int CountEnemysInRange(this Vector3 point, float range)
 {
     return(point.CountEnemiesInRange(range));
 }
Beispiel #31
0
        public static Vector3 CastDash()
        {
            int DashMode = MenuManager.Qsettings["QNmode"].Cast <ComboBox>().CurrentValue;

            Vector3 bestpoint = Vector3.Zero;

            if (DashMode == 0)
            {
                var orbT = TargetSelector.GetTarget((int)Variables._Player.GetAutoAttackRange(),
                                                    DamageType.Physical);
                if (orbT != null)
                {
                    Vector2 start = Variables._Player.Position.To2D();
                    Vector2 end   = orbT.Position.To2D();
                    var     dir   = (end - start).Normalized();
                    var     pDir  = dir.Perpendicular();

                    var rightEndPos = end + pDir * Variables._Player.Distance(orbT);
                    var leftEndPos  = end - pDir * Variables._Player.Distance(orbT);

                    var rEndPos = new Vector3(rightEndPos.X, rightEndPos.Y, Variables._Player.Position.Z);
                    var lEndPos = new Vector3(leftEndPos.X, leftEndPos.Y, Variables._Player.Position.Z);

                    if (Game.CursorPos.Distance(rEndPos) < Game.CursorPos.Distance(lEndPos))
                    {
                        bestpoint = (Vector3)Variables._Player.Position.Extend(rEndPos, Program.Q.Range);
                        if (IsGoodPosition(bestpoint))
                        {
                            Cast(bestpoint);
                        }
                    }
                    else
                    {
                        bestpoint = (Vector3)Variables._Player.Position.Extend(lEndPos, Program.Q.Range);
                        if (IsGoodPosition(bestpoint))
                        {
                            Cast(bestpoint);
                        }
                    }
                }
            }
            else if (DashMode == 1)
            {
                var points = CirclePoints(12, Program.Q.Range, Variables._Player.Position);
                bestpoint = (Vector3)Variables._Player.Position.Extend(Game.CursorPos, Program.Q.Range);
                int enemies = bestpoint.CountEnemiesInRange(400);
                foreach (var point in points)
                {
                    int count = point.CountEnemiesInRange(400);
                    if (count < enemies)
                    {
                        enemies   = count;
                        bestpoint = point;
                    }
                    else if (count == enemies && Game.CursorPos.Distance(point) < Game.CursorPos.Distance(bestpoint))
                    {
                        enemies   = count;
                        bestpoint = point;
                    }
                }
                if (IsGoodPosition(bestpoint))
                {
                    Cast(bestpoint);
                }
            }

            if (!bestpoint.IsZero && bestpoint.CountEnemiesInRange(Variables._Player.BoundingRadius + Variables._Player.AttackRange + 100) == 0)
            {
                return(Vector3.Zero);
            }

            return(bestpoint);
        }
Beispiel #32
0
        public static bool IsSafePosition(Vector3 position)
        {
            var enemies = position.CountEnemiesInRange(800);
            var allies = CountAlliesInRange(position);
            var turrets = EntityManager.Turrets.Allies.Count(x => Player.Distance(x) < 800 && x.IsValid && !x.IsDead);
            var lowEnemies = GetLowaiAiHeroClients(position, 800).Count();

            if (UnderEnemyTurret(position)) return false;

            if (enemies == 1)
            {
                return true;
            }
            return allies + turrets > enemies - lowEnemies;
        }
Beispiel #33
0
        private void LogicR()
        {
            foreach (var t in Program.Enemies.Where(t => t.IsValidTarget() && BallPos.Distance(Prediction.GetPrediction(t, R.Delay).CastPosition) < R.Width && BallPos.Distance(t.ServerPosition) < R.Width))
            {
                if (Program.Combo && Config.Item("Ralways" + t.ChampionName, true).GetValue <bool>())
                {
                    R.Cast();
                }

                if (Config.Item("Rks", true).GetValue <bool>())
                {
                    var comboDmg = OktwCommon.GetKsDamage(t, R);

                    if (t.IsValidTarget(Q.Range))
                    {
                        comboDmg += Q.GetDamage(t);
                    }
                    if (W.IsReady())
                    {
                        comboDmg += W.GetDamage(t);
                    }
                    if (Orbwalker.InAutoAttackRange(t))
                    {
                        comboDmg += (float)Player.GetAutoAttackDamage(t) * 2;
                    }
                    if (t.Health < comboDmg)
                    {
                        R.Cast();
                    }
                    Program.debug("ks");
                }
                if (Config.Item("Rturrent", true).GetValue <bool>() && BallPos.UnderTurret(false) && !BallPos.UnderTurret(true))
                {
                    R.Cast();
                    Program.debug("Rturrent");
                }
                if (Config.Item("Rlifesaver", true).GetValue <bool>() && Player.Health < Player.CountEnemiesInRange(800) * Player.Level * 20 && Player.Distance(BallPos) > t.Distance(Player.Position))
                {
                    R.Cast();
                    Program.debug("ls");
                }
            }

            int countEnemies = CountEnemiesInRangeDeley(BallPos, R.Width, R.Delay);

            if (countEnemies >= Config.Item("rCount", true).GetValue <Slider>().Value&& BallPos.CountEnemiesInRange(R.Width) == countEnemies)
            {
                R.Cast();
            }
        }
Beispiel #34
0
        private static void LogicE()
        {
            if (Player.HasBuff("LuxLightStrikeKugel") && !Program.None)
            {
                int eBig = Epos.CountEnemiesInRange(350);
                if (getCheckBoxItem(eMenu, "autoEslow"))
                {
                    int detonate = eBig - Epos.CountEnemiesInRange(160);

                    if (detonate > 0 || eBig > 1)
                    {
                        E.Cast();
                    }
                }
                else if (getCheckBoxItem(eMenu, "autoEdet"))
                {
                    if (eBig > 0)
                    {
                        E.Cast();
                    }
                }
                else
                {
                    E.Cast();
                }
            }
            else
            {
                var t = TargetSelector.GetTarget(E.Range, DamageType.Magical);
                if (t.LSIsValidTarget())
                {
                    if (!getCheckBoxItem(eMenu, "autoEcc"))
                    {
                        if (Program.Combo && Player.Mana > RMANA + EMANA)
                        {
                            Program.CastSpell(E, t);
                        }
                        else if (Program.Farm && OktwCommon.CanHarras() && getCheckBoxItem(eMenu, "harrasE") && Player.Mana > RMANA + EMANA + EMANA + RMANA)
                        {
                            Program.CastSpell(E, t);
                        }
                        else if (OktwCommon.GetKsDamage(t, E) > t.Health)
                        {
                            Program.CastSpell(E, t);
                        }
                    }

                    foreach (var enemy in Program.Enemies.Where(enemy => enemy.LSIsValidTarget(E.Range) && !OktwCommon.CanMove(enemy)))
                    {
                        E.Cast(enemy, true);
                    }
                }
                else if (Program.LaneClear && Player.ManaPercent > getSliderItem(farmMenu, "Mana") && getCheckBoxItem(farmMenu, "farmE") && Player.Mana > RMANA + WMANA)
                {
                    var minionList   = Cache.GetMinions(Player.ServerPosition, E.Range);
                    var farmPosition = E.GetCircularFarmLocation(minionList, E.Width);

                    if (farmPosition.MinionsHit > getSliderItem(farmMenu, "LCminions"))
                    {
                        E.Cast(farmPosition.Position);
                    }
                }
            }
        }
Beispiel #35
0
        public static bool IsSafeEx(Vector3 position)
        {
            var closeEnemies =
                    HeroManager.Enemies.FindAll(en => en.IsValidTarget(1500f) && !(en.Distance(ObjectManager.Player.ServerPosition) < en.AttackRange + 65f))
                    .OrderBy(en => en.Distance(position));

            return closeEnemies.All(
                                enemy =>
                                    position.CountEnemiesInRange(
                                        MenuExtensions.GetItemValue<bool>("dz191.vhr.misc.tumble.dynamicqsafety")
                                            ? enemy.AttackRange
                                            : 405f) <= 1);
        }
Beispiel #36
0
 public bool InAARange(Vector3 point)
 {
     if (!getCheckBoxItem("AAcheck"))
         return true;
     if (Orbwalker.LastTarget != null && Orbwalker.LastTarget.Type == GameObjectType.AIHeroClient)
     {
         return point.LSDistance(Orbwalker.LastTarget.Position) < Player.AttackRange;
     }
     return point.CountEnemiesInRange(Player.AttackRange) > 0;
 }
Beispiel #37
0
        public bool IsGoodPosition(Vector3 dashPos)
        {
            if (getCheckBoxItem("WallCheck"))
            {
                var segment = DashSpell.Range / 5;
                for (var i = 1; i <= 5; i++)
                {
                    if (Player.Position.LSExtend(dashPos, i * segment).LSIsWall())
                        return false;
                }
            }

            if (getCheckBoxItem("TurretCheck"))
            {
                if (dashPos.UnderTurret(true))
                    return false;
            }

            var enemyCheck = getSliderItem("EnemyCheck");
            var enemyCountDashPos = dashPos.CountEnemiesInRange(600);

            if (enemyCheck > enemyCountDashPos)
                return true;

            var enemyCountPlayer = Player.CountEnemiesInRange(400);

            if (enemyCountDashPos <= enemyCountPlayer)
                return true;

            return false;
        }
Beispiel #38
0
        public Vector3 CastDash()
        {
            int DashMode = Config.Item("DashMode", true).GetValue <StringList>().SelectedIndex;

            Vector3 bestpoint = Vector3.Zero;

            if (DashMode == 0)
            {
                bestpoint = Player.Position.Extend(Game.CursorPos, DashSpell.Range);
                if (IsGoodPosition(bestpoint))
                {
                    DashSpell.Cast(bestpoint);
                }
            }
            else if (DashMode == 1)
            {
                var orbT = Orbwalker.GetTarget();
                if (orbT != null && orbT.Type == GameObjectType.obj_AI_Hero)
                {
                    Vector2 start = Player.Position.To2D();
                    Vector2 end   = orbT.Position.To2D();
                    var     dir   = (end - start).Normalized();
                    var     pDir  = dir.Perpendicular();

                    var rightEndPos = end + pDir * Player.Distance(orbT);
                    var leftEndPos  = end - pDir * Player.Distance(orbT);

                    var rEndPos = new Vector3(rightEndPos.X, rightEndPos.Y, Player.Position.Z);
                    var lEndPos = new Vector3(leftEndPos.X, leftEndPos.Y, Player.Position.Z);

                    if (Game.CursorPos.Distance(rEndPos) < Game.CursorPos.Distance(lEndPos))
                    {
                        bestpoint = Player.Position.Extend(rEndPos, DashSpell.Range);
                        if (IsGoodPosition(bestpoint))
                        {
                            DashSpell.Cast(bestpoint);
                        }
                    }
                    else
                    {
                        bestpoint = Player.Position.Extend(lEndPos, DashSpell.Range);
                        if (IsGoodPosition(bestpoint))
                        {
                            DashSpell.Cast(bestpoint);
                        }
                    }
                }
            }
            else if (DashMode == 2)
            {
                var points = OktwCommon.CirclePoints(12, DashSpell.Range, Player.Position);
                bestpoint = Player.Position.Extend(Game.CursorPos, DashSpell.Range);
                int enemies = bestpoint.CountEnemiesInRange(400);
                foreach (var point in points)
                {
                    int count = point.CountEnemiesInRange(400);
                    if (count < enemies)
                    {
                        enemies   = count;
                        bestpoint = point;
                    }
                    else if (count == enemies && Game.CursorPos.Distance(point) < Game.CursorPos.Distance(bestpoint))
                    {
                        enemies   = count;
                        bestpoint = point;
                    }
                }
                if (IsGoodPosition(bestpoint))
                {
                    DashSpell.Cast(bestpoint);
                }
            }

            if (!bestpoint.IsZero && bestpoint.CountEnemiesInRange(Player.BoundingRadius + Player.AttackRange + 100) == 0)
            {
                return(Vector3.Zero);
            }

            return(bestpoint);
        }
Beispiel #39
0
        public static bool IsSafeEx(Vector3 position)
        {
            var closeEnemies =
                    HeroManager.Enemies.FindAll(en => en.LSIsValidTarget(1500f) && !(en.LSDistance(ObjectManager.Player.ServerPosition) < en.AttackRange + 65f))
                    .OrderBy(en => en.LSDistance(position));

            return closeEnemies.All(
                                enemy =>
                                    position.CountEnemiesInRange(
                                        MenuGenerator.miscMenu["dz191.vhr.misc.tumble.dynamicqsafety"].Cast<CheckBox>().CurrentValue
                                            ? enemy.AttackRange
                                            : 405f) <= 1);
        }