Ejemplo n.º 1
0
        public static float GetClosestDistanceApproach(Spell spell, Vector2 pos, float speed, float delay, Vector2 heroPos, float extraDist)
        {
            var walkDir = (pos - heroPos).Normalized();

            switch (spell.SpellType)
            {
            case SpellType.Line when spell.Info.ProjectileSpeed != float.MaxValue:
            {
                var spellPos    = spell.GetCurrentSpellPosition(true, delay);
                var spellEndPos = spell.GetSpellEndPosition();
                var extendedPos = pos.ExtendDir(walkDir, ObjectCache.MyHeroCache.BoundingRadius + speed * delay / 1000);

                var cpa2 = MathUtils.GetCollisionDistanceEx(heroPos,
                                                            walkDir * speed,
                                                            ObjectCache.MyHeroCache.BoundingRadius,
                                                            spellPos,
                                                            spell.Direction * spell.Info.ProjectileSpeed,
                                                            spell.Radius + extraDist,
                                                            out var cHeroPos,
                                                            out var cSpellPos);

                var cHeroPosProjection  = cHeroPos.ProjectOn(heroPos, extendedPos);
                var cSpellPosProjection = cSpellPos.ProjectOn(spellPos, spellEndPos);

                if (cSpellPosProjection.IsOnSegment && cHeroPosProjection.IsOnSegment && cpa2 != float.MaxValue)
                {
                    return(0);
                }

                var cpa = MathUtilsCpa.CPAPointsEx(heroPos, walkDir * speed, spellPos, spell.Direction * spell.Info.ProjectileSpeed, pos, spellEndPos, out cHeroPos, out cSpellPos);

                cHeroPosProjection  = cHeroPos.ProjectOn(heroPos, extendedPos);
                cSpellPosProjection = cSpellPos.ProjectOn(spellPos, spellEndPos);

                var checkDist = ObjectCache.MyHeroCache.BoundingRadius + spell.Radius + extraDist;

                if (cSpellPosProjection.IsOnSegment && cHeroPosProjection.IsOnSegment)
                {
                    return(Math.Max(0, cpa - checkDist));
                }

                return(checkDist);

                //return MathUtils.ClosestTimeOfApproach(heroPos, walkDir * speed, spellPos, spell.Orientation * spell.info.projectileSpeed);
            }

            case SpellType.Line when spell.Info.ProjectileSpeed == float.MaxValue:
            {
                var spellHitTime   = Math.Max(0, spell.EndTime - Environment.TickCount - delay);   //extraDelay
                var walkRange      = heroPos.Distance(pos);
                var predictedRange = speed * (spellHitTime / 1000);
                var tHeroPos       = heroPos + walkDir * Math.Min(predictedRange, walkRange); //Hero predicted pos

                var projection = tHeroPos.ProjectOn(spell.StartPos, spell.EndPos);

                return(Math.Max(0, tHeroPos.Distance(projection.SegmentPoint) - (spell.Radius + ObjectCache.MyHeroCache.BoundingRadius + extraDist)));    //+ dodgeBuffer
            }

            case SpellType.Circular:
            {
                var spellHitTime   = Math.Max(0, spell.EndTime - Environment.TickCount - delay);   //extraDelay
                var walkRange      = heroPos.Distance(pos);
                var predictedRange = speed * (spellHitTime / 1000);
                var tHeroPos       = heroPos + walkDir * Math.Min(predictedRange, walkRange); //Hero predicted pos

                switch (spell.Info.SpellName)
                {
                case "VeigarEventHorizon":
                {
                    const int wallRadius = 65;
                    var       midRadius  = spell.Radius - wallRadius;

                    if (spellHitTime == 0)
                    {
                        return(0);
                    }

                    return(tHeroPos.Distance(spell.EndPos) >= spell.Radius
                                       ? Math.Max(0, tHeroPos.Distance(spell.EndPos) - midRadius - wallRadius)
                                       : Math.Max(0, midRadius - tHeroPos.Distance(spell.EndPos) - wallRadius));
                }

                case "DariusCleave":
                {
                    const int wallRadius = 115;
                    var       midRadius  = spell.Radius - wallRadius;

                    if (spellHitTime == 0)
                    {
                        return(0);
                    }

                    return(tHeroPos.Distance(spell.EndPos) >= spell.Radius
                                       ? Math.Max(0, tHeroPos.Distance(spell.EndPos) - midRadius - wallRadius)
                                       : Math.Max(0, midRadius - tHeroPos.Distance(spell.EndPos) - wallRadius));
                }
                }

                var closestDist = Math.Max(0, tHeroPos.Distance(spell.EndPos) - (spell.Radius + extraDist));
                if (spell.Info.ExtraEndTime > 0 && closestDist != 0)
                {
                    var remainingTime   = Math.Max(0, spell.EndTime + spell.Info.ExtraEndTime - Environment.TickCount - delay);
                    var predictedRange2 = speed * (remainingTime / 1000);
                    var tHeroPos2       = heroPos + walkDir * Math.Min(predictedRange2, walkRange);

                    if (CheckMoveToDirection(tHeroPos, tHeroPos2))
                    {
                        return(0);
                    }
                }
                else
                {
                    return(closestDist);
                }
                break;
            }

            case SpellType.Arc:
            {
                var spellPos    = spell.GetCurrentSpellPosition(true, delay);
                var spellEndPos = spell.GetSpellEndPosition();

                var pDir = spell.Direction.Perpendicular();
                spellPos    = spellPos - pDir * spell.Radius / 2;
                spellEndPos = spellEndPos - pDir * spell.Radius / 2;

                var extendedPos = pos.ExtendDir(walkDir, ObjectCache.MyHeroCache.BoundingRadius);

                var cpa = MathUtilsCpa.CPAPointsEx(heroPos, walkDir * speed, spellPos, spell.Direction * spell.Info.ProjectileSpeed, pos, spellEndPos, out var cHeroPos, out var cSpellPos);

                var cHeroPosProjection  = cHeroPos.ProjectOn(heroPos, extendedPos);
                var cSpellPosProjection = cSpellPos.ProjectOn(spellPos, spellEndPos);

                var checkDist = spell.Radius + extraDist;

                if (cHeroPos.InSkillShot(spell, ObjectCache.MyHeroCache.BoundingRadius))
                {
                    if (cSpellPosProjection.IsOnSegment && cHeroPosProjection.IsOnSegment)
                    {
                        return(Math.Max(0, cpa - checkDist));
                    }
                    return(checkDist);
                }
                break;
            }

            case SpellType.Cone:
            {
                var spellHitTime   = Math.Max(0, spell.EndTime - Environment.TickCount - delay);   //extraDelay
                var walkRange      = heroPos.Distance(pos);
                var predictedRange = speed * (spellHitTime / 1000);
                var tHeroPos       = heroPos + walkDir * Math.Min(predictedRange, walkRange); //Hero predicted pos

                var sides = new[]
                {
                    heroPos.ProjectOn(spell.CnStart, spell.CnLeft).SegmentPoint,
                    heroPos.ProjectOn(spell.CnLeft, spell.CnRight).SegmentPoint,
                    heroPos.ProjectOn(spell.CnRight, spell.CnStart).SegmentPoint
                };

                var p = sides.OrderBy(x => x.Distance(x)).First();

                return(Math.Max(0, tHeroPos.Distance(p) - (spell.Radius + ObjectCache.MyHeroCache.BoundingRadius + extraDist)));
            }
            }

            return(1);
        }
