Example #1
0
        //private static void OnGapcloser(AIHeroClient target, GapcloserArgs Args)
        //{
        //    if (target != null && target.IsValidTarget(E.Range))
        //    {
        //        switch (Args.Type)
        //        {
        //            case SpellType.Melee:
        //                {
        //                    if (target.IsValidTarget(target.AttackRange + target.BoundingRadius + 100) &&
        //                        MiscOption.GetBool("Q", "QMelee").Enabled && Q.IsReady())
        //                    {
        //                        Q.Cast(Me.PreviousPosition.Extend(target.PreviousPosition, -Q.Range));
        //                    }
        //                }
        //                break;
        //            case SpellType.SkillShot:
        //                {
        //                    if (MiscOption.GetBool("E", "AntiGapcloserE").Enabled && E.IsReady() && target.IsValidTarget(250) && !Args.HaveShield)
        //                    {
        //                        E.CastOnUnit(target);
        //                    }
        //                }
        //                break;
        //            case SpellType.Dash:
        //            case SpellType.Targeted:
        //                {
        //                    if (MiscOption.GetBool("E", "AntiGapcloserE").Enabled && E.IsReady() && target.IsValidTarget(E.Range) && !Args.HaveShield)
        //                    {
        //                        E.CastOnUnit(target);
        //                    }
        //                }
        //                break;
        //        }
        //    }
        //}

        private static Vector3 GetDashQPos()
        {
            var firstQPos = Me.PreviousPosition.Extend(Game.CursorPosRaw, Q.Range);
            var allPoint  = MyExtraManager.GetCirclePoints(Q.Range).ToList();

            foreach (var point in allPoint)
            {
                var mousecount = firstQPos.CountEnemyHeroesInRange(300);
                var count      = point.CountEnemyHeroesInRange(300);

                if (!HaveEnemiesInRange(point))
                {
                    continue;
                }

                if (mousecount == count)
                {
                    if (point.DistanceToCursor() < firstQPos.DistanceToCursor())
                    {
                        firstQPos = point;
                    }
                }

                if (count < mousecount)
                {
                    firstQPos = point;
                }
            }

            if (MiscOption.GetList("Q", "QTurret").Index == 0 || MiscOption.GetList("Q", "QTurret").Index == 2)
            {
                if (firstQPos.IsUnderEnemyTurret())
                {
                    return(Vector3.Zero);
                }
            }

            if (MiscOption.GetBool("Q", "QCheck").Enabled)
            {
                if (Me.CountEnemyHeroesInRange(Q.Range + Me.BoundingRadius - 30) <
                    firstQPos.CountEnemyHeroesInRange(Q.Range * 2 - Me.BoundingRadius))
                {
                    return(Vector3.Zero);
                }

                if (firstQPos.CountEnemyHeroesInRange(Q.Range * 2 - Me.BoundingRadius) > 3)
                {
                    return(Vector3.Zero);
                }
            }

            return(HaveEnemiesInRange(firstQPos) ? firstQPos : Vector3.Zero);
        }
Example #2
0
        private static void OnUpdate(EventArgs args)
        {
            if (Me.IsDead || Me.IsRecalling())
            {
                return;
            }

            if (Variables.GameTimeTickCount - LastForcusTime > Me.AttackCastDelay * 1000f)
            {
                if (Orbwalker.ActiveMode != OrbwalkerMode.None)
                {
                    Orbwalker.ForceTarget = null;
                }
            }

            if (R.Level > 0 && R.IsReady())
            {
                RLogic();
            }

            if (Me.IsWindingUp)
            {
                return;
            }

            KillSteal();

            HideSettings(MiscOption.GetList("Stealth", "HideSelect").Index);

            switch (Orbwalker.ActiveMode)
            {
            case OrbwalkerMode.Combo:
                Combo();
                break;

            case OrbwalkerMode.Harass:
                Harass();
                break;

            case OrbwalkerMode.LaneClear:
                Farm();
                break;
            }
        }
Example #3
0
        private static void CastQCannonMouse()
        {
            Me.IssueOrder(OrderType.MoveTo, Game.CursorPos);

            if (isMelee && !R.Ready)
            {
                return;
            }

            if (isMelee && R.Ready)
            {
                R.Cast();
                return;
            }

            if (eCd == 0 && qCd == 0 && !isMelee)
            {
                if (MiscOption.GetList("QE", "SemiQEMode").Value == 1)
                {
                    var gateDis    = MiscOption.GetSlider("E", "gatePlace").Value;
                    var gateVector = Me.ServerPosition + Vector3.Normalize(Game.CursorPos - Me.ServerPosition) * gateDis;

                    if (E.Ready && QE.Ready)
                    {
                        E.Cast(gateVector);
                        QE.Cast(Game.CursorPos);
                    }
                }
                else
                {
                    var qTarget = MyTargetSelector.GetTarget(QE.Range);

                    if (qTarget != null && qTarget.IsValidTarget(QE.Range) && qCd == 0)
                    {
                        CastQCannon(qTarget, true);
                    }
                }
            }
        }
