Beispiel #1
0
        private static void UltimateLock()
        {
            Obj_AI_Hero      target           = TargetSelector.GetTarget(_spells[SpellSlot.R].Range, TargetSelector.DamageType.Physical);
            PredictionOutput targetPrediction = _spells[SpellSlot.R].GetPrediction(target);

            Vector3 endPosition  = Vector3.Normalize(_player.ServerPosition - target.ServerPosition);
            Vector3 castPosition = targetPrediction.CastPosition;

            Vector3 fullPoint =
                new Vector2(
                    castPosition.X + endPosition.X * _spells[SpellSlot.R].Range * 0.98f,
                    castPosition.Y + endPosition.Y * _spells[SpellSlot.R].Range * 0.98f).To3D();
            Vector3 closestPoint =
                _player.ServerPosition.To2D().Closest(new List <Vector3> {
                castPosition, fullPoint
            }.To2D()).To3D();

            if (closestPoint.IsValid() && !closestPoint.IsWall() &&
                castPosition.Distance(closestPoint) > _spells[SpellSlot.E].Range)
            {
                _player.IssueOrder(GameObjectOrder.MoveTo, closestPoint);
            }
            else if (fullPoint.IsValid() && !fullPoint.IsWall() &&
                     castPosition.Distance(fullPoint) < _spells[SpellSlot.R].Range &&
                     castPosition.Distance(fullPoint) > 100)
            {
                _player.IssueOrder(GameObjectOrder.MoveTo, fullPoint);
            }
        }
Beispiel #2
0
        private static bool CheckPosStun(Vector3 pos)
        {
            if (pos.IsWall())
            {
                return(true);
            }
            if (pos.Extend(Player.Position, -120).IsWall())
            {
                return(true);
            }
            var result = GetRockObject(200, pos);

            if (result != null)
            {
                return(true);
            }
            else
            {
                result = GetGrassObject(50, pos);

                if (result != null)
                {
                    return(true);
                }
                else
                {
                    return(IsWater(pos));
                }
            }
        }
Beispiel #3
0
        public static bool CanWallJump(Vector3 dashEndPos)
        {
            var firstWallPoint = GetFirstWallPoint(ObjectManager.Player.Position, dashEndPos);

            if (firstWallPoint.Equals(Vector3.Zero))
            {
                return(false);
            }

            if (dashEndPos.IsWall())
            {
                var wallWidth = GetWallWidth(firstWallPoint, dashEndPos);

                if (wallWidth > 50 && wallWidth - firstWallPoint.Distance(dashEndPos) < wallWidth * 0.4f)
                {
                    return(true);
                }
            }
            else
            {
                return(true);
            }

            return(false);
        }
Beispiel #4
0
        public void SelectedCondemn()
        {
            switch (Config.Item("condemn.style").GetValue <StringList>().SelectedIndex)
            {
            case 0:
                foreach (var target in HeroManager.Enemies.Where(h => h.IsValidTarget(Spells[E].Range)))
                {
                    if (Config.Item("condemnset." + target.CharData.BaseSkinName).GetValue <bool>())
                    {
                        var   pushDistance   = Config.Item("condemn.distance").GetValue <Slider>().Value;
                        var   targetPosition = Spells[E].GetPrediction(target).UnitPosition;
                        var   pushDirection  = (targetPosition - ObjectManager.Player.ServerPosition).Normalized();
                        float checkDistance  = pushDistance / 40f;
                        for (int i = 0; i < 40; i++)
                        {
                            Vector3 finalPosition = targetPosition + (pushDirection * checkDistance * i);
                            var     collFlags     = NavMesh.GetCollisionFlags(finalPosition);
                            if (collFlags.HasFlag(CollisionFlags.Wall) || collFlags.HasFlag(CollisionFlags.Building))     //not sure about building, I think its turrets, nexus etc
                            {
                                Spells[E].Cast(target);
                            }
                        }
                    }
                }
                break;

            case 1:
                foreach (var En in HeroManager.Enemies.Where(hero => hero.IsValidTarget(Spells[E].Range) && !hero.HasBuffOfType(BuffType.SpellShield) && !hero.HasBuffOfType(BuffType.SpellImmunity)))
                {
                    if (Config.Item("condemnset." + En.CharData.BaseSkinName).GetValue <bool>())
                    {
                        var EPred         = Spells[E].GetPrediction(En);
                        int pushDist      = Config.Item("condemn.distance").GetValue <Slider>().Value;
                        var FinalPosition = EPred.UnitPosition.To2D().Extend(ObjectManager.Player.ServerPosition.To2D(), -pushDist).To3D();

                        for (int i = 1; i < pushDist; i += (int)En.BoundingRadius)
                        {
                            Vector3 loc3 = EPred.UnitPosition.To2D().Extend(ObjectManager.Player.ServerPosition.To2D(), -i).To3D();

                            if (loc3.IsWall() || AsunasAllyFountain(FinalPosition))
                            {
                                Spells[E].Cast(En);
                            }
                        }
                    }
                }
                break;

            case 2:
                foreach (var enemy in HeroManager.Enemies.Where(x => x.IsValidTarget(Spells[E].Range) && !x.HasBuffOfType(BuffType.SpellShield) && !x.HasBuffOfType(BuffType.SpellImmunity) &&
                                                                IsCondemable(x)))
                {
                    if (Config.Item("condemnset." + enemy.CharData.BaseSkinName).GetValue <bool>())
                    {
                        Spells[E].Cast(enemy);
                    }
                }
                break;
            }
        }
