Beispiel #1
0
        /// <summary>
        ///     Returns an Area of Effect Prediction
        /// </summary>
        /// <param name="input">
        ///     <see cref="PredictionInput" /> input
        /// </param>
        /// <returns>
        ///     <see cref="PredictionOutput" /> output
        /// </returns>
        public static PredictionOutput GetAoEPrediction(PredictionInput input)
        {
            switch (input.Type)
            {
                case SkillshotType.SkillshotCircle:
                    return Circle.GetCirclePrediction(input);
                case SkillshotType.SkillshotCone:
                    return Cone.GetConePrediction(input);
                case SkillshotType.SkillshotLine:
                    return Line.GetLinePrediction(input);
            }

            return new PredictionOutput();
        }
Beispiel #2
0
        /// <summary>
        ///     Gets the list of minions currently between the source and target
        /// </summary>
        /// <param name="source">
        ///     The Source
        /// </param>
        /// <param name="targetPosition">
        ///     The Target Position
        /// </param>
        /// <returns>
        ///     The <see cref="List" />.
        /// </returns>
        public static List<Obj_AI_Base> GetCollisionMinions(Obj_AI_Hero source, Vector3 targetPosition)
        {
            var input = new PredictionInput
                            {
                                Unit = source, Radius = SpellManager.Spell[SpellSlot.Q].Width,
                                Delay = SpellManager.Spell[SpellSlot.Q].Delay,
                                Speed = SpellManager.Spell[SpellSlot.Q].Speed,
                                CollisionObjects = CollisionableObjects.Minions
                            };

            return
                Collision.GetCollision(new List<Vector3> { targetPosition }, input)
                    .OrderBy(x => x.Distance(source))
                    .ToList();
        }
Beispiel #3
0
        /// <summary>
        ///     Returns the possible targets of a prediction input source.
        /// </summary>
        /// <param name="input">
        ///     <see cref="PredictionInput" /> input
        /// </param>
        /// <returns><see cref="PossibleTarget" /> list.</returns>
        internal static List<PossibleTarget> GetPossibleTargets(PredictionInput input)
        {
            var result = new List<PossibleTarget>();
            var originalUnit = input.Unit;
            foreach (var enemy in
                GameObjects.Enemy.Where(
                    h =>
                    h.NetworkId != originalUnit.NetworkId
                    && h.IsValidTarget(input.Range + 200 + input.RealRadius, true, input.RangeCheckFrom)))
            {
                input.Unit = enemy;
                var prediction = Movement.GetPrediction(input, false, false);
                if (prediction.Hitchance >= HitChance.High)
                {
                    result.Add(new PossibleTarget { Position = prediction.UnitPosition.ToVector2(), Unit = enemy });
                }
            }

            return result;
        }
Beispiel #4
0
 private static PredictionOutput GetDashingPrediction(PredictionInput input)
 {
     var dashData = input.Unit.GetDashInfo();
     var result = new PredictionOutput { Input = input };
     input.Delay += 0.1f;
     if (!dashData.IsBlink)
     {
         var dashPred = GetPositionOnPath(
             input,
             new List<Vector2> { input.Unit.ServerPosition.ToVector2(), dashData.Path.Last() },
             dashData.Speed);
         if (dashPred.Hitchance >= HitChance.High)
         {
             dashPred.CastPosition = dashPred.UnitPosition;
             dashPred.Hitchance = HitChance.Dashing;
             return dashPred;
         }
         if (dashData.Path.PathLength() > 200)
         {
             var endP = dashData.Path.Last();
             var timeToPoint = input.Delay + input.From.ToVector2().Distance(endP) / input.Speed;
             if (timeToPoint
                 <= input.Unit.Distance(endP) / dashData.Speed + input.RealRadius / input.Unit.MoveSpeed)
             {
                 return new PredictionOutput
                            {
                                CastPosition = endP.ToVector3(), UnitPosition = endP.ToVector3(),
                                Hitchance = HitChance.Dashing
                            };
             }
         }
         result.CastPosition = dashData.Path.Last().ToVector3();
         result.UnitPosition = result.CastPosition;
     }
     return result;
 }
