public static bool MinionCollideLine(Vector3 lineStart, Vector3 lineFinish, Spell spell)
        {
            var minion =
                                MinionManager.GetMinions(spell.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.Health);
              //  Render.Circle.DrawCircle(ObjectManager.Player.Position, 100, System.Drawing.Color.Brown, 2);
            //   Render.Circle.DrawCircle(line_finish, 10, System.Drawing.Color.Red, 2);
            var d = lineStart.Distance(lineFinish);
            //    dis = (int)(dis /spell.Width);
            var circles = new List<Circle>();
            for (var i = 0; i < d; i += 10)
            {
                var dist = i > d ? d : i;
                var point = lineStart.Extend(lineFinish, +dist);
                circles.Add(new Circle(point, spell.Width));
            }
            foreach (var c in circles)
              {
              foreach (var m in minion)
              {
                  if (Geometry.CircleCircleIntersection(c.pos.To2D(), m.Position.To2D(), c.range, 100).Count()!=0)
                  {
                      return true;
                  }

              }
              }
            //  foreach(Obj_AI_Base m in minion)
            //  {
            //     m.
            //  }
            // Geometry.cu
            return false;
        }
Beispiel #2
0
 public static void Move_Draw(Vector3 Spell_Start, Vector3 Spell_End, double Spell_Time, int Distance, int Type)
 {            
     if (Spell_Start.Distance(Spell_End) > Distance){var dis = Spell_Start.Distance(Spell_End) - Distance;Spell_End = Spell_End.Extend(Spell_Start, +dis);}
     Render.Circle.DrawCircle(Spell_Start, 50, System.Drawing.Color.PaleVioletRed, 1);
     Render.Circle.DrawCircle(Spell_End, 50, System.Drawing.Color.LawnGreen, 1);
     var from = Drawing.WorldToScreen(Spell_Start);var to = Drawing.WorldToScreen(Spell_End);
     Drawing.DrawLine(from[0], from[1], to[0], to[1], 1, System.Drawing.Color.LawnGreen);
     Drawing.DrawText(from[0], from[1], System.Drawing.Color.PaleVioletRed, "Start");
     Drawing.DrawText(to[0], to[1], System.Drawing.Color.PaleVioletRed, "End");
 }
        public Vector3 GetFirstWallPoint(Vector3 start, Vector3 end, float range)
        {
            if (end.IsValid() && start.Distance(end) <= range)
            {
                var newPoint = start.Extend(end, range);

                return NavMesh.GetCollisionFlags(newPoint) == CollisionFlags.Wall || newPoint.IsWall()
                           ? newPoint
                           : Vector3.Zero;
            }
            return Vector3.Zero;
        }
Beispiel #4
0
        //my condemn logic so far
        public static Obj_AI_Base GetTarget(Vector3 fromPosition)
        {
            var targetList =
                EntityManager.Heroes.Enemies.Where(
                    h =>
                    h.IsValidTarget(Manager.SpellManager.E.Range) && !h.HasBuffOfType(BuffType.SpellShield)
                    && !h.HasBuffOfType(BuffType.SpellImmunity)
                    && h.Health > ObjectManager.Player.GetAutoAttackDamage(h, true) * 2).ToList();

            if (!targetList.Any())
            {
                return null;
            }

            foreach (var enemy in targetList)
            {
                var prediction = Manager.SpellManager.E2.GetPrediction(enemy);
                var predictionsList = new List<Vector3>
                                          {
                                              enemy.ServerPosition,
                                              enemy.Position,
                                              prediction.CastPosition,
                                              prediction.UnitPosition
                                          };

                var wallsFound = 0;

                foreach (var position in predictionsList)
                {
                    var distance = fromPosition.Distance(position);

                    for (var i = 0; i < Manager.MenuManager.CondemnPushDistance; i += (int)enemy.BoundingRadius)
                    {
                        var finalPosition = fromPosition.Extend(position, distance + i).To3D();
                        var j4Flag = Manager.MenuManager.J4Flag && (Variables.IsJ4Flag(finalPosition, enemy));
                        if (NavMesh.GetCollisionFlags(finalPosition).HasFlag(CollisionFlags.Wall)
                            || NavMesh.GetCollisionFlags(finalPosition).HasFlag(CollisionFlags.Building) || j4Flag)
                        {
                            wallsFound++;
                            break;
                        }
                    }
                }

                if (wallsFound >= Manager.MenuManager.CondemnHitchance)
                {
                    return enemy;
                }
            }

            return null;
        }
