C# Common.PredictionInput类代码示例

 public static bool AnalyzeQ(PredictionInput input, PredictionOutput output)
 {
     var posList = new List<Vector3> { ObjectManager.Player.ServerPosition, output.CastPosition };
     var collision = Collision.GetCollision(posList, input);
     var minions = collision.Count(collisionObj => collisionObj.IsMinion);
     return minions > 1;
 }

        /// <summary>
        ///     The get updated prediction.
        /// </summary>
        /// <param name="input">
        ///     The input.
        /// </param>
        /// <returns>
        ///     The <see cref="PredictionOutput" />.
        /// </returns>
        internal static PredictionOutput GetUpdatedPrediction(PredictionInput input)
        {
            if (Math.Abs(input.Speed - float.MaxValue) < float.Epsilon)
            {
                input.Speed = 90000;
            }

            var toTarget = Vector3.Normalize(input.Unit.ServerPosition - input.From);
            var targetVelocity = CalculateVelocity(
                input.Unit.ServerPosition,
                input.Unit.Path.LastOrDefault(),
                input.Unit.MoveSpeed);

            var a = Vector3.Dot(targetVelocity, targetVelocity) - (input.Speed * input.Speed);
            var b = 2 * Vector3.Dot(targetVelocity, toTarget);
            var c = Vector3.Dot(toTarget, toTarget);

            var p = -b / (2 * a);
            var q = (float)Math.Sqrt((b * b) - 4 * a * c) / (2 * a);

            var theorem1 = p - q;
            var theorem2 = p + q;
            var t = (theorem1 > theorem2 && theorem2 > 0) ? theorem2 : theorem1;

            var result = new PredictionOutput()
                             {
                                 CastPosition = input.Unit.ServerPosition + targetVelocity * (t + input.Delay),
                                 UnitPosition = input.Unit.ServerPosition, Hitchance = HitChance.VeryHigh
                             };

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

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

            // Check for collision
            if (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;
        }

 static void Game_OnGameLoad(EventArgs args)
 {
     if(ObjectManager.Player.ChampionName != "Blitzcrank") return;
     config = new Menu("AutoGrab", "grab", true);
     Menu menuTS = new Menu("Selector: ", "targ");
     SimpleTs.AddToMenu(menuTS);
     config.AddSubMenu(menuTS);
     config.AddItem(new MenuItem("grabem", "Pull While AA'ing")).SetValue(new KeyBind(32, KeyBindType.Press));
     config.AddToMainMenu();
     p = new PredictionInput {Delay = .25f, Radius = 35, Speed = 1800};
     Game.OnGameProcessPacket += Game_OnGameProcessPacket;
 }

        static bool CollisionCheckerino(Obj_AI_Hero source, Obj_AI_Hero target, float width)
        {
            var input = new PredictionInput
            {
                Radius = width,
                Unit = source,
            };

            input.CollisionObjects[0] = CollisionableObjects.Heroes;
            input.CollisionObjects[1] = CollisionableObjects.YasuoWall;

            return !Collision.GetCollision(new List<Vector3> { target.ServerPosition }, input).Where(x => x.NetworkId != x.NetworkId).Any();
        }

        internal static List<Obj_AI_Base> getCollisionMinions(Obj_AI_Hero source, SharpDX.Vector3 targetPos, float predDelay, float predWidth, float predSpeed)
        {
            var input = new PredictionInput
            {
                Unit = source,
                Radius = predWidth,
                Delay = predDelay,
                Speed = predSpeed,
            };

            input.CollisionObjects[0] = CollisionableObjects.Minions;

            return Collision.GetCollision(new List<SharpDX.Vector3> { targetPos }, input).OrderBy(obj => obj.Distance(source, false)).ToList();
        }

        /// <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(AIHeroClient 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 = new[] { CollisionableObjects.Minions }
            };

            return
                Collision.GetCollision(new List<Vector3> { targetPosition }, input)
                    .OrderBy(x => x.Distance(source))
                    .ToList();
        }

        public static IEnumerable<Obj_AI_Base> QGetCollisionMinions(Vector3 source, Vector3 targetposition, float width, float range, CollisionableObjects[] collisionObjects)
        {
            PredictionInput input = new PredictionInput {From = source, Radius = width, Range = range};

            if (collisionObjects.Length > 0)
            {
                for (int i = 0; collisionObjects.Length != 0; i ++)
                {
                    input.CollisionObjects[i] = collisionObjects[i];
                }
            }
            else
            {
                input.CollisionObjects[0] = CollisionableObjects.Minions;
            }

            return
                Collision.GetCollision(new List<Vector3> {targetposition}, input).OrderBy(obj => obj.Distance(source)).ToList();
        }

				public static PredictionOutput GetPrediction(PredictionInput input) {
					var mainTargetPrediction = Prediction.GetPrediction(input, false, true);
					var posibleTargets = new List<PossibleTarget>
				{
					new PossibleTarget { Position = mainTargetPrediction.UnitPosition.To2D(), 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.To2D();
						}

						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(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;
							}
						}

						bestCandidate = bestCandidate + input.From.To2D();

						if (bestCandidateHits > 1 && input.From.To2D().Distance(bestCandidate, true) > 50 * 50)
						{
							return new PredictionOutput
							{
								Hitchance = mainTargetPrediction.Hitchance,
								_aoeTargetsHitCount = bestCandidateHits,
								UnitPosition = mainTargetPrediction.UnitPosition,
								CastPosition = bestCandidate.To3D(),
								Input = input
							};
						}
					}
					return mainTargetPrediction;
				}

			internal static List<PossibleTarget> GetPossibleTargets(PredictionInput input) {
				var result = new List<PossibleTarget>();
				var originalUnit = input.Unit;
				foreach (var enemy in
					HeroManager.Enemies.FindAll(
						h =>
							h.NetworkId != originalUnit.NetworkId &&
							h.IsValidTarget((input.Range + 200 + input.RealRadius), true, input.RangeCheckFrom)))
				{
					input.Unit = enemy;
					var prediction = Prediction.GetPrediction(input, false, false);
					if (prediction.Hitchance >= HitChance.High)
					{
						result.Add(new PossibleTarget { Position = prediction.UnitPosition.To2D(), Unit = enemy });
					}
				}
				return result;
			}

			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.To3D(),
								UnitPosition = p.To3D(),
								Hitchance = 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)
				{
					var d = input.Delay * speed - input.RealRadius;
					if (input.Type == SkillshotType.SkillshotLine || input.Type == SkillshotType.SkillshotCone)
					{
						if (input.From.Distance(input.Unit.ServerPosition, true) < 200 * 200)
						{
							d = input.Delay * speed;
						}
					}

					path = path.CutPath(d);
					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 = Geometry.VectorMovementCollision(a, b, speed, input.From.To2D(), input.Speed, tT);
						var t = (float)sol[0];
						var pos = (Vector2)sol[1];

						if (pos.IsValid() && t >= tT && t <= tT + tB)
						{
							if (pos.Distance(b, true) < 20)
								break;
							var p = pos + input.RealRadius * direction;

							if (input.Type == SkillshotType.SkillshotLine && false)
							{
								var alpha = (input.From.To2D() - 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.To2D() + (p - input.From.To2D()).Rotated(beta);
									var cp2 = input.From.To2D() + (p - input.From.To2D()).Rotated(-beta);

									pos = cp1.Distance(pos, true) < cp2.Distance(pos, true) ? cp1 : cp2;
								}
							}

							return new PredictionOutput
							{
								Input = input,
								CastPosition = pos.To3D(),
//.........这里部分代码省略.........

			internal static PredictionOutput GetImmobilePrediction(PredictionInput input, double remainingImmobileT) {
				var timeToReachTargetPosition = input.Delay + input.Unit.Distance(input.From) / input.Speed;

				if (timeToReachTargetPosition <= remainingImmobileT + input.RealRadius / input.Unit.MoveSpeed)
				{
					return new PredictionOutput
					{
						CastPosition = input.Unit.ServerPosition,
						UnitPosition = input.Unit.Position,
						Hitchance = HitChance.Immobile
					};
				}

				return new PredictionOutput
				{
					Input = input,
					CastPosition = input.Unit.ServerPosition,
					UnitPosition = input.Unit.ServerPosition,
					Hitchance = HitChance.High
					/*timeToReachTargetPosition - remainingImmobileT + input.RealRadius / input.Unit.MoveSpeed < 0.4d ? HitChance.High : HitChance.Medium*/
				};
			}

			internal static PredictionOutput WayPointAnalysis(PredictionOutput result, PredictionInput input) {

				if (!input.Unit.IsValid<Obj_AI_Hero>() || input.Radius == 1)
				{
					result.Hitchance = HitChance.VeryHigh;
					return result;
				}

				//Program.debug("PRED: FOR CHAMPION " + input.Unit.BaseSkinName);

				// CAN'T MOVE SPELLS ///////////////////////////////////////////////////////////////////////////////////

				if (UnitTracker.GetSpecialSpellEndTime(input.Unit) > 0 || input.Unit.HasBuff("Recall"))
				{

					result.Hitchance = HitChance.VeryHigh;
					return result;

				}

				// PREPARE MATH ///////////////////////////////////////////////////////////////////////////////////

				result.Hitchance = HitChance.Medium;

				var lastWaypiont = input.Unit.GetWaypoints().Last().To3D();
				var distanceUnitToWaypoint = lastWaypiont.Distance(input.Unit.ServerPosition);
				var distanceFromToUnit = input.From.Distance(input.Unit.ServerPosition);
				var distanceFromToWaypoint = lastWaypiont.Distance(input.From);

				float speedDelay = distanceFromToUnit / input.Speed;

				if (Math.Abs(input.Speed - float.MaxValue) < float.Epsilon)
					speedDelay = 0;
				else
					speedDelay = distanceFromToUnit / input.Speed;

				float totalDelay = speedDelay + input.Delay;
				float moveArea = input.Unit.MoveSpeed * totalDelay;
				float fixRange = moveArea * 0.5f;
				double angleMove = 30 + (input.Radius / 13) - (totalDelay * 2);
				float backToFront = moveArea * 1.5f;
				float pathMinLen = 1000f;

				if (UnitTracker.GetLastNewPathTime(input.Unit) < 0.1d)
				{
					pathMinLen = 700f + backToFront;
					result.Hitchance = HitChance.High;
				}

				if (input.Type == SkillshotType.SkillshotCircle)
				{
					fixRange -= input.Radius / 2;
				}

				// SPAM CLICK ///////////////////////////////////////////////////////////////////////////////////

				if (UnitTracker.PathCalc(input.Unit))
				{
					if (distanceFromToUnit < input.Range - fixRange)
					{
						result.Hitchance = HitChance.VeryHigh;
						return result;
					}

					result.Hitchance = HitChance.High;
					return result;
				}

				// NEW VISABLE ///////////////////////////////////////////////////////////////////////////////////

				if (UnitTracker.GetLastVisableTime(input.Unit) < 0.08d)
				{
					result.Hitchance = HitChance.Medium;
					return result;
				}

				// SPECIAL CASES ///////////////////////////////////////////////////////////////////////////////////

				if (distanceFromToUnit < 300 || distanceFromToWaypoint < 200)
				{
					result.Hitchance = HitChance.VeryHigh;
					return result;

				}

				// LONG CLICK DETECTION ///////////////////////////////////////////////////////////////////////////////////

				if (distanceUnitToWaypoint > pathMinLen)
				{
					result.Hitchance = HitChance.VeryHigh;
					return result;
				}

				// RUN IN LANE DETECTION ///////////////////////////////////////////////////////////////////////////////////

				if (distanceFromToWaypoint > distanceFromToUnit + fixRange && GetAngle(input.From, input.Unit) < angleMove)
				{
					result.Hitchance = HitChance.VeryHigh;
					return result;
				}
//.........这里部分代码省略.........

 private Vector3 AssistedQLogic(out int hits)
 {
     try
     {
         if (Ball.IsMoving)
         {
             hits = 0;
             return Vector3.Zero;
         }
         var center = Vector2.Zero;
         float radius = -1;
         var count = 0;
         var range = (Q.Range + R.Width) * 1.5f;
         var input = new PredictionInput
         {
             Collision = false,
             From = Ball.Position,
             RangeCheckFrom = Ball.Position,
             Delay = (Q.Delay + R.Delay) - 0.1f,
             Range = Q.Range + R.Width / 2f,
             Speed = Q.Speed,
             Radius = R.Width,
             Type = R.Type
         };
         var points = new List<Vector2>();
         foreach (var enemy in GameObjects.EnemyHeroes.Where(t => t.IsValidTarget(range)))
         {
             input.Unit = enemy;
             var pred = Prediction.GetPrediction(input);
             if (pred.Hitchance >= HitChance.Low)
             {
                 points.Add(pred.UnitPosition.To2D());
             }
         }
         if (points.Any())
         {
             var possibilities = ListExtensions.ProduceEnumeration(points).Where(p => p.Count > 1).ToList();
             if (possibilities.Any())
             {
                 foreach (var possibility in possibilities)
                 {
                     var mec = MEC.GetMec(possibility);
                     if (mec.Radius < R.Width && Player.Distance(mec.Center) < range)
                     {
                         if (possibility.Count > count || possibility.Count == count && mec.Radius < radius)
                         {
                             center = mec.Center;
                             radius = mec.Radius;
                             count = possibility.Count;
                         }
                     }
                 }
                 if (!center.Equals(Vector2.Zero))
                 {
                     hits = count;
                     return center.To3D();
                 }
             }
             var dTarget = GameObjects.EnemyHeroes.FirstOrDefault(t => t.IsValidTarget(range));
             if (dTarget != null)
             {
                 hits = 1;
                 return dTarget.Position;
             }
         }
     }
     catch (Exception ex)
     {
         Global.Logger.AddItem(new LogItem(ex));
     }
     hits = 0;
     return Vector3.Zero;
 }

        public static void OnWaveClear()
        {
            // Mana check
            if (player.ManaPercentage() < Config.SliderLinks["waveMana"].Value.Value)
                return;

            // Check spells
            if (!Q.IsEnabledAndReady(Mode.WAVE) && !E.IsEnabledAndReady(Mode.WAVE))
                return;

            // Minions around
            var minions = MinionManager.GetMinions(Q.Range, MinionTypes.All, MinionTeam.Enemy, MinionOrderTypes.MaxHealth);
            if (minions.Count == 0)
                return;

            // Q usage
            if (Q.IsEnabledAndReady(Mode.WAVE) && !player.IsDashing())
            {
                int hitNumber = Config.SliderLinks["waveNumQ"].Value.Value;

                // Validate available minions
                if (minions.Count >= hitNumber)
                {
                    // Get only killable minions
                    var killable = minions.Where(m => m.Health < Q.GetDamage(m));
                    if (killable.Count() > 0)
                    {
                        // Prepare prediction input for Collision check
                        var input = new PredictionInput()
                        {
                            From = Q.From,
                            Collision = Q.Collision,
                            Delay = Q.Delay,
                            Radius = Q.Width,
                            Range = Q.Range,
                            RangeCheckFrom = Q.RangeCheckFrom,
                            Speed = Q.Speed,
                            Type = Q.Type,
                            CollisionObjects = new[] { CollisionableObjects.Heroes, CollisionableObjects.Minions, CollisionableObjects.YasuoWall }
                        };

                        // Helpers
                        var currentHitNumber = 0;
                        var castPosition = Vector3.Zero;

                        // Validate the collision
                        foreach (var target in killable)
                        {
                            // Update unit in the input
                            input.Unit = target;

                            // Get colliding objects
                            var colliding = LeagueSharp.Common.Collision.GetCollision(new List<Vector3>() { player.ServerPosition.Extend(Prediction.GetPrediction(input).UnitPosition, Q.Range) }, input)
                                .MakeUnique()
                                .OrderBy(e => e.Distance(player, true))
                                .ToList();

                            // Validate collision
                            if (colliding.Count >= hitNumber && !colliding.Contains(player))
                            {
                                // Calculate hit number
                                int i = 0;
                                foreach (var collide in colliding)
                                {
                                    // Break loop here since we can't kill the target
                                    if (Q.GetDamage(collide) < collide.Health)
                                    {
                                        if (currentHitNumber < i && i >= hitNumber)
                                        {
                                            currentHitNumber = i;
                                            castPosition = Q.GetPrediction(collide).CastPosition;
                                        }
                                        break;
                                    }

                                    // Increase hit count
                                    i++;
                                }
                            }
                        }

                        // Check if we have a valid target with enough targets being killed
                        if (castPosition != Vector3.Zero)
                        {
                            if (Q.Cast(castPosition))
                                return;
                        }
                    }
                }
            }

            // General E usage
            if (E.IsEnabledAndReady(Mode.WAVE))
            {
                int hitNumber = Config.SliderLinks["waveNumE"].Value.Value;

                // Get minions in E range
                var minionsInRange = minions.Where(m => E.IsInRange(m));

                // Validate available minions
//.........这里部分代码省略.........

        /// <summary>
        ///     Gets the collision minions
        /// </summary>
        /// <param name="source">
        ///     the source
        /// </param>
        /// <param name="targetPosition">
        ///     the target position
        /// </param>
        /// <returns>
        ///     The list of minions
        /// </returns>
        private IEnumerable<Obj_AI_Base> GetCollisionMinions(Obj_AI_Base source, Vector3 targetPosition)
        {
            var input = new PredictionInput
                            {
                                Unit = source, Radius = this.spells[SpellSlot.Q].Width, 
                                Delay = this.spells[SpellSlot.Q].Delay, Speed = this.spells[SpellSlot.Q].Speed
                            };

            input.CollisionObjects[0] = CollisionableObjects.Minions;

            return
                Collision.GetCollision(new List<Vector3> { targetPosition }, input)
                    .OrderBy(obj => obj.Distance(source))
                    .ToList();
        }