Beispiel #5
0
 internal static List<Obj_AI_Base> GetCollision(List<Vector3> positions, PredictionInput input)
 {
     var result = new List<Obj_AI_Base>();
     foreach (var position in positions)
     {
         foreach (var objType in input.CollisionObjects)
         {
             switch (objType)
             {
                 case CollisionableObjects.Minions:
                     foreach (var minion in
                         GameObjects.EnemyMinions.Where(
                             i =>
                             i.IsValidTarget(
                                 Math.Min(input.Range + input.Radius + 100, 2000),
                                 true,
                                 input.RangeCheckFrom)))
                     {
                         input.Unit = minion;
                         var pred = input.GetPrediction(false, false);
                         if (pred.UnitPosition.ToVector2()
                                 .DistanceSquared(input.From.ToVector2(), position.ToVector2(), true)
                             <= Math.Pow(input.Radius + 15 + minion.BoundingRadius, 2))
                         {
                             result.Add(minion);
                         }
                     }
                     break;
                 case CollisionableObjects.Heroes:
                     foreach (var hero in
                         GameObjects.EnemyHeroes.Where(
                             i =>
                             i.IsValidTarget(
                                 Math.Min(input.Range + input.Radius + 100, 2000),
                                 true,
                                 input.RangeCheckFrom)))
                     {
                         input.Unit = hero;
                         var pred = input.GetPrediction(false, false);
                         if (pred.UnitPosition.ToVector2()
                                 .DistanceSquared(input.From.ToVector2(), position.ToVector2(), true)
                             <= Math.Pow(input.Radius + 50 + hero.BoundingRadius, 2))
                         {
                             result.Add(hero);
                         }
                     }
                     break;
                 case CollisionableObjects.Walls:
                     var step = position.Distance(input.From) / 20;
                     for (var i = 0; i < 20; i++)
                     {
                         var p = input.From.ToVector2().Extend(position.ToVector2(), step * i);
                         if (NavMesh.GetCollisionFlags(p.X, p.Y).HasFlag(CollisionFlags.Wall))
                         {
                             result.Add(ObjectManager.Player);
                         }
                     }
                     break;
                 case CollisionableObjects.YasuoWall:
                     if (Variables.TickCount - wallCastT > 4000)
                     {
                         continue;
                     }
                     var wall =
                         GameObjects.AllGameObjects.FirstOrDefault(
                             i =>
                             i.IsValid
                             && Regex.IsMatch(i.Name, "_w_windwall_enemy_0.\\.troy", RegexOptions.IgnoreCase));
                     if (wall == null)
                     {
                         break;
                     }
                     var wallWidth = 300 + 50 * Convert.ToInt32(wall.Name.Substring(wall.Name.Length - 6, 1));
                     var wallDirection =
                         (wall.Position.ToVector2() - yasuoWallCastedPos).Normalized().Perpendicular();
                     var wallStart = wall.Position.ToVector2() + wallWidth / 2f * wallDirection;
                     var wallEnd = wallStart - wallWidth * wallDirection;
                     if (
                         wallStart.Intersection(wallEnd, position.ToVector2(), input.From.ToVector2())
                             .Intersects)
                     {
                         var t = Variables.TickCount
                                 + (wallStart.Intersection(
                                     wallEnd,
                                     position.ToVector2(),
                                     input.From.ToVector2()).Point.Distance(input.From) / input.Speed
                                    + input.Delay) * 1000;
                         if (t < wallCastT + 4000)
                         {
                             result.Add(ObjectManager.Player);
                         }
                     }
                     break;
             }
         }
     }
     return result.Distinct().ToList();
 }
Beispiel #6
0
 private static PredictionOutput GetImmobilePrediction(PredictionInput input, double remainingImmobileT)
 {
     var timeToReachTargetPosition = input.Delay + input.Unit.Distance(input.From) / input.Speed;
     return timeToReachTargetPosition <= remainingImmobileT + input.RealRadius / input.Unit.MoveSpeed
                ? new PredictionOutput
                      {
                          CastPosition = input.Unit.ServerPosition, UnitPosition = input.Unit.Position,
                          Hitchance = HitChance.Immobile
                      }
                : new PredictionOutput
                      {
                          Input = input, CastPosition = input.Unit.ServerPosition,
                          UnitPosition = input.Unit.ServerPosition, Hitchance = HitChance.High
                      };
 }
Beispiel #7
0
 private static void WayPointAnalysis(PredictionOutput result, PredictionInput input)
 {
     var totalDelay = input.Delay
                      + (Math.Abs(input.Speed - float.MaxValue) < float.Epsilon
                             ? 0
                             : input.Unit.Distance(input.From) / input.Speed);
     var fixRange = (input.Unit.MoveSpeed * totalDelay) / 2;
     var lastWaypiont = input.Unit.GetWaypoints().Last().ToVector3();
     if (input.Type == SkillshotType.SkillshotCircle)
     {
         fixRange -= input.Radius / 2;
     }
     switch (input.Type)
     {
         case SkillshotType.SkillshotLine:
             if (input.Unit.Path.Count() > 0)
             {
                 result.Hitchance = GetAngle(input.From, input.Unit) < 36 ? HitChance.VeryHigh : HitChance.High;
             }
             break;
         case SkillshotType.SkillshotCircle:
             if (totalDelay < 1.1
                 && ((totalDelay < 0.7 && OnProcessSpellDetection.GetLastAutoAttackTime(input.Unit) < 0.1d)
                     || Path.PathTracker.GetCurrentPath(input.Unit).Time < 0.1d))
             {
                 result.Hitchance = HitChance.VeryHigh;
             }
             break;
     }
     if (input.Unit.HasBuffOfType(BuffType.Slow) || input.Unit.Distance(input.From) < 300
         || lastWaypiont.Distance(input.From) < 250 || input.Unit.Distance(lastWaypiont) > 800)
     {
         result.Hitchance = HitChance.VeryHigh;
     }
     if (input.Unit.Path.Count() == 0 && input.Unit.Position == input.Unit.ServerPosition
         && !input.Unit.IsWindingUp)
     {
         result.Hitchance = input.Unit.Distance(input.From) > input.Range - fixRange
                                ? HitChance.High
                                : HitChance.VeryHigh;
         return;
     }
     if (lastWaypiont.Distance(input.From) <= input.Unit.Distance(input.From)
         && input.Unit.Distance(input.From) > input.Range - fixRange)
     {
         result.Hitchance = HitChance.High;
     }
     if ((input.Unit.Path.Count() > 0 && input.Unit.Distance(lastWaypiont) < input.Unit.MoveSpeed * totalDelay)
         || (totalDelay > 0.7
             && (input.Unit.IsWindingUp || OnProcessSpellDetection.GetLastAutoAttackTime(input.Unit) < 0.1d))
         || (input.Unit.Path.Count() > 1 && input.Type == SkillshotType.SkillshotLine))
     {
         result.Hitchance = HitChance.Medium;
     }
     if (input.Unit.Distance(input.From) < 300 || lastWaypiont.Distance(input.From) < 250)
     {
         result.Hitchance = HitChance.VeryHigh;
     }
 }