Beispiel #5
0
 public static bool IsOverWall(Vector3 start, Vector3 end)
 {
     double distance = Vector3.Distance(start, end);
     for (uint i = 0; i < distance; i += 10)
     {
         var tempPosition = start.Extend(end, i).ToVector2();
         if (tempPosition.IsWall())
         {
             return true;
         }
     }
     return false;
 }
Beispiel #6
0
        public static Vector3 GetFirstWallPoint(Vector3 start, Vector3 end)
        {
            double distance = Vector3.Distance(start, end);
            for (uint i = 0; i < distance; i += 10)
            {
                var tempPosition = start.Extend(end, i);
                if (tempPosition.IsWall())
                {
                    return tempPosition.Extend(start, -35);
                }
            }

            return Vector3.Zero;
        }
Beispiel #7
0
        public static bool IsOverWall(Vector3 start, Vector3 end)
        {
            double distance = Vector3.Distance(start, end);
            for (uint i = 0; i < distance; i += 10)
            {
                var tempPosition = start.Extend(end, i).To2D();
                if (tempPosition.IsWall() || (!NavMesh.IsWallOfGrass(start, 65) && NavMesh.IsWallOfGrass(tempPosition.To3D(), 65)))
                {
                    return true;
                }
            }

            return false;
        }
Beispiel #8
0
        internal static bool DoPositionsCrossWall(Vector3 start, Vector3 end)
        {
            double distance = Vector3.Distance(start, end);
            for (uint i = 0; i < distance; i += 10)
            {
                var tempPosition = start.Extend(end, i).To2D();
                if (tempPosition.IsWall())
                {
                    return true;
                }
            }

            return false;
        }
Beispiel #9
0
        public static bool IsOverWall(Vector3 start, Vector3 end)
        {
            double distance = Vector3.Distance(start, end);
            for (uint i = 0; i < distance; i += 10)
            {

                var tempPosition = start.Extend(end, i).To3D();
                var collFlags = NavMesh.GetCollisionFlags(tempPosition);
                if (collFlags.HasFlag(CollisionFlags.Wall) || collFlags.HasFlag(CollisionFlags.Building))
                {
                    return true;
                }
            }
            return false;
        }
Beispiel #10
0
        private void CastW(Obj_AI_Hero target, Vector3 from, Vector3 to)
        {
            var positions = new List<Vector3>();

            for (int i = 1; i < 11; i++)
            {
                positions.Add(from.Extend(to, 42 * i));
            }
            var best =
                positions.OrderByDescending(p => p.Distance(target.Position))
                    .FirstOrDefault(
                        p => !p.IsWall() && p.Distance(player.Position) < W.Range && p.Distance(target.Position) > 350);
            if (best != null && best.IsValid())
            {
                W.Cast(best, config.Item("packets").GetValue<bool>());
            }
        }
Beispiel #11
0
 public static void DrawArrow(Vector3 starPosition, Vector3 endPosition, int angle, int linelength, int arrowsize, Color arrowColor)
 {
     var playerPositionExtend = starPosition.Extend(endPosition, linelength);
     var extendPlayerPos = Drawing.WorldToScreen(playerPositionExtend);
     var afterStartPosition = playerPositionExtend.Extend(starPosition,
         playerPositionExtend.Distance(starPosition) - 110);
     var starPos = Drawing.WorldToScreen(afterStartPosition);
     Drawing.DrawLine(starPos, extendPlayerPos, 1, arrowColor);
     var playerposextend = playerPositionExtend.Extend(starPosition, -130);
     var firstLineRotate = RotateByX(playerposextend.To2D(), starPosition.To2D(), angle);
     var secondLineRotate = RotateByX(playerposextend.To2D(), starPosition.To2D(), -angle);
     var extend1 = playerposextend.Extend(firstLineRotate.To3D(), arrowsize);
     var extend2 = playerposextend.Extend(secondLineRotate.To3D(), arrowsize);
     var extendpoint = Drawing.WorldToScreen(playerposextend);
     var firstLineRotatePos = Drawing.WorldToScreen(extend1);
     var secondLineRotatePos = Drawing.WorldToScreen(extend2);
    Drawing.DrawLine(extendpoint, firstLineRotatePos, 1, arrowColor);
     Drawing.DrawLine(extendpoint, secondLineRotatePos, 1, arrowColor);
 }
