Exemple #1
0
        public static PredictionOutput GetCirclePrediction(PredictionInput input)
        {
            var mainTargetPrediction = Prediction.Instance.GetPrediction(input, false, true);
            var posibleTargets       = new List <PossibleTarget>
            {
                new PossibleTarget {
                    Position = (Vector2)mainTargetPrediction.UnitPosition, Unit = input.Unit
                }
            };

            if (mainTargetPrediction.HitChance >= HitChance.Medium)
            {
                posibleTargets.AddRange(AoePrediction.GetPossibleTargets(input));
            }

            while (posibleTargets.Count > 1)
            {
                var mecCircle = Mec.GetMec(posibleTargets.Select(h => h.Position).ToList());

                if (mecCircle.Radius <= input.RealRadius - 10 && mecCircle.Center.DistanceSquared(input.RangeCheckFrom)
                    < input.Range * input.Range)
                {
                    return(new PredictionOutput
                    {
                        AoeTargetsHit = posibleTargets.Select(h => (Obj_AI_Hero)h.Unit).ToList(),
                        CastPosition = (Vector3)mecCircle.Center,
                        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)
                    {
                        continue;
                    }

                    maxdistindex = i;
                    maxdist      = distance;
                }

                posibleTargets.RemoveAt(maxdistindex);
            }

            return(mainTargetPrediction);
        }
Exemple #2
0
            public static PredictionOutput GetPrediction(PredictionInput input)
            {
                PredictionOutput prediction = Prediction.GetPrediction(input, false, true);
                List <AoePrediction.PossibleTarget> list = new List <AoePrediction.PossibleTarget>
                {
                    new AoePrediction.PossibleTarget
                    {
                        Position = prediction.UnitPosition.ToVector2(),
                        Unit     = input.Unit
                    }
                };

                if (prediction.Hitchance >= HitChance.Medium)
                {
                    list.AddRange(AoePrediction.GetPossibleTargets(input));
                }
                while (list.Count > 1)
                {
                    var mec = Mec.GetMec((from h in list
                                          select h.Position).ToList <Vector2>());
                    if (mec.Radius <= input.RealRadius - 10f && Vector2.DistanceSquared(mec.Center, input.RangeCheckFrom.ToVector2()) < input.Range * input.Range)
                    {
                        PredictionOutput predictionOutput = new PredictionOutput();
                        predictionOutput.AoeTargetsHit = (from hero in list
                                                          select hero.Unit).ToList <AIBaseClient>();
                        predictionOutput.CastPosition        = mec.Center.ToVector3();
                        predictionOutput.UnitPosition        = prediction.UnitPosition;
                        predictionOutput.Hitchance           = prediction.Hitchance;
                        predictionOutput.Input               = input;
                        predictionOutput._aoeTargetsHitCount = list.Count;
                        return(predictionOutput);
                    }
                    float num   = -1f;
                    int   index = 1;
                    for (int i = 1; i < list.Count; i++)
                    {
                        float num2 = Vector2.DistanceSquared(list[i].Position, list[0].Position);
                        if (num2 > num || num.CompareTo(-1f) == 0)
                        {
                            index = i;
                            num   = num2;
                        }
                    }
                    list.RemoveAt(index);
                }
                return(prediction);
            }
Exemple #3
0
        public static Result GetCircleAoePrediction(this Spell spell, Obj_AI_Hero target, HitChance hitChance,
                                                    bool boundingRadius = true, bool extended = true, Vector3?sourcePosition = null)
        {
            try
            {
                if (spell == null || target == null)
                {
                    return(new Result(Vector3.Zero, new List <Obj_AI_Hero>()));
                }
                var fromPosition = sourcePosition ?? ObjectManager.GetLocalPlayer().ServerPosition;
                var hits         = new List <Obj_AI_Hero>();
                var center       = Vector3.Zero;
                var radius       = float.MaxValue;
                var range        = spell.Range + (extended ? spell.Width * 0.85f : 0) +
                                   (boundingRadius ? target.BoundingRadius * BoundingRadiusMultiplicator : 0);
                var positions = (from t in GameObjects.EnemyHeroes
                                 where t.IsValidTarget(range * 1.5f, false, false, fromPosition)
                                 let prediction = spell.GetPrediction(t)
                                                  where prediction.HitChance >= hitChance
                                                  select new Position(t, prediction.UnitPosition)).ToList();
                var spellWidth = spell.Width;
                if (positions.Any())
                {
                    var mainTarget    = positions.FirstOrDefault(p => p.Hero.NetworkId == target.NetworkId);
                    var possibilities =
                        ProduceEnumeration(
                            positions.Where(
                                p => p.UnitPosition.Distance(mainTarget.UnitPosition) <= spell.Width * 0.85f).ToList())
                        .Where(p => p.Count > 0 && p.Any(t => t.Hero.NetworkId == mainTarget.Hero.NetworkId))
                        .ToList();
                    foreach (var possibility in possibilities)
                    {
                        var mec      = Mec.GetMec(possibility.Select(p => p.UnitPosition.To2D()).ToList());
                        var distance = spell.From.Distance(mec.Center.To3D());
                        if (mec.Radius < spellWidth && distance < range)
                        {
                            var lHits  = new List <Obj_AI_Hero>();
                            var circle =
                                new MyPolygon.Circle(
                                    spell.From.Extend(
                                        mec.Center.To3D(), spell.Range > distance ? distance : spell.Range), spell.Width);

                            if (boundingRadius)
                            {
                                lHits.AddRange(
                                    from position in positions
                                    where
                                    new MyPolygon.Circle(
                                        position.UnitPosition,
                                        position.Hero.BoundingRadius * BoundingRadiusMultiplicator).Points.Any(
                                        p => circle.IsInside(p))
                                    select position.Hero);
                            }
                            else
                            {
                                lHits.AddRange(
                                    from position in positions
                                    where circle.IsInside(position.UnitPosition)
                                    select position.Hero);
                            }

                            if ((lHits.Count > hits.Count || lHits.Count == hits.Count && mec.Radius < radius ||
                                 lHits.Count == hits.Count &&
                                 spell.From.Distance(circle.Center.To3D()) < spell.From.Distance(center)) &&
                                lHits.Any(p => p.NetworkId == target.NetworkId))
                            {
                                center = To3D2(circle.Center);
                                radius = mec.Radius;
                                hits.Clear();
                                hits.AddRange(lHits);
                            }
                        }
                    }
                    if (!center.Equals(Vector3.Zero))
                    {
                        return(new Result(center, hits));
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
            return(new Result(Vector3.Zero, new List <Obj_AI_Hero>()));
        }