Beispiel #8
0
 private static PredictionOutput GetPrediction(PredictionInput input, bool ft, bool checkCollision)
 {
     PredictionOutput result = null;
     if (!input.Unit.IsValidTarget(float.MaxValue, false))
     {
         return new PredictionOutput();
     }
     if (ft)
     {
         input.Delay += Game.Ping / 2000f + 0.06f;
         if (input.AoE)
         {
             return Cluster.GetAoEPrediction(input);
         }
     }
     if (Math.Abs(input.Range - float.MaxValue) > float.Epsilon
         && input.Unit.DistanceSquared(input.RangeCheckFrom) > Math.Pow(input.Range * 1.5, 2))
     {
         return new PredictionOutput { Input = input };
     }
     if (input.Unit.IsDashing())
     {
         result = GetDashingPrediction(input);
     }
     else
     {
         var remainingImmobileT = UnitIsImmobileUntil(input.Unit);
         if (remainingImmobileT >= 0d)
         {
             result = GetImmobilePrediction(input, remainingImmobileT);
         }
     }
     if (result == null)
     {
         result = GetStandardPrediction(input);
     }
     if (Math.Abs(input.Range - float.MaxValue) > float.Epsilon)
     {
         if (result.Hitchance >= HitChance.High
             && input.RangeCheckFrom.DistanceSquared(input.Unit.Position)
             > Math.Pow(input.Range + input.RealRadius * 3 / 4, 2))
         {
             result.Hitchance = HitChance.Medium;
         }
         if (input.RangeCheckFrom.DistanceSquared(result.UnitPosition)
             > Math.Pow(input.Range + (input.Type == SkillshotType.SkillshotCircle ? input.RealRadius : 0), 2))
         {
             result.Hitchance = HitChance.OutOfRange;
         }
         if (input.RangeCheckFrom.DistanceSquared(result.CastPosition) > Math.Pow(input.Range, 2))
         {
             if (result.Hitchance != HitChance.OutOfRange)
             {
                 result.CastPosition = input.RangeCheckFrom
                                       + input.Range
                                       * (result.UnitPosition - input.RangeCheckFrom).Normalized().SetZ();
             }
             else
             {
                 result.Hitchance = HitChance.OutOfRange;
             }
         }
     }
     if (result.Hitchance > HitChance.Medium)
     {
         WayPointAnalysis(result, input);
     }
     if (checkCollision && input.Collision)
     {
         var positions = new List<Vector3> { result.UnitPosition, result.CastPosition, input.Unit.Position };
         var originalUnit = input.Unit;
         result.CollisionObjects = Collisions.GetCollision(positions, input);
         result.CollisionObjects.RemoveAll(i => i.NetworkId == originalUnit.NetworkId);
         result.Hitchance = result.CollisionObjects.Count > 0 ? HitChance.Collision : result.Hitchance;
     }
     return result;
 }
Beispiel #9
0
 private static PredictionOutput GetStandardPrediction(PredictionInput input)
 {
     var speed = input.Unit.MoveSpeed;
     if (input.Unit.DistanceSquared(input.From) < 200 * 200)
     {
         speed /= 1.5f;
     }
     var result = GetPositionOnPath(input, input.Unit.GetWaypoints(), speed);
     if (result.Hitchance >= HitChance.High && input.Unit is Obj_AI_Hero)
     {
     }
     return result;
 }
Beispiel #10
0
 internal static PredictionOutput GetConePrediction(PredictionInput input)
 {
     var mainTargetPrediction = input.GetPrediction(false, true);
     var posibleTargets = new List<PossibleTarget>
                              {
                                  new PossibleTarget
                                      {
                                          Position = mainTargetPrediction.UnitPosition.ToVector2(),
                                          Unit = input.Unit
                                      }
                              };
     if (mainTargetPrediction.Hitchance >= HitChance.Medium)
     {
         posibleTargets.AddRange(GetPossibleTargets(input));
     }
     if (posibleTargets.Count > 1)
     {
         var candidates = new List<Vector2>();
         foreach (var target in posibleTargets)
         {
             target.Position = target.Position - input.From.ToVector2();
         }
         for (var i = 0; i < posibleTargets.Count; i++)
         {
             for (var j = 0; j < posibleTargets.Count; j++)
             {
                 if (i != j)
                 {
                     var p = (posibleTargets[i].Position + posibleTargets[j].Position) * 0.5f;
                     if (!candidates.Contains(p))
                     {
                         candidates.Add(p);
                     }
                 }
             }
         }
         var bestCandidateHits = -1;
         var bestCandidate = new Vector2();
         var positionsList = posibleTargets.Select(i => i.Position).ToList();
         foreach (var candidate in candidates)
         {
             var hits = GetHits(candidate, input.Range, input.Radius, positionsList);
             if (hits > bestCandidateHits)
             {
                 bestCandidate = candidate;
                 bestCandidateHits = hits;
             }
         }
         if (bestCandidateHits > 1 && input.From.ToVector2().DistanceSquared(bestCandidate) > 50 * 50)
         {
             return new PredictionOutput
                        {
                            Hitchance = mainTargetPrediction.Hitchance, AoeHitCount = bestCandidateHits,
                            UnitPosition = mainTargetPrediction.UnitPosition,
                            CastPosition = bestCandidate.ToVector3(), Input = input
                        };
         }
     }
     return mainTargetPrediction;
 }