Beispiel #12
0
        public static Point[] GetNeededPoinits(
            Vector3 startPosition,
            Vector3 endPosition,
            float startWidth,
            float endWidth = 0)
        {
            if (endWidth <= 0)
            {
                endWidth = startWidth;
            }

            endPosition = startPosition.Extend(endPosition, startPosition.Distance2D(endPosition) + endWidth / 2);

            var difference = startPosition - endPosition;
            var rotation = difference.Rotated(MathUtil.DegreesToRadians(90));
            rotation.Normalize();

            var start = rotation * startWidth;
            var end = rotation * endWidth;

            var rightStartPosition = startPosition + start;
            var leftStartPosition = startPosition - start;
            var rightEndPosition = endPosition + end;
            var leftEndPosition = endPosition - end;

            /*Vector2 leftStart, rightStart, leftEnd, rightEnd;
            Drawing.WorldToScreen(leftStartPosition, out leftStart);
            Drawing.WorldToScreen(rightStartPosition, out rightStart);
            Drawing.WorldToScreen(leftEndPosition, out leftEnd);
            Drawing.WorldToScreen(rightEndPosition, out rightEnd);

            Drawing.DrawLine(leftStart, rightStart, Color.Orange);
            Drawing.DrawLine(rightStart, rightEnd, Color.Orange);
            Drawing.DrawLine(rightEnd, leftEnd, Color.Orange);
            Drawing.DrawLine(leftEnd, leftStart, Color.Orange);*/

            var p1 = new Point((int) rightStartPosition.X, (int) rightStartPosition.Y);
            var p2 = new Point((int) leftStartPosition.X, (int) leftStartPosition.Y);
            var p3 = new Point((int) rightEndPosition.X, (int) rightEndPosition.Y);
            var p4 = new Point((int) leftEndPosition.X, (int) leftEndPosition.Y);
            return new[] {p1, p2, p4, p3};
        }
Beispiel #13
0
        /// <summary>
        /// Collideses the with wall.
        /// </summary>
        /// <param name="start">The start.</param>
        /// <param name="end">The end.</param>
        /// <returns></returns>
        internal static bool CollidesWithWall(Vector3 start, Vector3 end)
        {
            if (Utils.TickCount - _wallCastT > 4000)
            {
                return false;
            }

            GameObject wall = null;
            foreach (var gameObject in
                ObjectManager.Get<GameObject>()
                    .Where(
                        gameObject =>
                            gameObject.IsValid &&
                            Regex.IsMatch(
                                gameObject.Name, "_w_windwall_enemy_0.\\.troy", RegexOptions.IgnoreCase))
                )
            {
                wall = gameObject;
            }
            if (wall == null)
            {
                return false;
            }
            var level = wall.Name.Substring(wall.Name.Length - 6, 1);
            var wallWidth = (300 + 50 * Convert.ToInt32(level));

            var wallDirection =
                (wall.Position.To2D() - _yasuoWallCastedPos).Normalized().Perpendicular();
            var wallStart = wall.Position.To2D() + wallWidth / 2f * wallDirection;
            var wallEnd = wallStart - wallWidth * wallDirection;

            for (int i = 0; i < start.Distance(end); i += 30)
            {
                var currentPosition = start.Extend(end, i);
                if (wallStart.Intersection(wallEnd, currentPosition.To2D(), start.To2D()).Intersects)
                {
                    return true;
                }
            }

            return false;
        }
Beispiel #14
0
        internal static float GetWallLength(Vector3 start, Vector3 end)
        {
            double distance = Vector3.Distance(start, end);
            var firstPosition = Vector3.Zero;
            var lastPosition = Vector3.Zero;

            for (uint i = 0; i < distance; i += 10)
            {
                var tempPosition = start.Extend(end, i);
                if (tempPosition.IsWall() && firstPosition == Vector3.Zero)
                {
                    firstPosition = tempPosition;
                }
                lastPosition = tempPosition;
                if (!lastPosition.IsWall() && firstPosition != Vector3.Zero)
                {
                    break;
                }
            }

            return Vector3.Distance(firstPosition, lastPosition);
        }