Beispiel #5
0
        private static void WardJump(Vector3 where, bool move = true, bool placeward = true)
        {
            if (move)
            {
                Orbwalking.MoveTo(Game.CursorPos);
            }
            if (!E.IsReady())
            {
                return;
            }
            Vector3     wardJumpPosition = Player.Position.Distance(where) < 600 ? where : Player.Position.Extend(where, 600);
            var         lstGameObjects   = ObjectManager.Get <Obj_AI_Base>().ToArray();
            Obj_AI_Base entityToWardJump = lstGameObjects.FirstOrDefault(obj =>
                                                                         obj.Position.Distance(wardJumpPosition) < 150 &&
                                                                         (obj is Obj_AI_Minion || obj is Obj_AI_Hero) &&
                                                                         !obj.IsMe && !obj.IsDead &&
                                                                         obj.Position.Distance(Player.Position) < E.Range);

            if (entityToWardJump != null)
            {
                E.Cast(entityToWardJump);
            }
            else if (placeward)
            {
                int wardId = GetWardItem();
                if (wardId != -1 && !wardJumpPosition.IsWall())
                {
                    WardJumpReady = true;
                    PutWard(wardJumpPosition.To2D(), (ItemId)wardId);
                }
            }
        }
Beispiel #6
0
        private void Drawing_OnDraw(EventArgs args)
        {
            if (!ObjectManager.Player.IsDead)
            {
                if (MenuProvider.Champion.Drawings.DrawQrange.Active && Q.isReadyPerfectly())
                {
                    Render.Circle.DrawCircle(ObjectManager.Player.Position, Q.Range, MenuProvider.Champion.Drawings.DrawQrange.Color);
                }

                if (MenuProvider.Champion.Drawings.DrawErange.Active && E.isReadyPerfectly())
                {
                    Render.Circle.DrawCircle(ObjectManager.Player.Position, E.Range, MenuProvider.Champion.Drawings.DrawErange.Color);
                }

                var DrawECrashPrediction = MenuProvider.Champion.Drawings.getCircleValue("Draw E Crash Prediction");
                if (DrawECrashPrediction.Active)
                {
                    foreach (var enemy in HeroManager.Enemies.Where(x => x.IsValidTarget(E.Range)))
                    {
                        var Prediction = E.GetPrediction(enemy);
                        for (int i = 1; i < 400; i += 50)
                        {
                            Vector3 loc3 = Prediction.UnitPosition.Extend(ObjectManager.Player.Position, -i);
                            if (loc3.IsWall())
                            {
                                Render.Circle.DrawCircle(loc3, 30, DrawECrashPrediction.Color, 5, false);
                            }
                        }
                    }
                }
            }
        }
Beispiel #7
0
 public static bool IsDangerousPosition(this Vector3 pos)
 {
     return(GameObjects.EnemyHeroes.Any(e =>
                                        e.IsValidTarget(1000) && e.IsVisible &&
                                        e.Distance(pos) < Program.MainMenu.GetMenuSlider("Combo Settings", "QMinDist")) ||
            Traps.EnemyTraps.Any(t => pos.Distance(t.Position) < 125) && pos.IsWall());
 }