Beispiel #11
0
            /// <summary>
            ///     Returns an Area-of-Effect cone prediction from a prediction input source.
            /// </summary>
            /// <param name="input">
            ///     <see cref="PredictionInput" /> input
            /// </param>
            /// <returns>
            ///     <see cref="PredictionOutput" /> output
            /// </returns>
            public static PredictionOutput GetConePrediction(PredictionInput input)
            {
                var mainTargetPrediction = Movement.GetPrediction(input, false, true);
                var posibleTargets       = new List <PossibleTarget>
                {
                    new PossibleTarget
                    {
                        Position = mainTargetPrediction.UnitPosition.ToVector2(),
                        Unit     = input.Unit
                    }
                };

                if (mainTargetPrediction.Hitchance >= HitChance.Medium)
                {
                    // Add the posible targets  in range:
                    posibleTargets.AddRange(GetPossibleTargets(input));
                }

                if (posibleTargets.Count > 1)
                {
                    var candidates = new List <Vector2>();

                    foreach (var target in posibleTargets)
                    {
                        target.Position = target.Position - input.From.ToVector2();
                    }

                    for (var i = 0; i < posibleTargets.Count; i++)
                    {
                        for (var j = 0; j < posibleTargets.Count; j++)
                        {
                            if (i != j)
                            {
                                var p = (posibleTargets[i].Position + posibleTargets[j].Position) * 0.5f;
                                if (!candidates.Contains(p))
                                {
                                    candidates.Add(p);
                                }
                            }
                        }
                    }

                    var bestCandidateHits = -1;
                    var bestCandidate     = default(Vector2);
                    var positionsList     = posibleTargets.Select(t => t.Position).ToList();

                    foreach (var candidate in candidates)
                    {
                        var hits = GetHits(candidate, input.Range, input.Radius, positionsList);
                        if (hits > bestCandidateHits)
                        {
                            bestCandidate     = candidate;
                            bestCandidateHits = hits;
                        }
                    }

                    if (bestCandidateHits > 1 && input.From.ToVector2().DistanceSquared(bestCandidate) > 50 * 50)
                    {
                        return(new PredictionOutput
                        {
                            Hitchance = mainTargetPrediction.Hitchance, AoeHitCount = bestCandidateHits,
                            UnitPosition = mainTargetPrediction.UnitPosition,
                            CastPosition = bestCandidate.ToVector3(), Input = input
                        });
                    }
                }

                return(mainTargetPrediction);
            }
Beispiel #12
0
        /// <summary>
        ///     Returns Calculated Prediction based off given data values.
        /// </summary>
        /// <param name="input">
        ///     <see cref="PredictionInput" /> input
        /// </param>
        /// <param name="ft">Add Delay</param>
        /// <param name="checkCollision">Check Collision</param>
        /// <returns>
        ///     <see cref="PredictionOutput" /> output
        /// </returns>
        internal static PredictionOutput GetPrediction(PredictionInput input, bool ft, bool checkCollision)
        {
            PredictionOutput result = null;

            if (!input.Unit.IsValidTarget(float.MaxValue, false))
            {
                return new PredictionOutput();
            }

            if (ft)
            {
                // Increase the delay due to the latency and server tick:
                input.Delay += (Game.Ping / 2000f) + 0.06f;

                if (input.AoE)
                {
                    return Cluster.GetAoEPrediction(input);
                }
            }

            // Target too far away.
            if (Math.Abs(input.Range - float.MaxValue) > float.Epsilon
                && input.Unit.DistanceSquared(input.RangeCheckFrom) > Math.Pow(input.Range * 1.5, 2))
            {
                return new PredictionOutput { Input = input };
            }

            // Unit is dashing.
            if (input.Unit.IsDashing())
            {
                result = GetDashingPrediction(input);
            }
            else
            {
                // Unit is immobile.
                var remainingImmobileT = UnitIsImmobileUntil(input.Unit);
                if (remainingImmobileT >= 0d)
                {
                    result = GetImmobilePrediction(input, remainingImmobileT);
                }
            }

            // Normal prediction
            if (result == null)
            {
                result = GetAdvancedPrediction(input);
            }

            // Check if the unit position is in range
            if (Math.Abs(input.Range - float.MaxValue) > float.Epsilon)
            {
                if (result.Hitchance >= HitChance.High
                    && input.RangeCheckFrom.DistanceSquared(input.Unit.Position)
                    > Math.Pow(input.Range + (input.RealRadius * 3 / 4), 2))
                {
                    result.Hitchance = HitChance.Medium;
                }

                if (input.RangeCheckFrom.DistanceSquared(result.UnitPosition)
                    > Math.Pow(input.Range + (input.Type == SkillshotType.SkillshotCircle ? input.RealRadius : 0), 2))
                {
                    result.Hitchance = HitChance.OutOfRange;
                }

                if (input.RangeCheckFrom.DistanceSquared(result.CastPosition) > Math.Pow(input.Range, 2))
                {
                    if (result.Hitchance != HitChance.OutOfRange)
                    {
                        result.CastPosition = input.RangeCheckFrom
                                              + (input.Range
                                                 * (result.UnitPosition - input.RangeCheckFrom).Normalized().SetZ());
                    }
                    else
                    {
                        result.Hitchance = HitChance.OutOfRange;
                    }
                }
            }

            // Check for collision
            if (checkCollision && input.Collision)
            {
                var positions = new List<Vector3> { result.UnitPosition, result.CastPosition, input.Unit.Position };
                var originalUnit = input.Unit;
                result.CollisionObjects = Collision.GetCollision(positions, input);
                result.CollisionObjects.RemoveAll(x => x.NetworkId == originalUnit.NetworkId);
                result.Hitchance = result.CollisionObjects.Count > 0 ? HitChance.Collision : result.Hitchance;
            }

            return result;
        }