Beispiel #15
0
 public static bool IsWallBetween(Vector3 start, Vector3 end, int step = 3)
 {
     if (start.IsValid() && end.IsValid() && step > 0)
     {
         var distance = start.Distance(end);
         for (var i = 0; i < distance; i = i + step)
         {
             if (NavMesh.GetCollisionFlags(start.Extend(end, i)) == CollisionFlags.Wall)
             {
                 return true;
             }
         }
     }
     return false;
 }
Beispiel #16
0
 public static bool CheckWalls(Vector3 from, Vector3 to)
 {
     var steps = 6f;
     var stepLength = from.Distance(to)/steps;
     for (var i = 1; i < steps + 1; i++)
     {
         if (from.Extend(to, stepLength*i).IsWall())
         {
             return true;
         }
     }
     return false;
 }
Beispiel #17
0
        public static Geometry.Polygon GetPolyFromVector(Vector3 from, Vector3 to, float width)
        {
            var POS = to.Extend(from, from.Distance(to));
            var direction = (POS - to.To2D()).Normalized();

            var pos1 = (to.To2D() - direction.Perpendicular()*width/2f).To3D();

            var pos2 =
                (POS + (POS - to.To2D()).Normalized() + direction.Perpendicular()*width/2f).To3D();

            var pos3 = (to.To2D() + direction.Perpendicular()*width/2f).To3D();

            var pos4 =
                (POS + (POS - to.To2D()).Normalized() - direction.Perpendicular()*width/2f).To3D();
            var poly = new Geometry.Polygon();
            poly.Add(pos1);
            poly.Add(pos3);
            poly.Add(pos2);
            poly.Add(pos4);
            return poly;
        }
Beispiel #18
0
        private static void DrawHinh1(Vector3 center, float radius, Color color, int width = 5)
        {
            Render.Circle.DrawCircle(center, radius, color, width, false);
            return;
            var pos1y = center;
            pos1y.X = pos1y.X + radius;
            var pos1 = pos1y.To2D().RotateAround(center.To2D(), drawstate.AngleToRadian());
            var pos1a = center.Extend(pos1.To3D(), radius * 5 / 8).To2D().RotateAround(center.To2D(), (18).AngleToRadian());
            var pos2 = pos1.RotateAround(center.To2D(), (36).AngleToRadian());
            var pos3 = pos1.RotateAround(center.To2D(), (72).AngleToRadian());
            var pos4 = pos1.RotateAround(center.To2D(), (108).AngleToRadian());
            var pos5 = pos1.RotateAround(center.To2D(), (144).AngleToRadian());
            var pos6 = pos1.RotateAround(center.To2D(), (180).AngleToRadian());
            var pos7 = pos1.RotateAround(center.To2D(), (216).AngleToRadian());
            var pos8 = pos1.RotateAround(center.To2D(), (252).AngleToRadian());
            var pos9 = pos1.RotateAround(center.To2D(), (288).AngleToRadian());
            var pos10 = pos1.RotateAround(center.To2D(), (324).AngleToRadian());
            var pos2a = pos1a.RotateAround(center.To2D(), (36).AngleToRadian());
            var pos3a = pos1a.RotateAround(center.To2D(), (72).AngleToRadian());
            var pos4a = pos1a.RotateAround(center.To2D(), (108).AngleToRadian());
            var pos5a = pos1a.RotateAround(center.To2D(), (144).AngleToRadian());
            var pos6a = pos1a.RotateAround(center.To2D(), (180).AngleToRadian());
            var pos7a = pos1a.RotateAround(center.To2D(), (216).AngleToRadian());
            var pos8a = pos1a.RotateAround(center.To2D(), (252).AngleToRadian());
            var pos9a = pos1a.RotateAround(center.To2D(), (288).AngleToRadian());
            var pos10a = pos1a.RotateAround(center.To2D(), (324).AngleToRadian());
            Drawing.DrawLine(Drawing.WorldToScreen(pos1.To3D()), Drawing.WorldToScreen(pos1a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos2.To3D()), Drawing.WorldToScreen(pos1a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos2.To3D()), Drawing.WorldToScreen(pos2a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos3.To3D()), Drawing.WorldToScreen(pos2a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos3.To3D()), Drawing.WorldToScreen(pos3a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos4.To3D()), Drawing.WorldToScreen(pos3a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos4.To3D()), Drawing.WorldToScreen(pos4a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos5.To3D()), Drawing.WorldToScreen(pos4a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos5.To3D()), Drawing.WorldToScreen(pos5a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos6.To3D()), Drawing.WorldToScreen(pos5a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos6.To3D()), Drawing.WorldToScreen(pos6a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos7.To3D()), Drawing.WorldToScreen(pos6a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos7.To3D()), Drawing.WorldToScreen(pos7a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos8.To3D()), Drawing.WorldToScreen(pos7a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos8.To3D()), Drawing.WorldToScreen(pos8a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos9.To3D()), Drawing.WorldToScreen(pos8a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos9.To3D()), Drawing.WorldToScreen(pos9a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos10.To3D()), Drawing.WorldToScreen(pos9a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos10.To3D()), Drawing.WorldToScreen(pos10a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos1.To3D()), Drawing.WorldToScreen(pos10a.To3D()), width, color);

            Drawing.DrawLine(Drawing.WorldToScreen(pos1.To3D()), Drawing.WorldToScreen(pos2.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos3.To3D()), Drawing.WorldToScreen(pos2.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos3.To3D()), Drawing.WorldToScreen(pos4.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos5.To3D()), Drawing.WorldToScreen(pos4.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos5.To3D()), Drawing.WorldToScreen(pos6.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos7.To3D()), Drawing.WorldToScreen(pos6.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos7.To3D()), Drawing.WorldToScreen(pos8.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos9.To3D()), Drawing.WorldToScreen(pos8.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos9.To3D()), Drawing.WorldToScreen(pos10.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos1.To3D()), Drawing.WorldToScreen(pos10.To3D()), width, color);

            Drawing.DrawLine(Drawing.WorldToScreen(pos1a.To3D()), Drawing.WorldToScreen(pos2a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos3a.To3D()), Drawing.WorldToScreen(pos2a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos3a.To3D()), Drawing.WorldToScreen(pos4a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos5a.To3D()), Drawing.WorldToScreen(pos4a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos5a.To3D()), Drawing.WorldToScreen(pos6a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos7a.To3D()), Drawing.WorldToScreen(pos6a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos7a.To3D()), Drawing.WorldToScreen(pos8a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos9a.To3D()), Drawing.WorldToScreen(pos8a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos9a.To3D()), Drawing.WorldToScreen(pos10a.To3D()), width, color);
            Drawing.DrawLine(Drawing.WorldToScreen(pos1a.To3D()), Drawing.WorldToScreen(pos10a.To3D()), width, color);

            DrawCircle(center, radius * 2 / 8, color, width, 10);

            if (Utils.GameTimeTickCount >= drawtick + 10)
            {
                drawtick = Utils.GameTimeTickCount;
                drawstate += 2;
            }
        }