Beispiel #8
0
        static void Game_OnGameUpdate(EventArgs args)
        {
            List <Vector2> Circles = new List <Vector2>();

            foreach (Obj_AI_Hero target in ObjectManager.Get <Obj_AI_Hero>().Where((target) =>
            {
                Vector2 pos = Drawing.WorldToScreen(target.ServerPosition);
                return(target.IsEnemy && !target.IsDead && target.IsValid && !target.IsImmovable && target.IsVisible && pos.X < Drawing.Width && pos.X > 0 && pos.Y < Drawing.Height && pos.Y > 0);
            }))
            {
                Vector2 targetPos     = target.ServerPosition.To2D();
                Vector2 rotatedVector = target.ServerPosition.To2D().Extend(new Vector2(0, 0), E.Range);


                // now lets rotate it 360 degrees and find the right angles for it :)
                for (int i = 0; i < 30; i++)
                {
                    Vector2 curRotatedVector = rotatedVector.RotateAroundPoint(targetPos, (float)(Math.PI / 180) * 12 * i);

                    // now lets do a basic check if we can condemn from here
                    for (float j = 30; j <= 450; j += 30)
                    {
                        Vector3 curPos = targetPos.Extend(curRotatedVector, -j).To3D();

                        if (curPos.IsWall())
                        {
                            Circles.Add(curRotatedVector);
                            break;
                        }
                    }
                }
            }

            standPositions = Circles;
        }
Beispiel #9
0
        public static void WardJump()
        {
            Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
            if (!Q.IsReady())
            {
                return;
            }
            Vector3     wardJumpPosition = (Player.Position.Distance(Game.CursorPos) < 600) ? Game.CursorPos : Player.Position.Extend(Game.CursorPos, 600);
            var         lstGameObjects   = ObjectManager.Get <Obj_AI_Base>().ToArray();
            Obj_AI_Base entityToWardJump = lstGameObjects.FirstOrDefault(obj =>
                                                                         obj.Position.Distance(wardJumpPosition) < 150 &&
                                                                         (obj is Obj_AI_Minion || obj is Obj_AI_Hero) &&
                                                                         !obj.IsMe && !obj.IsDead &&
                                                                         obj.Position.Distance(Player.Position) < Q.Range);

            if (entityToWardJump != null)
            {
                Q.Cast(entityToWardJump);
            }
            else
            {
                int wardId = GetWardItem();


                if (wardId != -1 && !wardJumpPosition.IsWall())
                {
                    PutWard(wardJumpPosition.To2D(), (ItemId)wardId);
                    lstGameObjects = ObjectManager.Get <Obj_AI_Base>().ToArray();
                    Q.Cast(
                        lstGameObjects.FirstOrDefault(obj =>
                                                      obj.Position.Distance(wardJumpPosition) < 150 &&
                                                      obj is Obj_AI_Minion && obj.Position.Distance(Player.Position) < Q.Range));
                }
            }
        }
Beispiel #10
0
 /// <summary>
 ///     Executes to the specified position.
 /// </summary>
 /// <param name="position">The position.</param>
 private void Execute(Vector3 position)
 {
     if (!position.IsWall() && position.IsValid())
     {
         GlobalVariables.Player.Spellbook.CastSpell(this.FlashSlot, position);
     }
 }
        public static bool WillStun(this PredictionResult pred)
        {
            var EndPoint  = Player.Instance.Position.Extend(pred.CastPosition, Spells.Q.Range).To3D();
            var Rectangle = new Geometry.Polygon.Rectangle(Player.Instance.Position, EndPoint, Spells.Q.Width);
            var Count     = ObjectManager.Get <Obj_AI_Base>().Where(x => x.IsValidTarget() && Rectangle.IsInside(x)).Count();

            if (pred.CollisionObjects.Any())
            {
                return(true);
            }
            if (Count >= 2)
            {
                return(true);
            }
            var   Distance      = Spells.Q.Range - Player.Instance.Distance(pred.UnitPosition);
            float checkDistance = Distance / 50f;

            for (int i = 0; i <= 50; i++)
            {
                Vector3 finalPosition = Player.Instance.Position.Extend(pred.UnitPosition, Player.Instance.Distance(pred.UnitPosition) + i * checkDistance).To3DWorld();
                if (finalPosition.IsWall() || finalPosition.IsBuilding())
                {
                    return(true);
                }
            }
            return(false);
        }