Beispiel #13
0
        /// <summary>
        ///     Get Position on Unit's Path.
        /// </summary>
        /// <param name="input">
        ///     <see cref="PredictionInput" /> input
        /// </param>
        /// <param name="path">Path in Vector2 List</param>
        /// <param name="speed">Unit Speed</param>
        /// <returns><see cref="PredictionOutput" /> output</returns>
        internal static PredictionOutput GetPositionOnPath(PredictionInput input, List <Vector2> path, float speed = -1)
        {
            speed = (Math.Abs(speed - (-1)) < float.Epsilon) ? input.Unit.MoveSpeed : speed;

            if (path.Count <= 1)
            {
                return(new PredictionOutput
                {
                    Input = input, UnitPosition = input.Unit.ServerPosition,
                    CastPosition = input.Unit.ServerPosition, Hitchance = HitChance.VeryHigh
                });
            }

            var pLength = path.PathLength();

            // Skillshots with only a delay
            if (pLength >= input.Delay * speed - input.RealRadius &&
                Math.Abs(input.Speed - float.MaxValue) < float.Epsilon)
            {
                var tDistance = input.Delay * speed - input.RealRadius;

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

                    if (d >= tDistance)
                    {
                        var direction = (b - a).Normalized();

                        var cp = a + direction * tDistance;
                        var p  = a
                                 + direction
                                 * ((i == path.Count - 2)
                                       ? Math.Min(tDistance + input.RealRadius, d)
                                       : (tDistance + input.RealRadius));

                        return(new PredictionOutput
                        {
                            Input = input, CastPosition = cp.ToVector3(), UnitPosition = p.ToVector3(),
                            Hitchance =
                                Path.PathTracker.GetCurrentPath(input.Unit).Time < 0.1d
                                               ? HitChance.VeryHigh
                                               : HitChance.High
                        });
                    }

                    tDistance -= d;
                }
            }

            // Skillshot with a delay and speed.
            if (pLength >= input.Delay * speed - input.RealRadius &&
                Math.Abs(input.Speed - float.MaxValue) > float.Epsilon)
            {
                path = path.CutPath(Math.Max(0, input.Delay * speed - input.RealRadius));
                var tT = 0f;
                for (var i = 0; i < path.Count - 1; i++)
                {
                    var a         = path[i];
                    var b         = path[i + 1];
                    var tB        = a.Distance(b) / speed;
                    var direction = (b - a).Normalized();
                    a = a - speed * tT * direction;
                    var sol = a.VectorMovementCollision(b, speed, input.From.ToVector2(), input.Speed, tT);
                    var t   = (float)sol[0];
                    var pos = (Vector2)sol[1];

                    if (pos.IsValid() && t >= tT && t <= tT + tB)
                    {
                        var p = pos + input.RealRadius * direction;

                        if (input.Type == SkillshotType.SkillshotLine)
                        {
                            var alpha = (input.From.ToVector2() - p).AngleBetween(a - b);
                            if (alpha > 30 && alpha < 180 - 30)
                            {
                                var beta = (float)Math.Asin(input.RealRadius / p.Distance(input.From));
                                var cp1  = input.From.ToVector2() + (p - input.From.ToVector2()).Rotated(beta);
                                var cp2  = input.From.ToVector2() + (p - input.From.ToVector2()).Rotated(-beta);

                                pos = cp1.DistanceSquared(pos) < cp2.DistanceSquared(pos) ? cp1 : cp2;
                            }
                        }

                        return(new PredictionOutput
                        {
                            Input = input, CastPosition = pos.ToVector3(), UnitPosition = p.ToVector3(),
                            Hitchance =
                                Path.PathTracker.GetCurrentPath(input.Unit).Time < 0.1d
                                               ? HitChance.VeryHigh
                                               : HitChance.High
                        });
                    }

                    tT += tB;
                }
            }

            var position = path.Last();

            return(new PredictionOutput
            {
                Input = input, CastPosition = position.ToVector3(), UnitPosition = position.ToVector3(),
                Hitchance = HitChance.Medium
            });
        }
Beispiel #14
0
        /// <summary>
        ///     Returns Dashing Prediction
        /// </summary>
        /// <param name="input">
        ///     <see cref="PredictionInput" /> input
        /// </param>
        /// <returns><see cref="PredictionOutput" /> output</returns>
        internal static PredictionOutput GetDashingPrediction(PredictionInput input)
        {
            var dashData = input.Unit.GetDashInfo();
            var result = new PredictionOutput { Input = input };
            input.Delay += 0.1f;

            // Normal dashes.
            if (!dashData.IsBlink)
            {
                // Mid air:
                var dashPred = GetPositionOnPath(
                    input,
                    new List<Vector2> { input.Unit.ServerPosition.ToVector2(), dashData.Path.Last() },
                    dashData.Speed);
                if (dashPred.Hitchance >= HitChance.High)
                {
                    dashPred.CastPosition = dashPred.UnitPosition;
                    dashPred.Hitchance = HitChance.Dashing;
                    return dashPred;
                }

                // At the end of the dash:
                if (dashData.Path.PathLength() > 200)
                {
                    var endP = dashData.Path.Last();
                    var timeToPoint = input.Delay + (input.From.ToVector2().Distance(endP) / input.Speed);
                    if (timeToPoint
                        <= (input.Unit.Distance(endP) / dashData.Speed) + (input.RealRadius / input.Unit.MoveSpeed))
                    {
                        return new PredictionOutput
                                   {
                                       CastPosition = endP.ToVector3(), UnitPosition = endP.ToVector3(),
                                       Hitchance = HitChance.Dashing
                                   };
                    }
                }

                result.CastPosition = dashData.Path.Last().ToVector3();
                result.UnitPosition = result.CastPosition;

                // Figure out where the unit is going.
            }

            return result;
        }