Beispiel #19
0
 private static void GapByWardJump(Obj_AI_Hero target, Vector3 posGap)
 {
     if (Variables.Orbwalker.CanMove())
     {
         lastMoveTime = Variables.TickCount;
         Variables.Orbwalker.Move(
             posGap.Extend(GetPositionKickTo(target), -(GetDistBehind(target) + Player.BoundingRadius / 2)));
     }
     lastEndPos = GetPositionAfterKick(target);
     lastInsecTime = Variables.TickCount;
     lastJumpTime = Variables.TickCount;
     Variables.TargetSelector.SetTarget(target);
     WardManager.Place(posGap, true);
 }
Beispiel #20
0
        private static void DrawLineIfWallBetween(Vector3 startPos, Obj_AI_Base target)
         {
             Vector3 endPos = YasuoCalcs.GetDashingEnd(target);
 
             List<Vector3> inbetweenPoints = new List<Vector3>();
             Vector2 wallStartPosition = Vector2.Zero;
             Vector2 wallEndPosition = Vector2.Zero;
 
             //get every point between yasuo's position and the end position of the dash extended to a range of 1000. 
             //1 point is every 1/100 of total length
             for (int i = 0; i <= 100; i++)
                 inbetweenPoints.Add(startPos.Extend(startPos.Extend(endPos, 1000), i* (startPos.Distance(startPos.Extend(endPos, 1000)) / 100)).To3D());
 
             //for every point in the list of points, find the beginning and the end of the wal
             foreach (Vector2 vec in inbetweenPoints)
              {
                 if (vec.IsWall())
                 {
                     if (wallStartPosition == Vector2.Zero)
                         wallStartPosition = vec;
                 }
                 else if (wallEndPosition == Vector2.Zero && wallStartPosition != Vector2.Zero)
                     wallEndPosition = vec;
             }

            //draw the wall in the color blue
            if (wallStartPosition != Vector2.Zero && wallEndPosition != Vector2.Zero)
            {
                 double wallWidth = Math.Round(wallStartPosition.Distance(wallEndPosition)),
                    distanceToWall = Math.Round(startPos.Distance(wallStartPosition)),
                    totalDistance = Math.Round(wallStartPosition.Distance(wallEndPosition) + startPos.Distance(wallStartPosition)),
                    monsterDist = Math.Round(target.Position.Distance(wallStartPosition));

                Drawing.DrawLine(wallStartPosition.To3D().WorldToScreen(), wallEndPosition.To3D().WorldToScreen(), 10, System.Drawing.Color.Black);

                //if the end point of yasuos dash brings him at least halfway between the two points (closer to the wall end than to the walls beginning)
                //and the wall has to be thinner than yasuo's total dash range. TESTED THIS TO CONFIRM IT WORKS
                //if (endPos.Distance(wallEndPosition) < endPos.Distance(wallStartPosition) && wallStartPosition.Distance(wallEndPosition) <= Program.E.Range)
                if (totalDistance <= 630)
                    Drawing.DrawLine(startPos.WorldToScreen(), startPos.Extend(endPos, 1000).To3D().WorldToScreen(), 3, System.Drawing.Color.Green);
                else
                    Drawing.DrawLine(startPos.WorldToScreen(), startPos.Extend(endPos, 1000).To3D().WorldToScreen(), 3, System.Drawing.Color.Red);
                Drawing.DrawText(wallStartPosition.To3D().WorldToScreen(), System.Drawing.Color.Purple, wallStartPosition.Distance(wallEndPosition).ToString(), 15);
                Drawing.DrawText(startPos.Extend(endPos, 1000).To3D().WorldToScreen(), System.Drawing.Color.Purple, (wallStartPosition.Distance(wallEndPosition) + startPos.Distance(wallStartPosition)).ToString(), 15);
                Drawing.DrawCircle(endPos, 50, System.Drawing.Color.White);
            }
         }
