C# Obj_AI_Base.LSGetDashInfo方法代码示例

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

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