Beispiel #15
0
        /// <summary>
        ///     Calculates the position to cast a spell according to unit movement.
        /// </summary>
        /// <param name="input">PredictionInput type</param>
        /// <param name="additionalSpeed">Additional Speed (Multiplicative)</param>
        /// <returns>The <see cref="PredictionOutput" /></returns>
        internal static PredictionOutput GetAdvancedPrediction(PredictionInput input, float additionalSpeed = 0)
        {
            var speed = Math.Abs(additionalSpeed) < float.Epsilon ? input.Speed : input.Speed * additionalSpeed;

            if (Math.Abs(speed - int.MaxValue) < float.Epsilon)
            {
                speed = 90000;
            }

            var unit = input.Unit;
            var position = PositionAfter(unit, 1, unit.MoveSpeed - 100);
            var prediction = position + (speed * (input.Delay / 1000));

            return new PredictionOutput()
                       {
                           UnitPosition = new Vector3(position.X, position.Y, unit.ServerPosition.Z),
                           CastPosition = new Vector3(prediction.X, prediction.Y, unit.ServerPosition.Z),
                           Hitchance = HitChance.High
                       };
        }
Beispiel #16
0
            /// <summary>
            ///     Returns an Area-of-Effect line prediction from a prediction input source.
            /// </summary>
            /// <param name="input">
            ///     <see cref="PredictionInput" /> input
            /// </param>
            /// <returns>
            ///     <see cref="PredictionOutput" /> output
            /// </returns>
            public static PredictionOutput GetLinePrediction(PredictionInput input)
            {
                var mainTargetPrediction = Movement.GetPrediction(input, false, true);
                var posibleTargets       = new List <PossibleTarget>
                {
                    new PossibleTarget
                    {
                        Position = mainTargetPrediction.UnitPosition.ToVector2(),
                        Unit     = input.Unit
                    }
                };

                if (mainTargetPrediction.Hitchance >= HitChance.Medium)
                {
                    // Add the posible targets  in range:
                    posibleTargets.AddRange(GetPossibleTargets(input));
                }

                if (posibleTargets.Count > 1)
                {
                    var candidates = new List <Vector2>();
                    foreach (var targetCandidates in
                             posibleTargets.Select(
                                 target => GetCandidates(input.From.ToVector2(), target.Position, input.Radius, input.Range))
                             )
                    {
                        candidates.AddRange(targetCandidates);
                    }

                    var bestCandidateHits      = -1;
                    var bestCandidate          = default(Vector2);
                    var bestCandidateHitPoints = new List <Vector2>();
                    var positionsList          = posibleTargets.Select(t => t.Position).ToList();

                    foreach (var candidate in candidates)
                    {
                        if (
                            GetHits(
                                input.From.ToVector2(),
                                candidate,
                                input.Radius + (input.Unit.BoundingRadius / 3) - 10,
                                new List <Vector2> {
                            posibleTargets[0].Position
                        }).Count() == 1)
                        {
                            var hits      = GetHits(input.From.ToVector2(), candidate, input.Radius, positionsList).ToList();
                            var hitsCount = hits.Count;
                            if (hitsCount >= bestCandidateHits)
                            {
                                bestCandidateHits      = hitsCount;
                                bestCandidate          = candidate;
                                bestCandidateHitPoints = hits.ToList();
                            }
                        }
                    }

                    if (bestCandidateHits > 1)
                    {
                        float   maxDistance = -1;
                        Vector2 p1 = default(Vector2), p2 = default(Vector2);

                        // Center the position
                        for (var i = 0; i < bestCandidateHitPoints.Count; i++)
                        {
                            for (var j = 0; j < bestCandidateHitPoints.Count; j++)
                            {
                                var startP = input.From.ToVector2();
                                var endP   = bestCandidate;
                                var proj1  = positionsList[i].ProjectOn(startP, endP);
                                var proj2  = positionsList[j].ProjectOn(startP, endP);
                                var dist   = Vector2.DistanceSquared(bestCandidateHitPoints[i], proj1.LinePoint)
                                             + Vector2.DistanceSquared(bestCandidateHitPoints[j], proj2.LinePoint);
                                if (dist >= maxDistance &&
                                    (proj1.LinePoint - positionsList[i]).AngleBetween(
                                        proj2.LinePoint - positionsList[j]) > 90)
                                {
                                    maxDistance = dist;
                                    p1          = positionsList[i];
                                    p2          = positionsList[j];
                                }
                            }
                        }

                        return(new PredictionOutput
                        {
                            Hitchance = mainTargetPrediction.Hitchance, AoeHitCount = bestCandidateHits,
                            UnitPosition = mainTargetPrediction.UnitPosition,
                            CastPosition = ((p1 + p2) * 0.5f).ToVector3(), Input = input
                        });
                    }
                }

                return(mainTargetPrediction);
            }
Beispiel #17
0
 public static PredictionOutput GetPrediction(PredictionInput input)
 {
     return input.GetPrediction(true, true);
 }
Beispiel #18
0
 /// <summary>
 ///     Returns Calculated Prediction based off given data values.
 /// </summary>
 /// <param name="input">
 ///     <see cref="PredictionInput" /> input
 /// </param>
 /// <returns>
 ///     <see cref="PredictionOutput" /> output
 /// </returns>
 public static PredictionOutput GetPrediction(PredictionInput input)
 {
     return(GetPrediction(input, true, true));
 }