Ejemplo n.º 2
0
        private void Render_OnPresent()
        {
            foreach (var entry in SpellDetector.DrawSpells)
            {
                var spell = entry.Value;

                if (spell.SpellType != SpellType.Line)
                {
                    continue;
                }

                var spellPos = spell.CurrentSpellPosition;

                Render.Circle(new Vector3(spellPos.X, spellPos.Y, MyHero.Position.Z), spell.Info.Radius, 50, Color.White);
            }

            if (TestMenu["(TestHeroPos)"].Enabled)
            {
                var path = MyHero.Path;
                if (path.Length > 0)
                {
                    var heroPos2 = EvadeHelper.GetRealHeroPos(ObjectCache.GamePing + 50);
                    var heroPos1 = ObjectCache.MyHeroCache.ServerPos2D;

                    Render.Circle(new Vector3(heroPos2.X, heroPos2.Y, MyHero.ServerPosition.Z), ObjectCache.MyHeroCache.BoundingRadius, 50, Color.Red);
                    Render.Circle(new Vector3(MyHero.ServerPosition.X, MyHero.ServerPosition.Y, MyHero.ServerPosition.Z), ObjectCache.MyHeroCache.BoundingRadius, 50, Color.White);

                    Render.WorldToScreen(ObjectManager.GetLocalPlayer().Position, out var heroPos);

                    Render.Text($" {(int) heroPos2.Distance(heroPos1)}", new Vector2(heroPos.X - 10, heroPos.Y), RenderTextFlags.Center, Color.Red);

                    Render.Circle(new Vector3(_circleRenderPos.X, _circleRenderPos.Y, MyHero.ServerPosition.Z), 10, 50, Color.Red);
                }
            }

            if (TestMenu["(DrawHeroPos)"].Enabled)
            {
                Render.Circle(new Vector3(MyHero.ServerPosition.X, MyHero.ServerPosition.Y, MyHero.ServerPosition.Z), ObjectCache.MyHeroCache.BoundingRadius, 50, Color.White);
            }

            if (TestMenu["(TestMoveTo)"].As <MenuKeyBind>().Enabled)
            {
                TestMenu["(TestMoveTo)"].As <MenuKeyBind>().Value = false;

                MyHero.IssueOrder(OrderType.MoveTo, Game.CursorPos);

                var dir = (Game.CursorPos - MyHero.Position).Normalized();

                var pos2 = Game.CursorPos.To2D() - dir.To2D() * 75;

                DelayAction.Add(20, () => MyHero.IssueOrder(OrderType.MoveTo, pos2.To3D()));
            }

            if (TestMenu["(TestPath)"].Enabled)
            {
                var tPath = MyHero.GetPath(Game.CursorPos);

                foreach (var point in tPath)
                {
                    var point2D = point.To2D();
                    Render.Circle(new Vector3(point.X, point.Y, point.Z), ObjectCache.MyHeroCache.BoundingRadius, 50, Color.Violet);
                }
            }

            if (TestMenu["(TestPath)"].Enabled)
            {
                foreach (var entry in SpellDetector.Spells)
                {
                    var spell = entry.Value;

                    var to  = Game.CursorPos.To2D();
                    var dir = (to - MyHero.Position.To2D()).Normalized();

                    var cpa = MathUtilsCpa.CPAPointsEx(MyHero.Position.To2D(), dir * ObjectCache.MyHeroCache.MoveSpeed, spell.EndPos, spell.Direction * spell.Info.ProjectileSpeed, to, spell.EndPos);

                    if (cpa < ObjectCache.MyHeroCache.BoundingRadius + spell.Radius)
                    {
                    }
                }
            }

            if (TestMenu["(ShowBuffs)"].Enabled)
            {
                var target = MyHero;

                foreach (var hero in GameObjects.EnemyHeroes)
                {
                    target = hero;
                }

                var buffs = target.Buffs;

                if (!target.IsTargetable)
                {
                    ConsolePrinter.Print("invul" + Environment.TickCount);
                }

                var height = 20;

                foreach (var buff in buffs)
                {
                    if (!buff.IsValid)
                    {
                        continue;
                    }

                    Render.Text(buff.Name, new Vector2(10, height), RenderTextFlags.Center, Color.White);
                    height += 20;

                    ConsolePrinter.Print(buff.Name);
                }
            }

            if (TestMenu["(TestTracker)"].Enabled)
            {
                foreach (var entry in ObjectTracker.ObjTracker)
                {
                    var info = entry.Value;

                    var endPos2 = !info.UsePosition ? info.Obj.Position : info.Position;

                    Render.Circle(new Vector3(endPos2.X, endPos2.Y, MyHero.Position.Z), 50, 50, Color.Green);
                }
            }

            if (!TestMenu["(TestWall)"].Enabled)
            {
                return;
            }

            var       posChecked    = 0;
            const int maxPosToCheck = 50;
            const int posRadius     = 50;
            var       radiusIndex   = 0;

            var heroPoint = ObjectCache.MyHeroCache.ServerPos2D;

            while (posChecked < maxPosToCheck)
            {
                radiusIndex++;

                var curRadius       = radiusIndex * 2 * posRadius;
                var curCircleChecks = (int)Math.Ceiling(2 * Math.PI * curRadius / (2 * (double)posRadius));

                for (var i = 1; i < curCircleChecks; i++)
                {
                    posChecked++;
                    var cRadians = 2 * Math.PI / (curCircleChecks - 1) * i; //check decimals
                    var pos      = new Vector2((float)Math.Floor(heroPoint.X + curRadius * Math.Cos(cRadians)), (float)Math.Floor(heroPoint.Y + curRadius * Math.Sin(cRadians)));

                    if (!EvadeHelper.CheckPathCollision(MyHero, pos))
                    {
                        Render.Circle(new Vector3(pos.X, pos.Y, MyHero.Position.Z), 25, 50, Color.White);
                    }
                }
            }
        }