Beispiel #12
0
 bool CondemnCheck(Vector3 Position, out Obj_AI_Hero target)
 {
     if (Sector.inTowerRange(player.Position.To2D()))
     {
         target = null;
         return(false);
     }
     foreach (var En in DeathWalker.AllEnemys.Where(hero => hero.IsEnemy && hero.IsValidTarget() && hero.Distance(player.Position) <= E.Range))
     {
         var EPred         = E.GetPrediction(En);
         int pushDist      = 300;
         var FinalPosition = EPred.UnitPosition.To2D().Extend(Position.To2D(), -pushDist).To3D();
         for (int i = 1; i < pushDist; i += (int)En.BoundingRadius)
         {
             Vector3 loc3     = EPred.UnitPosition.To2D().Extend(Position.To2D(), -i).To3D();
             var     OrTurret = Sector.inTowerRange(FinalPosition.To2D());
             AfterCond = loc3;
             if (loc3.IsWall() || OrTurret)
             {
                 target = En;
                 return(true);
             }
         }
     }
     target = null;
     return(false);
 }
Beispiel #13
0
        public static Vector3 GetBestPosition(AIHeroClient target, Vector3 firstPosition, Vector3 secondPosition)
        {
            if (firstPosition.IsWall() && !secondPosition.IsWall() &&
                secondPosition.LSDistance(target.ServerPosition) < firstPosition.LSDistance(target.ServerPosition))
            // if firstposition is a wall and second position isn't
            {
                return(secondPosition); //return second position
            }
            if (secondPosition.IsWall() && !firstPosition.IsWall() &&
                firstPosition.LSDistance(target.ServerPosition) < secondPosition.LSDistance(target.ServerPosition))
            // if secondPosition is a wall and first position isn't
            {
                return(firstPosition); // return first position
            }

            return(firstPosition);
        }
Beispiel #14
0
        public static Vector3 GetBestPosition(AIHeroClient target, Vector3 firstPosition, Vector3 secondPosition)
        {
            if (firstPosition.IsWall() && !secondPosition.IsWall() &&
                secondPosition.LSDistance(target.ServerPosition) < firstPosition.LSDistance(target.ServerPosition))
                // if firstposition is a wall and second position isn't
            {
                return secondPosition; //return second position
            }
            if (secondPosition.IsWall() && !firstPosition.IsWall() &&
                firstPosition.LSDistance(target.ServerPosition) < secondPosition.LSDistance(target.ServerPosition))
                // if secondPosition is a wall and first position isn't
            {
                return firstPosition; // return first position
            }

            return firstPosition;
        }
Beispiel #15
0
 private static void OnDraw(EventArgs args)
 {
     if (LastCastAttempt + 1000 > Utils.TickCount)
     {
         Render.Circle.DrawCircle(FlashPosition, 100, FlashPosition.IsWall() ? Color.Red : Color.Green);
         Render.Circle.DrawCircle(WallPosition, 50, Color.Aqua);
     }
 }
Beispiel #16
0
 public static bool IsDangerousPosition(this Vector3 pos)
 {
     return
         (HeroManager.Enemies.Any(
              e => e.IsValidTarget() && e.IsVisible &&
              e.Distance(pos) < Program.ComboMenu.Item("QMinDist").GetValue <Slider>().Value) ||
          Traps.EnemyTraps.Any(t => pos.Distance(t.Position) < 125) ||
          (pos.UnderTurret(true) && !Player.UnderTurret(true)) || pos.IsWall());
 }
 public static bool IsDangerousPosition(this Vector3 pos)
 {
     return
         (HeroManager.Enemies.Any(
              e => e.IsValidTarget() && e.IsVisible &&
              e.Distance(pos) < 375) ||
          Traps.EnemyTraps.Any(t => pos.Distance(t.Position) < 125) ||
          (pos.UnderTurret(true) && !Player.UnderTurret(true)) || pos.IsWall());
 }
Beispiel #18
0
        private static void Game_OnGameUpdate(EventArgs args)
        {
            Orbwalker.SetAttack(true);
            //COMBO
            if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
            {
                var target = TargetSelector.GetTarget(1000, TargetSelector.DamageType.Physical);


                if (target.Buffs.Any(buff => buff.Name == "vaynesilvereddebuff" && buff.Count == 2) && Q.IsReady())
                {
                    Q.Cast(Game.CursorPos);
                }

                if (E.IsReady() && Config.Item("RushECombo").GetValue <bool>())
                {
                    foreach (var en in HeroManager.Enemies.Where(hero => hero.IsValidTarget(E.Range) && !hero.HasBuffOfType(BuffType.SpellShield) && !hero.HasBuffOfType(BuffType.SpellImmunity)))
                    {
                        //credits VayneHunterRework

                        var ePred         = E.GetPrediction(en);
                        int pushDist      = 425;
                        var FinalPosition = ePred.UnitPosition.To2D().Extend(Player.ServerPosition.To2D(), -pushDist).To3D();

                        for (int i = 1; i < pushDist; i += (int)en.BoundingRadius)
                        {
                            Vector3 loc3 = ePred.UnitPosition.To2D().Extend(Player.ServerPosition.To2D(), -i).To3D();

                            if (loc3.IsWall() || IsAllyFountain(FinalPosition))
                            {
                                E.Cast(en);
                            }
                        }
                    }
                }
            }
            if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed)
            {
                var target = TargetSelector.GetTarget(1000, TargetSelector.DamageType.Physical);
                var pT     = HeroManager.Enemies.Find(enemy => enemy.IsValidTarget(E.Range));

                if (target.Buffs.Any(buff => buff.Name == "vaynesilvereddebuff" && buff.Count == 2) && E.IsReady())
                {
                    if (pT != null && (pT is Obj_AI_Hero))
                    {
                        E.Cast(pT);
                    }
                }
            }

            if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
            {
            }
        }
Beispiel #19
0
        private static void WallJumpEvent()
        {
            if (true)
            {
                if (!Q.Ready)
                {
                    Me.IssueOrder(OrderType.MoveTo, Game.CursorPos);
                }
                else
                {
                    if (qStack < 2)
                    {
                        if (Game.TickCount - lastQTime < 500)
                        {
                            return;
                        }

                        Me.IssueOrder(OrderType.MoveTo, Game.CursorPos);
                        Q.Cast(Game.CursorPos);
                    }
                    else
                    {
                        Vector3 Position     = Game.CursorPos;
                        Vector3 JumpPosition = Me.ServerPosition.Extend(Game.CursorPos, 65);//65 = Riven.BoundRadius
                        if (JumpPosition.IsWall())
                        {
                            Position = JumpPosition;
                        }

                        Me.IssueOrder(OrderType.MoveTo, Position);

                        Vector3 EDashPosition  = Me.ServerPosition.Extend(Game.CursorPos, 300); // 300 = E.Range - less
                        Vector3 QDashPosition  = Me.ServerPosition.Extend(Game.CursorPos, 162); // 162 = Q.Range/2, this is real dash distance
                        Vector3 EQDashPosition = Me.ServerPosition.Extend(Game.CursorPos, 462); // 300 + 162

                        if (EDashPosition.IsWall() && E.Ready)
                        {
                            E.Cast(EDashPosition);
                        }

                        if (QDashPosition.IsWall() && Q.Ready)
                        {
                            Q.Cast(QDashPosition);
                        }

                        if (EQDashPosition.IsWall() && E.Ready && Q.Ready)
                        {
                            E.Cast(EQDashPosition);
                            Q.Cast(EQDashPosition);
                        }
                    }
                }
            }
        }
        public void Cast(AIHeroClient target)
        {
            PredictionItem predictionItem = predictionItems.First(x => x.Target == target);
            Vector3        castPosition   = predictionItem.GetPrediction();

            if (predictionItem.PredictionSpell.IsReady() && predictionItem.PredictionSpell.IsInRange(castPosition) &&
                !castPosition.IsWall())
            {
                predictionItem.PredictionSpell.Cast(castPosition);
            }
        }
Beispiel #21
0
        private static void PositionHelper()
        {
            if (Player.ChampionName == "Draven" || !Config.Item("positioningAssistant").GetValue <bool>() || AIOmode == 2)
            {
                return;
            }

            if (Player.IsMelee)
            {
                Orbwalker.SetOrbwalkingPoint(new Vector3());
                return;
            }

            foreach (var enemy in Enemies.Where(enemy => enemy.IsMelee && enemy.IsValidTarget(dodgeRange) && enemy.IsFacing(Player) && Config.Item("posAssistant" + enemy.ChampionName).GetValue <bool>()))
            {
                if (Player.FlatMagicDamageMod > Player.FlatPhysicalDamageMod)
                {
                    OktwCommon.blockAttack = true;
                }

                var     points    = OktwCommon.CirclePoints(20, 200, Player.Position);
                Vector3 bestPoint = Vector3.Zero;

                foreach (var point in points)
                {
                    if (enemy.Distance(point) > dodgeRange && (bestPoint == Vector3.Zero || Game.CursorPos.Distance(point) < Game.CursorPos.Distance(bestPoint)))
                    {
                        bestPoint = point;
                    }
                }

                if (enemy.Distance(bestPoint) > dodgeRange && !bestPoint.IsWall() && !bestPoint.UnderTurret(true))
                {
                    Orbwalker.SetOrbwalkingPoint(bestPoint);
                }
                else
                {
                    var fastPoint = enemy.ServerPosition.Extend(Player.ServerPosition, dodgeRange);
                    if (!fastPoint.IsWall() && !fastPoint.UnderTurret(true) && fastPoint.CountEnemiesInRange(dodgeRange) <= Player.CountEnemiesInRange(dodgeRange))
                    {
                        Orbwalker.SetOrbwalkingPoint(fastPoint);
                    }
                }
                dodgeTime = Game.Time;
                return;
            }

            Orbwalker.SetOrbwalkingPoint(new Vector3());
            if (OktwCommon.blockAttack == true)
            {
                OktwCommon.blockAttack = false;
            }
        }
Beispiel #22
0
        private static bool IsWater(Vector3 pos)
        {
            var result = false;

            rivers.ForEach(polygon => {
                if (polygon.IsInside(pos) && !pos.IsWall() && GetGrassObject(50, pos) == null)
                {
                    result = true;
                }
            });
            return(result);
        }
Beispiel #23
0
        public static void WardJumpJax()
        {
            Player.IssueOrder(GameObjectOrder.MoveTo, Player.Position.Extend(Game.CursorPos, 150));

            if (QJax.IsReady())
            {
                wardPosition = Game.CursorPos;
                Obj_AI_Minion Wards;
                if (Game.CursorPos.Distance(Program.Player.Position) <= 700)
                {
                    Wards = ObjectManager.Get <Obj_AI_Minion>().Where(ward => ward.Distance(Game.CursorPos) < 150 && !ward.IsDead).FirstOrDefault();
                }
                else
                {
                    Vector3 cursorPos = Game.CursorPos;
                    Vector3 myPos     = Player.ServerPosition;
                    Vector3 delta     = cursorPos - myPos;
                    delta.Normalize();
                    wardPosition = myPos + delta * (600 - 5);
                    Wards        = ObjectManager.Get <Obj_AI_Minion>().Where(ward => ward.Distance(wardPosition) < 150 && !ward.IsDead).FirstOrDefault();
                }
                if (Wards == null)
                {
                    if (!wardPosition.IsWall())
                    {
                        InventorySlot invSlot = Items.GetWardSlot();
                        Items.UseItem((int)invSlot.Id, wardPosition);
                        jumped = true;
                    }
                }

                else
                if (QJax.CastOnUnit(Wards))
                {
                    jumped = false;
                }
            }
        }
Beispiel #24
0
        /// <summary>
        /// Lấy 360 điểm xung quanh center với khoảng cách range với điều kiện không phải dưới trụ địch hoặc tường.
        /// </summary>
        /// <param name="center"></param>
        /// <param name="range"></param>
        /// <returns></returns>
        public static List <Vector3> GetSafePosCircle(this Obj_AI_Base center, int range)
        {
            var result = new List <Vector3>();

            for (int i = 0; i < 360; i += 1)
            {
                var v3 = new Vector3((float)(center.Position.X + range * Math.Cos(i * Math.PI / 180)), (float)(center.Position.Y + range * Math.Sin(i * Math.PI / 180)), ObjectManager.Player.Position.Z);
                if (!v3.IsWall() && v3.IsInTurret())
                {
                    result.Add(v3);
                }
            }
            return(result);
        }
Beispiel #25
0
        public static void VhrBasicJungleCondemn(Obj_AI_Minion hero)
        {
            var ePred         = VayneSpells.E.GetPrediction(hero);
            int pushDist      = PushDistance;
            var finalPosition = ePred.UnitPosition.To2D().Extend(ObjectManager.Player.ServerPosition.To2D(), -pushDist).To3D();

            for (int i = 1; i < pushDist; i += (int)hero.BoundingRadius)
            {
                Vector3 loc3 = ePred.UnitPosition.To2D().Extend(ObjectManager.Player.ServerPosition.To2D(), -i).To3D();

                if (loc3.IsWall() || AsunasAllyFountain(finalPosition))
                {
                    VayneSpells.E.Cast(hero);
                }
            }
        }
Beispiel #26
0
        public static float GetPositionScore(AIHeroClient target, Vector3 position, bool countAllies = false, bool countAllyTurret = false, string getScoreOf = null)
        {
            const int wallScore  = 600;
            const int enemyScore = 300;

            // Count getting closer to allies as a positive score
            var alliesScore = 0f;

            if (countAllies)
            {
                alliesScore = EntityManager.Heroes.Allies.Where(ally => ally.WithinRange(position, ScanRange) && !ally.IsDead).Sum(ally => Math.Max(EffectiveAttackRange * 2 - ally.Distance(position), 0));

                if (getScoreOf != null && getScoreOf.Contains("alliesScore"))
                {
                    return(alliesScore);
                }
            }

            // Count getting closer to ally turret as a positive score
            var allyTurretScore = 0f;

            if (countAllyTurret)
            {
                var closeAllyTurret = EntityManager.Turrets.Allies.Where(turret => turret.WithinRange(position, TurretNearRange));
                if (closeAllyTurret.Any())
                {
                    allyTurretScore = Math.Max((TurretNearRange - closeAllyTurret.First().Distance(position)), 0) * 2f;
                }

                if (getScoreOf != null && getScoreOf.Contains("allyTurretScore"))
                {
                    return(allyTurretScore);
                }
            }

            // Calculations
            var enemies = position.EnemiesWithinRange(NearRange);
            var isWall  = (position.IsWall() || !position.IsValid() || NavMesh.GetCollisionFlags(position).HasFlag(CollisionFlags.Wall) || NavMesh.GetCollisionFlags(position).HasFlag(CollisionFlags.Building)) ? 1 : 0;

            return(-(Math.Abs(enemies - 1) * enemyScore)
                   - (isWall * wallScore)
                   + position.Distance(target)
                   + (TotalDistanceToEnemies(position, NearRange) / enemies)
                   + (allyTurretScore)
                   + alliesScore);
        }
Beispiel #27
0
        public static bool IsCondemnable(this Obj_AI_Base target, Vector3 fromPosition)
        {
            var   pushDistance   = MenuExtensions.GetItemValue <Slider>("dz191.vhr.misc.condemn.pushdistance").Value;
            var   targetPosition = target.ServerPosition;
            float checkDistance  = pushDistance / 40f;
            var   pushDirection  = (targetPosition - ObjectManager.Player.ServerPosition).Normalized();

            for (int i = 0; i < 40; i++)
            {
                Vector3 finalPosition = targetPosition + (pushDirection * checkDistance * i);
                if (finalPosition.IsWall())
                {
                    return(true);
                }
            }
            return(false);
        }
Beispiel #28
0
        public static bool Newjump()
        {
            Player.IssueOrder(GameObjectOrder.MoveTo, Player.Position.Extend(Game.CursorPos, 150));


            if (Program.W.IsReady() && ObjectManager.Player.Spellbook.GetSpell(SpellSlot.W).Name == "BlindMonkWOne")
            {
                wardPosition = Game.CursorPos;
                Obj_AI_Minion Wards;
                if (Game.CursorPos.Distance(Program.Player.Position) <= 700)
                {
                    Wards = ObjectManager.Get <Obj_AI_Minion>().Where(ward => ward.Distance(Game.CursorPos) < 150 && !ward.IsDead).FirstOrDefault();
                }
                else
                {
                    Vector3 cursorPos = Game.CursorPos;
                    Vector3 myPos     = Player.ServerPosition;
                    Vector3 delta     = cursorPos - myPos;
                    delta.Normalize();
                    wardPosition = myPos + delta * (600 - 5);
                    Wards        = ObjectManager.Get <Obj_AI_Minion>().Where(ward => ward.Distance(wardPosition) < 150 && !ward.IsDead).FirstOrDefault();
                }
                if (Wards == null && Items.GetWardSlot() != null)
                {
                    if (jumped == false)
                    {
                        if (!wardPosition.IsWall())
                        {
                            InventorySlot invSlot = Items.GetWardSlot();
                            Items.UseItem((int)invSlot.Id, wardPosition);
                            jumped = true;
                        }
                    }
                }

                else
                if (Program.W.CastOnUnit(Wards))
                {
                    jumped = false;
                }
            }

            return(false);
        }