Beispiel #19
0
 internal static PredictionOutput GetCirclePrediction(PredictionInput input)
 {
     var mainTargetPrediction = input.GetPrediction(false, true);
     var posibleTargets = new List<PossibleTarget>
                              {
                                  new PossibleTarget
                                      {
                                          Position = mainTargetPrediction.UnitPosition.ToVector2(),
                                          Unit = input.Unit
                                      }
                              };
     if (mainTargetPrediction.Hitchance >= HitChance.Medium)
     {
         posibleTargets.AddRange(GetPossibleTargets(input));
     }
     while (posibleTargets.Count > 1)
     {
         var mecCircle = ConvexHull.GetMec(posibleTargets.Select(i => i.Position).ToList());
         if (mecCircle.Radius <= input.RealRadius - 10
             && mecCircle.Center.DistanceSquared(input.RangeCheckFrom.ToVector2())
             < input.Range * input.Range)
         {
             return new PredictionOutput
                        {
                            AoeTargetsHit = posibleTargets.Select(i => (Obj_AI_Hero)i.Unit).ToList(),
                            CastPosition = mecCircle.Center.ToVector3(),
                            UnitPosition = mainTargetPrediction.UnitPosition,
                            Hitchance = mainTargetPrediction.Hitchance, Input = input,
                            AoeHitCount = posibleTargets.Count
                        };
         }
         float maxdist = -1;
         var maxdistindex = 1;
         for (var i = 1; i < posibleTargets.Count; i++)
         {
             var distance = posibleTargets[i].Position.DistanceSquared(posibleTargets[0].Position);
             if (distance > maxdist || maxdist.CompareTo(-1) == 0)
             {
                 maxdistindex = i;
                 maxdist = distance;
             }
         }
         posibleTargets.RemoveAt(maxdistindex);
     }
     return mainTargetPrediction;
 }
Beispiel #20
0
        /// <summary>
        ///     Returns Calculated Prediction based off given data values.
        /// </summary>
        /// <param name="input">
        ///     <see cref="PredictionInput" /> input
        /// </param>
        /// <param name="ft">Add Delay</param>
        /// <param name="checkCollision">Check Collision</param>
        /// <returns>
        ///     <see cref="PredictionOutput" /> output
        /// </returns>
        internal static PredictionOutput GetPrediction(PredictionInput input, bool ft, bool checkCollision)
        {
            PredictionOutput result = null;

            if (!input.Unit.IsValidTarget(float.MaxValue, false))
            {
                return(new PredictionOutput());
            }

            if (ft)
            {
                // Increase the delay due to the latency and server tick:
                input.Delay += Game.Ping / 2000f + 0.06f;

                if (input.AoE)
                {
                    return(Cluster.GetAoEPrediction(input));
                }
            }

            // Target too far away.
            if (Math.Abs(input.Range - float.MaxValue) > float.Epsilon &&
                input.Unit.DistanceSquared(input.RangeCheckFrom) > Math.Pow(input.Range * 1.5, 2))
            {
                return(new PredictionOutput {
                    Input = input
                });
            }

            // Unit is dashing.
            if (input.Unit.IsDashing())
            {
                result = GetDashingPrediction(input);
            }
            else
            {
                // Unit is immobile.
                var remainingImmobileT = UnitIsImmobileUntil(input.Unit);
                if (remainingImmobileT >= 0d)
                {
                    result = GetImmobilePrediction(input, remainingImmobileT);
                }
            }

            // Normal prediction
            if (result == null)
            {
                result = GetAdvancedPrediction(input);
            }

            // Check if the unit position is in range
            if (Math.Abs(input.Range - float.MaxValue) > float.Epsilon)
            {
                if (result.Hitchance >= HitChance.High &&
                    input.RangeCheckFrom.DistanceSquared(input.Unit.Position)
                    > Math.Pow(input.Range + input.RealRadius * 3 / 4, 2))
                {
                    result.Hitchance = HitChance.Medium;
                }

                if (input.RangeCheckFrom.DistanceSquared(result.UnitPosition)
                    > Math.Pow(input.Range + (input.Type == SkillshotType.SkillshotCircle ? input.RealRadius : 0), 2))
                {
                    result.Hitchance = HitChance.OutOfRange;
                }

                if (input.RangeCheckFrom.DistanceSquared(result.CastPosition) > Math.Pow(input.Range, 2))
                {
                    if (result.Hitchance != HitChance.OutOfRange)
                    {
                        result.CastPosition = input.RangeCheckFrom
                                              + input.Range
                                              * (result.UnitPosition - input.RangeCheckFrom).Normalized().SetZ();
                    }
                    else
                    {
                        result.Hitchance = HitChance.OutOfRange;
                    }
                }
            }

            // Check for collision
            if (checkCollision && input.Collision)
            {
                var positions = new List <Vector3> {
                    result.UnitPosition, result.CastPosition, input.Unit.Position
                };
                var originalUnit = input.Unit;
                result.CollisionObjects = Collision.GetCollision(positions, input);
                result.CollisionObjects.RemoveAll(x => x.NetworkId == originalUnit.NetworkId);
                result.Hitchance = result.CollisionObjects.Count > 0 ? HitChance.Collision : result.Hitchance;
            }

            return(result);
        }
Beispiel #21
0
 internal static PredictionOutput GetLinePrediction(PredictionInput input)
 {
     var mainTargetPrediction = input.GetPrediction(false, true);
     var posibleTargets = new List<PossibleTarget>
                              {
                                  new PossibleTarget
                                      {
                                          Position = mainTargetPrediction.UnitPosition.ToVector2(),
                                          Unit = input.Unit
                                      }
                              };
     if (mainTargetPrediction.Hitchance >= HitChance.Medium)
     {
         posibleTargets.AddRange(GetPossibleTargets(input));
     }
     if (posibleTargets.Count > 1)
     {
         var candidates = new List<Vector2>();
         foreach (var targetCandidates in
             posibleTargets.Select(
                 i => GetCandidates(input.From.ToVector2(), i.Position, input.Radius, input.Range)))
         {
             candidates.AddRange(targetCandidates);
         }
         var bestCandidateHits = -1;
         var bestCandidate = new Vector2();
         var bestCandidateHitPoints = new List<Vector2>();
         var positionsList = posibleTargets.Select(i => i.Position).ToList();
         foreach (var candidate in candidates)
         {
             if (
                 GetHits(
                     input.From.ToVector2(),
                     candidate,
                     input.Radius + input.Unit.BoundingRadius / 3 - 10,
                     new List<Vector2> { posibleTargets[0].Position }).Count == 1)
             {
                 var hits = GetHits(input.From.ToVector2(), candidate, input.Radius, positionsList);
                 var hitsCount = hits.Count;
                 if (hitsCount >= bestCandidateHits)
                 {
                     bestCandidateHits = hitsCount;
                     bestCandidate = candidate;
                     bestCandidateHitPoints = hits;
                 }
             }
         }
         if (bestCandidateHits > 1)
         {
             float maxDistance = -1;
             Vector2 p1 = new Vector2(), p2 = new Vector2();
             for (var i = 0; i < bestCandidateHitPoints.Count; i++)
             {
                 for (var j = 0; j < bestCandidateHitPoints.Count; j++)
                 {
                     var startP = input.From.ToVector2();
                     var endP = bestCandidate;
                     var proj1 = positionsList[i].ProjectOn(startP, endP);
                     var proj2 = positionsList[j].ProjectOn(startP, endP);
                     var dist = bestCandidateHitPoints[i].DistanceSquared(proj1.LinePoint)
                                + bestCandidateHitPoints[j].DistanceSquared(proj2.LinePoint);
                     if (dist >= maxDistance
                         && (proj1.LinePoint - positionsList[i]).AngleBetween(
                             proj2.LinePoint - positionsList[j]) > 90)
                     {
                         maxDistance = dist;
                         p1 = positionsList[i];
                         p2 = positionsList[j];
                     }
                 }
             }
             return new PredictionOutput
                        {
                            Hitchance = mainTargetPrediction.Hitchance, AoeHitCount = bestCandidateHits,
                            UnitPosition = mainTargetPrediction.UnitPosition,
                            CastPosition = ((p1 + p2) * 0.5f).ToVector3(), Input = input
                        };
         }
     }
     return mainTargetPrediction;
 }
Beispiel #22
0
 private static PredictionOutput GetPositionOnPath(PredictionInput input, List<Vector2> path, float speed = -1)
 {
     speed = Math.Abs(speed - (-1)) < float.Epsilon ? input.Unit.MoveSpeed : speed;
     if (path.Count <= 1)
     {
         return new PredictionOutput
                    {
                        Input = input, UnitPosition = input.Unit.ServerPosition,
                        CastPosition = input.Unit.ServerPosition, Hitchance = HitChance.VeryHigh
                    };
     }
     var pLength = path.PathLength();
     if (pLength >= input.Delay * speed - input.RealRadius
         && Math.Abs(input.Speed - float.MaxValue) < float.Epsilon)
     {
         var tDistance = input.Delay * speed - input.RealRadius;
         for (var i = 0; i < path.Count - 1; i++)
         {
             var a = path[i];
             var b = path[i + 1];
             var d = a.Distance(b);
             if (d >= tDistance)
             {
                 var direction = (b - a).Normalized();
                 var cp = a + direction * tDistance;
                 var p = a
                         + direction
                         * (i == path.Count - 2
                                ? Math.Min(tDistance + input.RealRadius, d)
                                : tDistance + input.RealRadius);
                 return new PredictionOutput
                            {
                                Input = input, CastPosition = cp.ToVector3(), UnitPosition = p.ToVector3(),
                                Hitchance =
                                    Path.PathTracker.GetCurrentPath(input.Unit).Time < 0.1d
                                        ? HitChance.VeryHigh
                                        : HitChance.High
                            };
             }
             tDistance -= d;
         }
     }
     if (pLength >= input.Delay * speed - input.RealRadius
         && Math.Abs(input.Speed - float.MaxValue) > float.Epsilon)
     {
         path =
             path.CutPath(
                 input.Delay * speed
                 - ((input.Type == SkillshotType.SkillshotLine || input.Type == SkillshotType.SkillshotCone)
                    && input.Unit.DistanceSquared(input.From) < 200 * 200
                        ? 0
                        : input.RealRadius));
         var tT = 0f;
         for (var i = 0; i < path.Count - 1; i++)
         {
             var a = path[i];
             var b = path[i + 1];
             var tB = a.Distance(b) / speed;
             var direction = (b - a).Normalized();
             a = a - speed * tT * direction;
             var sol = a.VectorMovementCollision(b, speed, input.From.ToVector2(), input.Speed, tT);
             var t = (float)sol[0];
             var pos = (Vector2)sol[1];
             if (pos.IsValid() && t >= tT && t <= tT + tB)
             {
                 if (pos.DistanceSquared(b) < 20)
                 {
                     break;
                 }
                 var p = pos + input.RealRadius * direction;
                 /*if (input.Type == SkillshotType.SkillshotLine)
                 {
                     var alpha = (input.From.ToVector2() - p).AngleBetween(a - b);
                     if (alpha > 30 && alpha < 180 - 30)
                     {
                         var beta = (float)Math.Asin(input.RealRadius / p.Distance(input.From));
                         var cp1 = input.From.ToVector2() + (p - input.From.ToVector2()).Rotated(beta);
                         var cp2 = input.From.ToVector2() + (p - input.From.ToVector2()).Rotated(-beta);
                         pos = cp1.DistanceSquared(pos) < cp2.DistanceSquared(pos) ? cp1 : cp2;
                     }
                 }*/
                 return new PredictionOutput
                            {
                                Input = input, CastPosition = pos.ToVector3(), UnitPosition = p.ToVector3(),
                                Hitchance =
                                    Path.PathTracker.GetCurrentPath(input.Unit).Time < 0.1d
                                        ? HitChance.VeryHigh
                                        : HitChance.High
                            };
             }
             tT += tB;
         }
     }
     var position = path.Last();
     return new PredictionOutput
                {
                    Input = input, CastPosition = position.ToVector3(), UnitPosition = position.ToVector3(),
                    Hitchance = HitChance.Medium
                };
 }