Ejemplo n.º 3
0
        public static bool CheckMoveToDirection(Vector2 from, Vector2 movePos, float extraDelay = 0)
        {
            var dir = (movePos - from).Normalized();

            foreach (var entry in SpellDetector.Spells)
            {
                var spell = entry.Value;

                if (!from.InSkillShot(spell, ObjectCache.MyHeroCache.BoundingRadius))
                {
                    var spellPos = spell.CurrentSpellPosition;

                    switch (spell.SpellType)
                    {
                    case SpellType.Line:
                        if (spell.LineIntersectLinearSpell(@from, movePos))
                        {
                            return(true);
                        }
                        break;

                    case SpellType.Circular:
                        switch (spell.Info.SpellName)
                        {
                        case "VeigarEventHorizon":
                        {
                            var cpa2 = MathUtilsCpa.CPAPointsEx(@from, dir * ObjectCache.MyHeroCache.MoveSpeed, spell.EndPos, new Vector2(0, 0), movePos, spell.EndPos);

                            if (@from.Distance(spell.EndPos) < spell.Radius && !(@from.Distance(spell.EndPos) < spell.Radius - 135 && movePos.Distance(spell.EndPos) < spell.Radius - 135))
                            {
                                return(true);
                            }
                            if (@from.Distance(spell.EndPos) > spell.Radius && cpa2 < spell.Radius + 10)
                            {
                                return(true);
                            }
                            break;
                        }

                        case "DariusCleave":
                            var cpa3 = MathUtilsCpa.CPAPointsEx(@from, dir * ObjectCache.MyHeroCache.MoveSpeed, spell.EndPos, new Vector2(0, 0), movePos, spell.EndPos);

                            if (@from.Distance(spell.EndPos) < spell.Radius && !(@from.Distance(spell.EndPos) < spell.Radius - 230 && movePos.Distance(spell.EndPos) < spell.Radius - 230))
                            {
                                return(true);
                            }
                            if (@from.Distance(spell.EndPos) > spell.Radius && cpa3 < spell.Radius + 10)
                            {
                                return(true);
                            }
                            break;

                        default:
                        {
                            var cpa2 = MathUtils.GetCollisionDistanceEx(@from, dir * ObjectCache.MyHeroCache.MoveSpeed, 1, spell.EndPos, new Vector2(0, 0), spell.Radius, out var cHeroPos, out _);

                            if (spell.Info.SpellName.Contains("_trap") && !(cpa2 < spell.Radius + 10))
                            {
                                continue;
                            }

                            var cHeroPosProjection = cHeroPos.ProjectOn(@from, movePos);
                            if (cHeroPosProjection.IsOnSegment && cpa2 != float.MaxValue)
                            {
                                return(true);
                            }
                            break;
                        }
                        }
                        break;

                    case SpellType.Arc:
                        if (@from.IsLeftOfLineSegment(spell.StartPos, spell.EndPos))
                        {
                            return(MathUtils.CheckLineIntersection(@from, movePos, spell.StartPos, spell.EndPos));
                        }

                        var spellRange = spell.StartPos.Distance(spell.EndPos);
                        var midPoint   = spell.StartPos + spell.Direction * (spellRange / 2);

                        var cpa = MathUtilsCpa.CPAPointsEx(@from, dir * ObjectCache.MyHeroCache.MoveSpeed, midPoint, new Vector2(0, 0), movePos, midPoint);

                        if (cpa < spell.Radius + 10)
                        {
                            return(true);
                        }
                        break;

                    case SpellType.Cone:
                        if (LineIntersectLinearSegment(spell.CnStart, spell.CnLeft, @from, movePos) || LineIntersectLinearSegment(spell.CnLeft, spell.CnRight, @from, movePos) ||
                            LineIntersectLinearSegment(spell.CnRight, spell.CnStart, @from, movePos))
                        {
                            return(true);
                        }
                        break;
                    }
                }
                else if (from.InSkillShot(spell, ObjectCache.MyHeroCache.BoundingRadius))
                {
                    if (movePos.InSkillShot(spell, ObjectCache.MyHeroCache.BoundingRadius))
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }