Exemple #1
0
        public static void OnKeyPressed()
        {
            var target = Global.TargetSelector.GetSelectedTarget();

            if (target == null || !SpellManager.E.Ready)
            {
                return;
            }

            if (target.IsValidTarget(SpellManager.E.Range))
            {
                SpellManager.CastE(target);
            }

            var point = WallExtension.NearestWall(target, 430);

            if (point.IsZero)
            {
                return;
            }

            var pos = target.ServerPosition + (target.ServerPosition - point).Normalized() * 200;

            SpellManager.DrawingPred = pos;

            if (pos.Distance(Global.Player) <= SummonerSpells.Flash.Range && SummonerSpells.IsValid(SummonerSpells.Flash))
            {
                SpellManager.E.CastOnUnit(target);
                DelayAction.Queue(100, () => SummonerSpells.Flash.Cast(pos), new CancellationToken(false));
            }
        }
Exemple #2
0
        public static bool CanStun(Obj_AI_Base target)
        {
            var rectAfterDelay = RectAfterDelay(target);
            var rect           = Rect(target.ServerPosition);

            return(WallExtension.IsWall(rectAfterDelay.Start.To3D(), rectAfterDelay.End.To3D()) && WallExtension.IsWall(rect.Start.To3D(), rect.End.To3D()));
        }
Exemple #3
0
        public static void CastQ(Obj_AI_Base target, int modeIndex = 0, bool force = true)
        {
            var wallPos = WallExtension.NearestWall(Global.Player, 130);

            if (!wallPos.IsZero)
            {
                Q.Cast(wallPos);
                return;
            }

            var point = WallExtension.NearestWall(target, 475);

            if (force && E.Ready && !point.IsZero)
            {
                point = target.ServerPosition + (target.ServerPosition - point).Normalized() * 100;

                if (point.Distance(Global.Player) <= Q.Range)
                {
                    Q.Cast(point);
                }
            }

            switch (modeIndex)
            {
            case 0:
                Q.Cast(Game.CursorPos);
                break;

            case 1:
                Q.Cast(DashManager.DashKite(target, Q.Range));
                break;
            }
        }
Exemple #4
0
        protected override void OnLoad(object sender, FeatureBaseEventArgs eventArgs)
        {
            base.OnLoad(sender, eventArgs);

            dashPos = new DashPosition();

            wall = new WallExtension();
        }
Exemple #5
0
        protected override void OnLoad(object sender, FeatureBaseEventArgs eventArgs)
        {
            base.OnLoad(sender, eventArgs);

            wall = new WallExtension();

            Menu.AddItem(new MenuItem("Ziggs.Flee.Wall", "Walljump").SetValue(true));

            Menu.AddItem(new MenuItem("Ziggs.Flee.Keybind", "Keybind: ").SetValue(new KeyBind('A', KeyBindType.Press)));
        }
Exemple #6
0
        protected override void OnLoad(object sender, FeatureBaseEventArgs eventArgs)
        {
            base.OnLoad(sender, eventArgs);

            dashPos = new DashPosition();
            wall    = new WallExtension();

            Menu.AddItem(new MenuItem("Enemies", "Don't E Into X Enemies").SetValue(new Slider(3, 1, 5)));

            Menu.AddItem(new MenuItem("Turret", "Turret Check").SetValue(true));
        }
Exemple #7
0
        private static void GenereateWallForQ()
        {
            var target = Global.TargetSelector.GetTarget(Q.Range);

            if (target == null)
            {
                WallForQ = Vector3.Zero;
                return;
            }

            WallForQ = WallExtension.NearestWall(target, Q.Range);
        }
Exemple #8
0
        protected override void onAwake()
        {
            base.onAwake();

            BoxCollider[] boxes = this.GetComponents <BoxCollider>();
            this.xCollider = boxes[0];
            this.zCollider = boxes[1];

            this.posXExtension = new WallExtension(this, "posXExtension", Vector3.right);
            this.posZExtension = new WallExtension(this, "posZExtension", Vector3.forward);
            this.negXExtension = new WallExtension(this, "negXExtension", Vector3.left);
            this.negZExtension = new WallExtension(this, "negZExtension", Vector3.back);
        }
Exemple #9
0
        protected override void OnLoad(object sender, FeatureBaseEventArgs eventArgs)
        {
            base.OnLoad(sender, eventArgs);

            dashPos = new DashPosition();

            wall = new WallExtension();

            Menu.AddItem(new MenuItem("Flee.Keybind", "Keybind: ").SetValue(new KeyBind('A', KeyBindType.Press)));

            //Menu.AddItem(new MenuItem("Flee.Enemies", "Don't Flee Into X Enemies").SetValue(new Slider(2, 0, 5)));

            Menu.AddItem(new MenuItem("Flee.Turret", "Turret Check").SetValue(true));
        }
Exemple #10
0
        private void GetToSafety(GameObject allyTurret, bool runToGrass = true)
        {
            if (allyTurret == null)
            {
                Console.WriteLine("CANT GET OUT, ALLY TURRET IS NULL");
                return;
            }

            BotData.SetDanger();

            if (runToGrass)
            {
                var nearestGrass = WallExtension.NearestGrass(Global.Player, 800);

                if (!nearestGrass.IsZero)
                {
                    lastGrassVector    = nearestGrass;
                    lastFoundGrassTick = Environment.TickCount;
                }

                if (!lastGrassVector.IsZero &&
                    Global.Player.Distance(lastGrassVector) < Global.Player.Distance(allyTurret.ServerPosition))
                {
                    DebugConsole.WriteLine($"Running to: GRASS (SAFETY)", MessageState.Debug);
                    BotData.SetNewMovePosition(Global.Player.ServerPosition.Extend(lastGrassVector, 600), false);
                    return;
                }
                return;
            }

            var allyHero2 = GameObjects.AllyHeroes.FirstOrDefault(x => !x.IsMe && x.IsValidTarget(1800, true) && !x.UnderEnemyTURRET());

            if (allyTurret.Distance(Global.Player) <= 3500 || allyHero2 == null)
            {
                DebugConsole.WriteLine($"Running to: ALLY TURRET (SAFETY)", MessageState.Debug);
                var pos = allyTurret.ServerPosition.Extend(Global.Player.GetFountainPos(), 800);
                BotData.SetNewMovePosition(pos);
            }

            if (allyHero2 != null)
            {
                DebugConsole.WriteLine($"Running to: ALLY HERO (SAFETY)", MessageState.Debug);
                var pos = Global.Player.ServerPosition.Extend(allyHero2.ServerPosition, 800);
                BotData.SetNewMovePosition(pos, true, 700);
            }
        }
Exemple #11
0
        public static void OnKeyPressed()
        {
            if (Extension.CurrentMode == Mode.Dashing && SpellConfig.Q.Ready)
            {
                SpellConfig.Q.Cast();
            }

            if (!SpellConfig.E.Ready)
            {
                return;
            }

            var mob = GameObjects.Jungle.OrderBy(x => x.Distance(Game.CursorPos)).
                      FirstOrDefault(x => x.Distance(Global.Player) <= SpellConfig.E.Range + 200 && !x.HasBuff("YasuoDashWrapper"));

            if (mob != null)
            {
                var pos = mob.ServerPosition + (mob.ServerPosition - Global.Player.ServerPosition).Normalized() * mob.BoundingRadius;

                var point = WallExtension.GeneratePoint(mob.ServerPosition, Global.Player.ServerPosition.Extend(mob.ServerPosition, 475 + mob.BoundingRadius));

                if (Global.Orbwalker.CanMove())
                {
                    Global.Orbwalker.Move(pos);
                }

                if (NavMesh.WorldToCell(point).Flags == NavCellFlags.Wall)
                {
                    return;
                }

                if (pos.Distance(Global.Player) <= mob.BoundingRadius + Global.Player.BoundingRadius + 43)
                {
                    SpellConfig.E.CastOnUnit(mob);
                }
            }
            else
            {
                var minion = GameObjects.EnemyMinions.Where(MinionHelper.IsDashable).OrderBy(x => x.Distance(Game.CursorPos)).FirstOrDefault();

                if (minion != null)
                {
                    SpellConfig.E.CastOnUnit(minion);
                }
            }
        }
Exemple #12
0
        public static void CastR(Obj_AI_Base target, int count = 1)
        {
            var wall = WallExtension.NearestWall(target, 590);

            if (wall.IsZero || count != 1 && wall.CountEnemyHeroesInRange(590) < count)
            {
                return;
            }

            var flashPos = wall + (wall - Global.Player.ServerPosition).Normalized() * SummonerSpells.Flash.Range;

            if (SummonerSpells.IsValid(SummonerSpells.Flash) && MenuConfig.Combo["Flash"].Enabled && target.Distance(Global.Player) > 475 && wall.Distance(Global.Player) < 475 + 425)
            {
                SummonerSpells.Flash.Cast(flashPos);
            }

            if (wall.Distance(Global.Player) <= 590)
            {
                R.Cast(wall);
            }
        }
Exemple #13
0
        public static void RenderBasics()
        {
            if (Global.Player.IsDead)
            {
                return;
            }

            if (MenuConfig.FleeMode.Active)
            {
                var spot = WallExtension.GetBestWallHopPos(Global.Player.ServerPosition, 275);

                if (!spot.IsZero)
                {
                    Render.WorldToScreen(spot.Extend(Global.Player.ServerPosition, 65), out var startPointVector2);
                    Render.WorldToScreen(spot, out var endPointVector2);
                    Render.Line(startPointVector2, endPointVector2, Color.Orange);
                    Render.Circle(spot, 50, (uint)MenuConfig.Drawings["Segments"].Value, Color.White);
                }
            }

            if (MenuConfig.Drawings["Mouse"].Enabled && Global.Orbwalker.Mode != OrbwalkingMode.None)
            {
                if (!SpellConfig.Q.Ready && Extensions.CurrentQCount == 1)
                {
                    return;
                }

                var temp = Global.Orbwalker.GetOrbwalkingTarget();
                if (temp != null && temp.IsHero && temp.Distance(Global.Player) > Global.Player.AttackRange - 100)
                {
                    var pos = Global.Player.ServerPosition.Extend(temp.ServerPosition, 450);
                    Render.Circle(pos, 200, (uint)MenuConfig.Drawings["Segments"].Value, Color.Yellow);
                    Render.WorldToScreen(pos, out var posV2);
                    Render.Text("Put Mouse Here", new Vector2(posV2.X - 50, posV2.Y), RenderTextFlags.Center, Color.White);
                }
            }

            if (MenuConfig.Drawings["Pattern"].Enabled)
            {
                Render.WorldToScreen(Global.Player.Position, out var playerV2);

                if (MenuConfig.BurstMode.Active)
                {
                    RenderHelper.RenderArrowFromPlayer(Global.TargetSelector.GetSelectedTarget());
                    Render.Text("PATTERN: " + Enums.BurstPattern, new Vector2(playerV2.X - 65, playerV2.Y + 30), RenderTextFlags.Center, Color.Aqua);
                }

                switch (Global.Orbwalker.Mode)
                {
                case OrbwalkingMode.Mixed:
                    RenderHelper.RenderArrowFromPlayer(Global.TargetSelector.GetTarget(Extensions.EngageRange + 800));
                    Render.Text("PATTERN: " + Enums.Current, new Vector2(playerV2.X - 65, playerV2.Y + 30), RenderTextFlags.Center, Color.Aqua);
                    break;
                }
            }

            if (MenuConfig.Drawings["Engage"].Enabled)
            {
                if (Extensions.AllIn || MenuConfig.BurstMode.Active)
                {
                    Render.Circle(Global.Player.Position, Extensions.FlashRange(), (uint)MenuConfig.Drawings["Segments"].Value, Color.Yellow);
                }
                else
                {
                    Render.Circle(Global.Player.Position, Extensions.EngageRange, (uint)MenuConfig.Drawings["Segments"].Value, Color.White);
                }
            }

            if (MenuConfig.Drawings["R2"].Enabled && SpellConfig.R2.Ready && Enums.UltimateMode == UltimateMode.Second)
            {
                Render.Circle(Global.Player.Position, SpellConfig.R2.Range, (uint)MenuConfig.Drawings["Segments"].Value, Color.OrangeRed);
            }
        }
Exemple #14
0
        public static void OnKeyPressed()
        {
            if (MenuConfig.Miscellaneous["Walljump"].Enabled && Global.Player.CountEnemyHeroesInRange(2000) == 0)
            {
                if (MenuConfig.Miscellaneous["Force"].Enabled && Extensions.CurrentQCount != 3)
                {
                    switch (Extensions.CurrentQCount)
                    {
                    case 3:
                        DelayAction.Queue(250, () => Global.Player.SpellBook.CastSpell(SpellSlot.Q, Game.CursorPos), new CancellationToken(false));
                        break;

                    default:
                        Global.Player.SpellBook.CastSpell(SpellSlot.Q, Game.CursorPos);
                        break;
                    }
                }

                if (Extensions.CurrentQCount != 3)
                {
                    return;
                }

                const int dashRange = 275;
                var       wall      = WallExtension.GetBestWallHopPos(Global.Player.Position, dashRange);

                if (wall.IsZero ||
                    wall.Distance(Global.Player) > SpellConfig.E.Range + 65)
                {
                    return;
                }

                wall = wall.Extend(Global.Player.ServerPosition, 65);

                var distance = wall.Distance(Global.Player.Position);
                Global.Orbwalker.Move(wall);

                if (SpellConfig.E.Ready)
                {
                    Global.Player.SpellBook.CastSpell(SpellSlot.E, Global.Player.ServerPosition.Extend(wall, 400));
                    DelayAction.Queue(190, () => Global.Player.SpellBook.CastSpell(SpellSlot.Q, wall), new CancellationToken(false));
                }


                if (distance > 40)
                {
                    return;
                }

                Global.Player.SpellBook.CastSpell(SpellSlot.Q, wall);
            }
            else
            {
                if (SpellConfig.W.Ready)
                {
                    foreach (var enemy in GameObjects.EnemyHeroes.Where(x => x.IsValidTarget(SpellConfig.W.Range)))
                    {
                        SpellManager.CastW(enemy);
                    }
                }

                if (SpellConfig.Q.Ready)
                {
                    SpellConfig.Q.Cast(Game.CursorPos);
                }
                else if (SpellConfig.E.Ready)
                {
                    if (SpellConfig.Q.Ready && Extensions.CurrentQCount != 3)
                    {
                        return;
                    }
                    SpellConfig.E.Cast(Game.CursorPos);
                }
            }
        }