C# Obj_AI_Base.LSIsDashing方法代码示例

        /// <summary>
        ///     Gets fast-predicted unit position
        /// </summary>
        /// <param name="target">Target</param>
        /// <param name="delay">Spell delay</param>
        /// <param name="missileSpeed">Spell missile speed</param>
        /// <param name="from">Spell casted position</param>
        /// <returns></returns>
        public static Vector2 GetFastUnitPosition(Obj_AI_Base target, float delay, float missileSpeed = 0,
            Vector2? from = null, float distanceSet = 0)
        {
            var path = target.GetWaypoints();
            if (from == null)
                from = ObjectManager.Player.ServerPosition.LSTo2D();

            if (path.Count <= 1 || (target is AIHeroClient && target.Spellbook.IsChanneling) || Utility.IsImmobileTarget(target))
                return target.ServerPosition.LSTo2D();

            if (target.LSIsDashing())
                return target.LSGetDashInfo().Path.Last();

            var distance = distanceSet;

            if (distance == 0)
            {
                var targetDistance = from.Value.LSDistance(target.ServerPosition);
                var flyTime = targetDistance/missileSpeed;

                if (missileSpeed != 0 && path.Count == 2)
                {
                    var Vt = (path[1] - path[0]).LSNormalized()*target.MoveSpeed;
                    var Vs = (target.ServerPosition.LSTo2D() - from.Value).LSNormalized()*missileSpeed;
                    var Vr = Vt - Vs;

                    flyTime = targetDistance/Vr.Length();
                }

                var t = flyTime + delay + Game.Ping/2000f;
                distance = t*target.MoveSpeed;
            }

            for (var i = 0; i < path.Count - 1; i++)
            {
                var d = path[i + 1].LSDistance(path[i]);
                if (distance == d)
                    return path[i + 1];
                if (distance < d)
                    return path[i] + distance*(path[i + 1] - path[i]).LSNormalized();
                distance -= d;
            }

            return path.Last();
        }

 private static void HandeR(Obj_AI_Base target, Vector3 toVector3, bool toBarrel)
 {
     if (target == null || !toVector3.IsValid())
     {
         return;
     }
     var pred = LeagueSharp.Common.Prediction.GetPrediction(target, target.LSDistance(Player.ServerPosition) / R.Speed);
     if (pred.Hitchance >= HitChance.VeryHigh && !justE && !target.LSIsDashing())
     {
         var cast = pred.UnitPosition.LSExtend(toVector3, -100);
         if (Player.LSDistance(cast) < R.Range && checkBuffs(target, Player.LSDistance(cast)) && pred.UnitPosition.LSDistance(target.Position) < 15 && ((!CombatHelper.CheckWalls(target.Position, toVector3)) || (toBarrel && savedQ.position.LSDistance(target.Position) < QExplosionRange)))
         {
             if (toBarrel && 4000 - savedQ.deltaT() > (Player.LSDistance(cast) + cast.LSDistance(savedQ.position)) / R.Speed)
             {
                 R.Cast(cast);
                 return;
             }
             else if (!toBarrel)
             {
                 R.Cast(cast);
             }
         }
     }
 }

        /// <summary>
        ///     Gets Prediction result while unit is dashing
        /// </summary>
        /// <param name="target">Target for spell</param>
        /// <param name="width">Spell width</param>
        /// <param name="delay">Spell delay</param>
        /// <param name="missileSpeed">Spell missile speed</param>
        /// <param name="range">Spell range</param>
        /// <param name="collisionable">Spell collisionable</param>
        /// <param name="type">Spell skillshot type</param>
        /// <param name="from">Spell casted position</param>
        /// <returns></returns>
        internal static Result GetDashingPrediction(Obj_AI_Base target, float width, float delay, float missileSpeed,
            float range, bool collisionable, SkillshotType type, Vector2 from, Vector2 rangeCheckFrom)
        {
            var result = new Result
            {
                Input = new Input(target, delay, missileSpeed, width, range, collisionable, type, @from.To3D2(), rangeCheckFrom.To3D2()),
                Unit = target
            };

            if (target.LSIsDashing())
            {
                var dashInfo = target.LSGetDashInfo();
                if (dashInfo.IsBlink)
                {
                    result.HitChance = HitChance.Impossible;
                    result.CastPosition = dashInfo.EndPos;
                    return result;
                }

                result.CastPosition = GetFastUnitPosition(target, dashInfo.Path, delay, missileSpeed, from, dashInfo.Speed);
                result.HitChance = HitChance.Dashing;

                result.Lock(false);
            }
            else
            {
                result = GetPrediction(target, width, delay, missileSpeed, range, collisionable, type, target.GetWaypoints(), 0, 0, 0, 0, from, rangeCheckFrom);
                result.Lock(false);
            }
            return result;
        }

        /// <summary>
        ///     Gets Prediction result
        /// </summary>
        /// <param name="target">Target for spell</param>
        /// <param name="width">Spell width</param>
        /// <param name="delay">Spell delay</param>
        /// <param name="missileSpeed">Spell missile speed</param>
        /// <param name="range">Spell range</param>
        /// <param name="collisionable">Spell collisionable</param>
        /// <param name="type">Spell skillshot type</param>
        /// <param name="path">Waypoints of target</param>
        /// <param name="avgt">Average reaction time (in ms)</param>
        /// <param name="movt">Passed time from last movement change (in ms)</param>
        /// <param name="avgp">Average Path Lenght</param>
        /// <param name="from">Spell casted position</param>
        /// <param name="rangeCheckFrom"></param>
        /// <returns>Prediction result as <see cref="Prediction.Result" /></returns>
        internal static Result GetPrediction(Obj_AI_Base target, float width, float delay, float missileSpeed,
            float range, bool collisionable, SkillshotType type, List<Vector2> path, float avgt, float movt, float avgp,
            float anglediff, Vector2 from, Vector2 rangeCheckFrom)
        {
            AssertInitializationMode();

            var result = new Result
            {
                Input = new Input(target, delay, missileSpeed, width, range, collisionable, type, @from.To3D2(),
                    rangeCheckFrom.To3D2()),
                Unit = target
            };

            try
            {
                if (type == SkillshotType.SkillshotCircle)
                    range += width;

                //to do: hook logic ? by storing average movement direction etc
                if (path.Count <= 1 && movt > 100 && (Environment.TickCount - PathTracker.EnemyInfo[target.NetworkId].LastAATick > 300 || !ConfigMenu.CheckAAWindUp)) //if target is not moving, easy to hit (and not aaing)
                {
                    result.HitChance = HitChance.VeryHigh;
                    result.CastPosition = target.ServerPosition.LSTo2D();
                    result.UnitPosition = result.CastPosition;
                    result.Lock();

                    return result;
                }

                if (target is AIHeroClient)
                {
                    if (((AIHeroClient) target).IsChannelingImportantSpell())
                    {
                        result.HitChance = HitChance.VeryHigh;
                        result.CastPosition = target.ServerPosition.LSTo2D();
                        result.UnitPosition = result.CastPosition;
                        result.Lock();

                        return result;
                    }

                    if (Environment.TickCount - PathTracker.EnemyInfo[target.NetworkId].LastAATick < 300 && ConfigMenu.CheckAAWindUp)
                    {
                        if (target.AttackCastDelay*1000 + PathTracker.EnemyInfo[target.NetworkId].AvgOrbwalkTime + avgt - width/2f/target.MoveSpeed >= GetArrivalTime(target.ServerPosition.LSTo2D().LSDistance(from), delay, missileSpeed))
                        {
                            result.HitChance = HitChance.High;
                            result.CastPosition = target.ServerPosition.LSTo2D();
                            result.UnitPosition = result.CastPosition;
                            result.Lock();

                            return result;
                        }
                    }

                    //to do: find a fuking logic
                    if (avgp < 400 && movt < 100 && path.PathLength() <= avgp)
                    {
                        result.HitChance = HitChance.High;
                        result.CastPosition = path.Last();
                        result.UnitPosition = result.CastPosition;
                        result.Lock();

                        return result;
                    }
                }

                if (target.LSIsDashing()) //if unit is dashing
                    return GetDashingPrediction(target, width, delay, missileSpeed, range, collisionable, type, from, rangeCheckFrom);

                if (Utility.IsImmobileTarget(target)) //if unit is immobile
                    return GetImmobilePrediction(target, width, delay, missileSpeed, range, collisionable, type, from, rangeCheckFrom);

                result = WaypointAnlysis(target, width, delay, missileSpeed, range, collisionable, type, path, avgt, movt, avgp, anglediff, from);

                var d = result.CastPosition.LSDistance(target.ServerPosition.LSTo2D());
                if (d >= (avgt - movt)*target.MoveSpeed && d >= avgp)
                    result.HitChance = HitChance.Medium;

                result.Lock();

                return result;
            }
            finally
//.........这里部分代码省略.........