Beispiel #21
0
 public static Vector3 GetBestDaggerPoint(Vector3 position, Obj_AI_Base target)
 {
     if (target.Position.IsInRange(position, 150)) return position;
     return position.Extend(target, 150).To3D();
 }
Beispiel #22
0
 /// <summary>
 /// Gets a specified amount of Rotated Positions. Useful for getting safe dash positions.
 /// </summary>
 /// <param name="rotateAround">The source position</param>
 /// <param name="rotateTowards">The target position</param>
 /// <param name="degrees">It will get rotated positions from -degrees to +degrees</param>
 /// <param name="positionAmount">The amount of positions to get. Can be left blank</param>
 /// <param name="distance">Can be left blan</param>
 /// <returns></returns>
 public static List<Vector3> RotatedPositions(Vector3 rotateAround, Vector3 rotateTowards, int degrees,
     int positionAmount = 0, float distance = 0)
 {
     if (distance == 0) distance = rotateAround.Distance(rotateTowards);
     if (positionAmount == 0) positionAmount = degrees / 10;
     var realRotateTowards = rotateAround.Extend(rotateTowards, distance);
     var posList = new List<Vector3>();
     var step = (degrees * 2) / positionAmount;
     for (var i = -degrees; i <= degrees; i += step)
     {
         var rotatedPosition = Deviation(rotateAround.To2D(), realRotateTowards, i);
         posList.Add(rotatedPosition.To3D());
     }
     return posList;
 }
Beispiel #23
0
 public static bool CheckWalls(Vector3 player, Vector3 enemy)
 {
     var distance = player.Distance(enemy);
     for (var i = 1; i < 6; i++)
     {
         if (player.Extend(enemy, distance + 55*i).IsWall())
         {
             return true;
         }
     }
     return false;
 }
Beispiel #24
0
        private static IEnumerable<Vector3> GetPossibleJumpPositions(Vector3 pos)
        {
            var pointList = new List<Vector3>();

            for (var j = 680; j >= 50; j -= 50)
            {
                var offset = (int)(2 * Math.PI * j / 50);

                for (var i = 0; i <= offset; i++)
                {
                    var angle = i * Math.PI * 2 / offset;
                    var point = new Vector3((float)(pos.X + j * Math.Cos(angle)),
                        (float)(pos.Y - j * Math.Sin(angle)),
                        pos.Z);

                    if (!NavMesh.GetCollisionFlags(point).HasFlag(CollisionFlags.Wall)&&point.Distance(ObjectManager.Player.Position)<pos.Distance(ObjectManager.Player.Position)-400&&
                        point.Distance(pos.Extend(ObjectManager.Player.Position, 600)) <= 250)
                        pointList.Add(point);
                }
            }

            return pointList;
        }
Beispiel #25
0
        private static void wjumpflee()
        {
            if (WStage != WCastStage.First)
                _player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
            else
            {
                if (_config.Item("wjmax").GetValue<bool>())
                {
                    _player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                    WardJump(Game.CursorPos, true, true, true);
                }
                else if (_player.Distance(Game.CursorPos) >= 700 || walljump == true)
                {

                    if (Game.CursorPos.Distance(wallcheck) > 50)
                    {
                        walljump = false;
                        checker=false;
                        for (var i = 0; i < 40; i++)
                        {
                            var p = Game.CursorPos.Extend(_player.Position, 10 * i);
                            if (NavMesh.GetCollisionFlags(p).HasFlag(CollisionFlags.Wall))
                            {
                                jumppoint = p;
                                wallcheck = Game.CursorPos;
                                walljump = true;
                                break;

                            }
                        }

                        if (walljump == true)
                        {
                            foreach (
                              var qPosition in
                                GetPossibleJumpPositions(jumppoint)
                                .OrderBy(qPosition => qPosition.Distance(jumppoint)))
                                {
                                if (_player.Position.Distance(qPosition) < _player.Position.Distance(jumppoint))
                                {
                                    movepoint = qPosition;
                                    if (movepoint.Distance(jumppoint) > 600)
                                        wpos = movepoint.Extend(jumppoint, 595);
                                    else
                                        wpos = jumppoint;

                                    break;
                                }
                                if (qPosition == null)
                                    movepoint = jumppoint;
                                checker = true;
                                break;
                            }

                        }
                    }
                    var jumpObj = ObjectManager.Get<Obj_AI_Base>()
                         .OrderBy(obj => obj.Distance(_player.ServerPosition))
                         .FirstOrDefault(obj => obj.IsAlly && !obj.IsMe && obj.Distance(movepoint) <= 700 &&
                             (!(obj.Name.IndexOf("turret", StringComparison.InvariantCultureIgnoreCase) >= 0) &&
                             obj.Distance(jumppoint) <= 200));

                    if (walljump == false || movepoint.Distance(Game.CursorPos) > _player.Distance(Game.CursorPos) + 150)
                    {
                        movepoint = Game.CursorPos;
                        jumppoint = Game.CursorPos;

                    }
                    if (jumpObj == null && Items.GetWardSlot() != null && Items.GetWardSlot().Stacks != 0)
                        placeward(wpos);
                    if (_player.Position.Distance(jumppoint) <= 700 && jumpObj != null)
                    {
                        CastW(jumpObj);
                        walljump = false;
                    }

                    _player.IssueOrder(GameObjectOrder.MoveTo, movepoint);
                }
                else
                    WardJump(jumppoint, true, true, false);

            }
        }