Beispiel #29
0
 private void Game_OnUpdate(EventArgs args)
 {
     if (!ObjectManager.Player.IsDead)
     {
         switch (MenuProvider.Orbwalker.ActiveMode)
         {
         case Orbwalking.OrbwalkingMode.Combo:
         {
             if (MenuProvider.Champion.Combo.UseE)
             {
                 if (E.isReadyPerfectly())
                 {
                     foreach (var enemy in HeroManager.Enemies.Where(x => x.IsValidTarget(E.Range)))
                     {
                         var Prediction = E.GetPrediction(enemy);
                         if (Prediction.Hitchance >= E.MinHitChance)
                         {
                             var FinalPosition = Prediction.UnitPosition.Extend(ObjectManager.Player.Position, -400);
                             if (FinalPosition.IsWall())
                             {
                                 E.CastOnUnit(enemy);
                             }
                             else
                             {
                                 for (int i = 1; i < 400; i += 50)
                                 {
                                     Vector3 loc3 = Prediction.UnitPosition.Extend(ObjectManager.Player.Position, -i);
                                     if (loc3.IsWall())
                                     {
                                         E.CastOnUnit(enemy);
                                         break;
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
             break;
         }
         }
     }
 }
Beispiel #30
0
 private Vector3 GetRealPosition(Vector3 end)
 {
     if (end.IsWall())
     {
         for (var i = 0; i < 500; i = i + 2)
         {
             List <IntPoint> circlePath = new Geometry.Polygon.Circle(end, i, 10).ToClipperPath();
             foreach (var item in circlePath)
             {
                 Vector3 newPos = new Vector2(item.X, item.Y).To3D2();
                 if (!newPos.IsWall())
                 {
                     return(newPos);
                 }
             }
         }
     }
     return(end);
 }
Beispiel #31
0
        private static Vector3 FindNearestNonWall(Vector3 pos, float maxRadius)
        {
            if (!pos.IsWall())
            {
                return(pos);
            }
            maxRadius = (float)Math.Floor(maxRadius / 50);
            float x0     = (float)Math.Round(pos.X / 50) * 50;
            float z0     = (float)Math.Round(pos.Z / 50) * 50;
            float radius = 1;

            while (radius <= maxRadius)
            {
                if (CheckP(pos, x0, z0, 0, radius) || CheckP(pos, x0, z0, radius, 0) || CheckP(pos, x0, z0, 0, -radius) || CheckP(pos, x0, z0, -radius, 0))
                {
                    return(pos);
                }
                float f = 1 - radius;
                float x = 0;
                float y = radius;
                while (x < y - 1)
                {
                    x = x + 1;
                    if (f < 0)
                    {
                        f = f + 1 + 2 * x;
                    }
                    else
                    {
                        y = y - 1;
                        f = f + 1 + 2 * (x - y);
                    }
                    if (CheckP(pos, x0, z0, x, y) || CheckP(pos, x0, z0, -x, y) || CheckP(pos, x0, z0, x, -y) || CheckP(pos, x0, z0, -x, -y) ||
                        CheckP(pos, x0, z0, y, x) || CheckP(pos, x0, z0, -y, x) || CheckP(pos, x0, z0, y, -x) || CheckP(pos, x0, z0, -y, -x))
                    {
                        return(pos);
                    }
                }
                radius = radius + 1;
            }
            return(new Vector3(0, 0, 0));
        }
    //Credits to Honda (I think)
    private static Vector3 GetELandingPosition()
    {
        Vector3 castPoint = Player.Distance(Game.CursorPos) <= _e.Range
            ? Game.CursorPos
            : Player.Position.Extend(Game.CursorPos, _e.Range);

        for (var i = 0; i < 500; i += 9)
            for (double j = 0; j < 2 * Math.PI + 0.2; j += 0.2)
            {
                var c = new Vector3((castPoint.X + i * (float)Math.Cos(j)), castPoint.Y + i * (float)Math.Sin(j), castPoint.Z);
                if (!c.IsWall())
                    return c;
            }

        return castPoint;
    }
Beispiel #33
0
            private static void CastWard(Vector3 vector3)
            {
                var wardinrage = ObjectsManager.Wards.Any(ward => ward.IsInRange(vector3, 200));

                var ally = EntityManager.Heroes.Allies.Any(a => a.IsInRange(vector3, 200) && a.IsValidTarget() && !a.IsMe);

                var minion = EntityManager.MinionsAndMonsters.AlliedMinions.Any(m => m.IsInRange(vector3, 200) && m.IsValidTarget());

                if (UseWardReady && UseWard.IsInRange(vector3) && (!user.ServerPosition.Extend(vector3, 75).IsWall() || !vector3.IsWall()) && !wardinrage && !ally && !minion
                    && Core.GameTickCount - lastward > 1000)
                {
                    UseWard.Cast(vector3);
                    lastward = Core.GameTickCount;
                }
            }