Example #4
0
        private static void OnUpdate()
        {
            if (Me.IsDead || Me.IsRecalling())
            {
                return;
            }

            if (Game.TickCount - LastForcusTime > Orbwalker.WindUpTime)
            {
                if (Orbwalker.Mode != OrbwalkingMode.None)
                {
                    Orbwalker.ForceTarget(null);
                }
            }

            if (R.GetBasicSpell().Level > 0 && R.Ready)
            {
                RLogic();
            }

            KillSteal();

            HideSettings(MiscOption.GetList("Stealth", "HideSelect").Value);

            if (Orbwalker.Mode == OrbwalkingMode.Combo)
            {
                Combo();
            }

            if (Orbwalker.Mode == OrbwalkingMode.Mixed)
            {
                Harass();
            }

            if (Orbwalker.Mode == OrbwalkingMode.Laneclear)
            {
                Farm();
            }
        }
Example #5
0
        private static void Combo()
        {
            var target = MiscOption.GetList("PlayMode") == 0
                ? TargetSelector.GetTarget(EQ.Range, TargetSelector.DamageType.Physical)
                : TargetSelector.GetTarget(EQ.Range);

            if (target.IsValidTarget(EQ.Range))
            {
                if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                {
                    SpellManager.PredCast(Q, target);
                }

                if (ComboOption.UseW && W.IsReady() && target.IsValidTarget(W.Range))
                {
                    SpellManager.PredCast(W, target, true);
                }

                if (ComboOption.UseE && E.IsReady() && target.IsValidTarget(EQ.Range))
                {
                    if (ComboOption.GetBool("ComboECheck") && !Me.UnderTurret(true) &&
                        Me.CountEnemiesInRange(1200) <= 2)
                    {
                        var useECombo = false;

                        if (target.DistanceToPlayer() > Orbwalker.GetRealAutoAttackRange(Me) &&
                            target.IsValidTarget())
                        {
                            if (target.Health < E.GetDamage(target) + Me.GetAutoAttackDamage(target) &&
                                target.Distance(Game.CursorPosition) < Me.Distance(Game.CursorPosition))
                            {
                                useECombo = true;
                            }

                            if (target.Health < E.GetDamage(target) + W.GetDamage(target) && W.IsReady() &&
                                target.Distance(Game.CursorPosition) + 350 < Me.Distance(Game.CursorPosition))
                            {
                                useECombo = true;
                            }

                            if (target.Health < E.GetDamage(target) + Q.GetDamage(target) && Q.IsReady() &&
                                target.Distance(Game.CursorPosition) + 300 < Me.Distance(Game.CursorPosition))
                            {
                                useECombo = true;
                            }
                        }

                        if (useECombo)
                        {
                            var CastEPos = Me.Position.Extend(target.Position, 475f);

                            if (ComboOption.GetBool("ComboEWall"))
                            {
                                if (NavMesh.GetCollisionFlags(CastEPos) != CollisionFlags.Wall &&
                                    NavMesh.GetCollisionFlags(CastEPos) != CollisionFlags.Building &&
                                    NavMesh.GetCollisionFlags(CastEPos) != CollisionFlags.Prop)
                                {
                                    E.Cast(CastEPos);
                                    useECombo = false;
                                }
                            }
                            else
                            {
                                E.Cast(CastEPos);
                                useECombo = false;
                            }
                        }
                    }
                }

                if (ComboOption.UseR && R.IsReady())
                {
                    if (Me.UnderTurret(true) || Me.CountEnemiesInRange(800) > 1)
                    {
                        return;
                    }

                    foreach (var rTarget in ObjectManager.Heroes.Enemies.Where(
                                 x =>
                                 x.IsValidTarget(R.Range) &&
                                 target.DistanceToPlayer() > Orbwalker.GetRealAutoAttackRange(Me)))
                    {
                        if (target.Health < R.GetDamage(rTarget) && R.GetPrediction(rTarget).Hitchance >= HitChance.VeryHigh &&
                            target.DistanceToPlayer() > Q.Range + E.Range / 2)
                        {
                            R.Cast(rTarget, true);
                        }

                        if (rTarget.IsValidTarget(Q.Range + E.Range) &&
                            R.GetDamage(rTarget) + (Q.IsReady() ? Q.GetDamage(rTarget) : 0) +
                            (W.IsReady() ? W.GetDamage(rTarget) : 0) > rTarget.Health + rTarget.HPRegenRate * 2)
                        {
                            R.Cast(rTarget, true);
                        }
                    }
                }
            }
        }