Beispiel #26
0
        private static void Flee()
        {
            var pos = Game.CursorPos;
            
            
            
            return;
            
            if (pos.IsWall())
            {
                return;
            }

            if (pos.Distance(ObjectManager.Player.Position) < ObjectManager.Player.BoundingRadius)
            {
                return;
            }

            WardJump(Game.CursorPos);

            return;
                if (ObjectManager.Player.Distance(Game.CursorPos) >= 700 || walljump)
                {
                    if (Game.CursorPos.Distance(wallcheck) > 50)
                    {
                        walljump = false;
                        checker = false;
                        for (var i = 0; i < 40; i++)
                        {
                            var p = Game.CursorPos.Extend(ObjectManager.Player.Position, 10*i);
                            if (NavMesh.GetCollisionFlags(p).HasFlag(CollisionFlags.Wall))
                            {
                                jumppoint = p;
                                wallcheck = Game.CursorPos;
                                walljump = true;
                                break;
                            }
                        }

                        if (walljump)
                        {
                            foreach (
                                var qPosition in
                                    GetPossibleJumpPositions(jumppoint)
                                        .OrderBy(qPosition => qPosition.Distance(jumppoint)))
                            {
                                if (ObjectManager.Player.Position.Distance(qPosition) <
                                    ObjectManager.Player.Position.Distance(jumppoint))
                                {
                                    movepoint = qPosition;
                                    wpos = movepoint.Distance(jumppoint) > 600
                                        ? movepoint.Extend(jumppoint, 595)
                                        : jumppoint;

                                    break;
                                }
                                checker = true;
                                break;
                            }
                        }
                    }
                    var jumpObj = ObjectManager.Get<Obj_AI_Base>()
                        .OrderBy(obj => obj.Distance(ObjectManager.Player.ServerPosition))
                        .FirstOrDefault(obj => obj.IsAlly && !obj.IsMe && obj.Distance(movepoint) <= 700 &&
                                               (!(obj.Name.IndexOf("turret", StringComparison.InvariantCultureIgnoreCase) >=
                                                  0) &&
                                                obj.Distance(jumppoint) <= 200));



                    if (walljump == false || movepoint.Distance(Game.CursorPos) > ObjectManager.Player.Distance(Game.CursorPos) + 150)
                    {
                        movepoint = Game.CursorPos;
                        jumppoint = Game.CursorPos;
                    }

                    if (jumpObj == null && Items.GetWardSlot() != null && Items.GetWardSlot().Stacks != 0)
                    {
                        PutWard(wpos);
                    }

                    if (ObjectManager.Player.Position.Distance(jumppoint) <= 700 && jumpObj != null)
                    {
                        CastW(jumpObj);
                        walljump = false;
                    }


                    ObjectManager.Player.IssueOrder(GameObjectOrder.MoveTo, movepoint);
                }
                else
                    WardJump(jumppoint);
        }
Beispiel #27
0
 private static Vector3 ExtendWallpos(Obj_AI_Base ts, Vector3 point)
 {
     if (ts == null) throw new ArgumentNullException("ts");
     return point.Extend(ts.Position, point.Distance(ts.Position) + 25);
 }
 /// <summary>
 /// Simplfying Extend for me
 /// </summary>
 /// <param name="from"></param>
 /// <param name="to"></param>
 /// <param name="x"></param>
 /// <returns></returns>
 public static Vector3 Extend(Vector3 from, Vector3 to, float x)
 {
     return from.Extend(to, x);
 }
Beispiel #29
0
        public void SetUnavailableTrees(Vector3 start, Vector3 end, Chakram chakram)
        {
            var precision = chakram.Radius;
            var count = (int)Math.Ceiling(start.Distance2D(end) / precision);

            var ping = Game.Ping / 1000;
            var time = Game.RawGameTime;

            for (var i = 1; i <= count; i++)
            {
                var position = i == count ? end : start.Extend(end, precision * i);

                unavailableTrees.Add(
                    Tuple.Create(
                        position,
                        chakram.Radius,
                        chakram.CastPoint + ping + start.Distance2D(position) / chakram.Speed + time));
            }
        }
Beispiel #30
0
 private static void GapByWardJump(Obj_AI_Hero target, Vector3 posGap)
 {
     if (Variables.Orbwalker.CanMove())
     {
         lastGapClose = Variables.TickCount;
         Variables.Orbwalker.Move(
             posGap.Extend(ExpectedEndPosition(target), -(DistBehind(target) + Player.BoundingRadius / 2)));
     }
     posSetting = EndPosition(target);
     lastSettingPos = Variables.TickCount;
     lastJump = Variables.TickCount;
     Variables.TargetSelector.SetTarget(target);
     var objJump =
         GameObjects.AllyHeroes.Where(i => !i.IsMe)
             .Cast<Obj_AI_Base>()
             .Concat(
                 GameObjects.AllyMinions.Where(
                     i => i.IsMinion() || i.IsPet() || SpecialPet.Contains(i.CharData.BaseSkinName.ToLower()))
                     .Concat(GameObjects.AllyWards.Where(i => i.IsWard())))
             .Where(i => i.IsValidTarget(W.Range, false) && i.Distance(posGap) <= target.BoundingRadius)
             .MinOrDefault(i => i.Distance(posGap));
     if (objJump != null && objJump.Distance(target) < objJump.Distance(ExpectedEndPosition(target)))
     {
         W.CastOnUnit(objJump);
     }
     else
     {
         WardManager.Place(posGap, true);
     }
 }