Example #6
0
        private static void AfterQLogic(AIBaseClient target)
        {
            if (!Q.IsReady() || target == null || !target.IsValidTarget())
            {
                return;
            }

            var qPosition  = Me.Position.Extend(Game.CursorPosRaw, Q.Range);
            var targetDisQ = target.Position.Distance(qPosition);

            if (MiscOption.GetList("Q", "QTurret").Index == 1 || MiscOption.GetList("Q", "QTurret").Index == 2)
            {
                if (qPosition.IsUnderEnemyTurret())
                {
                    return;
                }
            }

            if (MiscOption.GetBool("Q", "QCheck").Enabled)
            {
                if (GameObjects.EnemyHeroes.Count(x => x.IsValidTarget(300f, true, qPosition)) >= 3)
                {
                    return;
                }

                //Catilyn W
                if (ObjectManager
                    .Get <GameObject>()
                    .FirstOrDefault(
                        x =>
                        x != null && x.IsValid &&
                        x.Name.ToLower().Contains("yordletrap_idle_red.troy") &&
                        x.Position.Distance(qPosition) <= 100) != null)
                {
                    return;
                }

                //Jinx E
                if (ObjectManager.Get <AIMinionClient>()
                    .FirstOrDefault(x => x.IsValid && x.IsEnemy && x.Name == "k" &&
                                    x.Position.Distance(qPosition) <= 100) != null)
                {
                    return;
                }

                //Teemo R
                if (ObjectManager.Get <AIMinionClient>()
                    .FirstOrDefault(x => x.IsValid && x.IsEnemy && x.Name == "Noxious Trap" &&
                                    x.Position.Distance(qPosition) <= 100) != null)
                {
                    return;
                }
            }

            if (targetDisQ <= Me.AttackRange + Me.BoundingRadius)
            {
                if (Me.CanMoveMent())
                {
                    Q.Cast(Game.CursorPosRaw);
                }
            }
        }
Example #7
0
        private static void AutoCatchLogic()
        {
            if ((MiscOption.GetList("CatchMode") == 2) || (MiscOption.GetList("CatchMode") == 1 && !isComboMode))
            {
                myOrbwalker.SetOrbwalkingPoint(Game.CursorPosition);
                return;
            }

            var catchRange = MiscOption.GetSlider("CatchRange");

            var bestAxe =
                AxeList.Where(x => !x.Axe.IsDead && x.Axe.IsValid() && x.Axe.Position.DistanceToMouse() <= catchRange)
                .OrderBy(x => x.AxeTime)
                .ThenBy(x => x.Axe.Position.DistanceToPlayer())
                .ThenBy(x => x.Axe.Position.DistanceToMouse())
                .FirstOrDefault();

            if (bestAxe != null)
            {
                if (MiscOption.GetBool("UnderTurret") &&
                    ((Me.UnderTurret(true) && bestAxe.Axe.Position.UnderTurret(true)) || (bestAxe.Axe.Position.
                                                                                          UnderTurret(true) &&
                                                                                          !Me.UnderTurret(true))))
                {
                    return;
                }

                if (MiscOption.GetBool("CheckSafe") &&
                    (ObjectManager.Heroes.Enemies.Count(x => x.Distance(bestAxe.Axe.Position) < 350) > 3 ||
                     ObjectManager.Heroes.Enemies.Count(x => x.Distance(bestAxe.Axe.Position) < 350 && x.IsMelee()) > 1))
                {
                    return;
                }

                if (((MiscOption.GetList("WCatchAxe") == 0 && (isComboMode || isHarassMode)) ||
                     (MiscOption.GetList("WCatchAxe") == 1 && isComboMode)) && W.IsReady() &&
                    (bestAxe.Axe.Position.DistanceToPlayer() / Me.MovementSpeed * 1000 >= bestAxe.AxeTime - Utils.TickCount))
                {
                    W.Cast();
                }

                if (bestAxe.Axe.Position.DistanceToPlayer() > 100)
                {
                    if (Utils.TickCount - lastCatchTime > 1800)
                    {
                        if (!isNoneMode)
                        {
                            myOrbwalker.SetOrbwalkingPoint(bestAxe.Axe.Position);
                        }
                        else
                        {
                            Me.IssueOrder(GameObjectOrder.MoveTo, bestAxe.Axe.Position);
                        }
                    }
                    else
                    {
                        if (!isNoneMode)
                        {
                            myOrbwalker.SetOrbwalkingPoint(Game.CursorPosition);
                        }
                    }
                }
                else
                {
                    if (!isNoneMode)
                    {
                        myOrbwalker.SetOrbwalkingPoint(Game.CursorPosition);
                    }
                }
            }
            else
            {
                if (!isNoneMode)
                {
                    myOrbwalker.SetOrbwalkingPoint(Game.CursorPosition);
                }
            }
        }