Exemplo n.º 1
0
        private void CastWq(Obj_AI_Hero target)
        {
            if (Player.Distance(target) < 1150 && Player.Distance(target) > 450)
            {
                if (W.IsReady() && (Q.IsReady() || qSpell.State == SpellState.Surpressed))
                {
                    Vector3 wVec = Player.ServerPosition + Vector3.Normalize(target.ServerPosition - Player.ServerPosition) * 450;

                    var qPred = GetP(wVec, QExtend, target, true);

                    if (qPred.Hitchance >= getQHitchance())
                    {
                        W.Cast(wVec);
                        QExtend.Cast(qPred.CastPosition, packets());
                    }
                }
            }
        }
Exemplo n.º 2
0
        private void CastQe(Obj_AI_Hero target)
        {
            if (soilderCount() > 0)
            {
                if ((Q.IsReady() || QSpell.State == SpellState.Surpressed) && E.IsReady())
                {
                    var slaves = xSLxOrbwalker.Soilders.ToList();

                    foreach (var slave in slaves)
                    {
                        if (target != null && Player.Distance(target) < 800)
                        {
                            var qPred = GetP(slave.Position, QExtend, target, true);

                            if (Q.IsReady() && Player.Distance(target) < 800 && qPred.Hitchance >= getQHitchance())
                            {
                                var vec        = target.ServerPosition - Player.ServerPosition;
                                var castBehind = qPred.CastPosition + Vector3.Normalize(vec) * 75;

                                Q.Cast(castBehind, packets());
                                E.Cast(slave.Position, packets());
                                return;
                            }
                        }
                    }
                }
            }
            else if (W.IsReady())
            {
                Vector3 wVec = Player.ServerPosition + Vector3.Normalize(target.ServerPosition - Player.ServerPosition) * W.Range;

                var qPred = GetP(wVec, QExtend, target, true);

                if ((Q.IsReady() || QSpell.State == SpellState.Surpressed) && (E.IsReady() || ESpell.State == SpellState.Surpressed) && Player.Distance(target) < 800 && qPred.Hitchance >= getQHitchance())
                {
                    var vec        = target.ServerPosition - Player.ServerPosition;
                    var castBehind = qPred.CastPosition + Vector3.Normalize(vec) * 75;

                    W.Cast(wVec);
                    QExtend.Cast(castBehind, packets());
                    Utility.DelayAction.Add(1, () => E.Cast(getNearestSoilderToEnemy(target).Position, packets()));
                }
            }
        }
Exemplo n.º 3
0
        private void CastQe(Obj_AI_Hero target)
        {
            if (soilderCount() > 0)
            {
                if ((Q.IsReady() || qSpell.State == SpellState.Surpressed) && E.IsReady())
                {
                    var slaves = (from obj in ObjectManager.Get <Obj_AI_Base>() where obj.Name == "AzirSoldier" && obj.IsAlly && target.Distance(obj.ServerPosition) < 2000 select obj).ToList();

                    foreach (var slave in slaves)
                    {
                        if (target != null && Player.Distance(target) < 800)
                        {
                            var qPred = GetP(slave.ServerPosition, QExtend, target, true);

                            if (Q.IsReady() && Player.Distance(target) < 800 && qPred.Hitchance >= getQHitchance())
                            {
                                var vec        = target.ServerPosition - Player.ServerPosition;
                                var castBehind = qPred.CastPosition + Vector3.Normalize(vec) * 75;

                                Q.Cast(castBehind, packets());
                                E.Cast(slave.ServerPosition, packets());
                                return;
                            }
                        }
                    }
                }
            }
            else if (W.IsReady())
            {
                Vector3 wVec = Player.ServerPosition + Vector3.Normalize(target.ServerPosition - Player.ServerPosition) * 450;

                var qPred = GetP(wVec, QExtend, target, true);

                if ((Q.IsReady() || qSpell.State == SpellState.Surpressed) && (E.IsReady() || eSpell.State == SpellState.Surpressed) && Player.Distance(target) < 800 && qPred.Hitchance >= getQHitchance())
                {
                    var vec        = target.ServerPosition - Player.ServerPosition;
                    var castBehind = qPred.CastPosition + Vector3.Normalize(vec) * 75;

                    W.Cast(wVec);
                    QExtend.Cast(castBehind, packets());
                    Utility.DelayAction.Add(1, () => E.Cast(getNearestSoilderToEnemy(target).ServerPosition, packets()));
                }
            }
        }
Exemplo n.º 4
0
        private void CastQ(string source)
        {
            if (!Q.IsReady())
            {
                return;
            }

            var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);

            if (target != null && target.IsValidTarget(Q.Range))
            {
                SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Magical, HitChanceManager.GetQHitChance(source));
            }

            target = TargetSelector.GetTarget(QExtend.Range, TargetSelector.DamageType.Physical);

            if (target == null)
            {
                return;
            }

            var pred       = QExtend.GetPrediction(target, true);
            var collisions = MinionManager.GetMinions(Player.ServerPosition, Q.Range, MinionTypes.All, MinionTeam.NotAlly);

            if (!collisions.Any())
            {
                return;
            }

            foreach (var minion in collisions)
            {
                var poly = new Geometry.Polygon.Rectangle(Player.ServerPosition, Player.ServerPosition.Extend(minion.ServerPosition, QExtend.Range), QExtend.Width);

                if (poly.IsInside(pred.UnitPosition))
                {
                    if (Q.Cast(minion) == Spell.CastStates.SuccessfullyCasted)
                    {
                        Q.LastCastAttemptT = Utils.TickCount;
                        return;
                    }
                }
            }
        }
Exemplo n.º 5
0
        private static void Farm()
        {
            var range = MenuInit.HarassQExtend && QExtend.IsReady()
                ? QExtend.Range
                : MenuInit.HarassW && W.IsReady() ? W.Range : MenuInit.HarassQ && Q.IsReady() ? Q.Range : 0;

            if (ManaManager.SpellHarass && ManaManager.HasEnoughMana(MenuInit.HarassMP) && range > 0 &&
                Player.Instance.CountEnemyChampionsInRange(range) > 0)
            {
                Harass();
            }
            else if (ManaManager.SpellFarm)
            {
                if (isLaneClearMode && ManaManager.HasEnoughMana(MenuInit.LaneClearMP))
                {
                    LaneClear();
                }
            }
        }
Exemplo n.º 6
0
        private static void LaneClear()
        {
            if (TickCount - lastCastTime < 600 || havePassiveBuff)
            {
                return;
            }

            if (MenuInit.LaneClearQ && Q.IsReady())
            {
                var minions =
                    EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy,
                                                                    Player.Instance.Position, Q.Range).ToList();

                if (minions.Any())
                {
                    var minion     = minions.FirstOrDefault();
                    var qExminions =
                        EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy,
                                                                        Player.Instance.Position, QExtend.Range).ToList();

                    if (minion != null && QExtend.CountHits(qExminions, Player.Instance.Extend(minion.Position, 900)) >= 2)
                    {
                        Q.Cast(minion);
                        return;
                    }
                }
            }

            if (MenuInit.LaneClearW && W.IsReady())
            {
                var minions =
                    EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy,
                                                                    Player.Instance.Position, W.Range).ToList();

                if (minions.Count > 2)
                {
                    var pred = W.GetBestCircularCastPosition(minions);

                    W.Cast(pred.CastPosition);
                }
            }
        }
Exemplo n.º 7
0
        private void Harass()
        {
            if (Me.UnderTurret(true))
            {
                return;
            }

            if (Me.ManaPercent >= Menu.Item("HarassMana", true).GetValue <Slider>().Value)
            {
                var target = TargetSelector.GetSelectedTarget() ??
                             TargetSelector.GetTarget(QExtend.Range, TargetSelector.DamageType.Physical);

                if (CheckTarget(target, QExtend.Range))
                {
                    if (Menu.Item("HarassE", true).GetValue <bool>() && E.IsReady() && target.IsValidTarget(E.Range))
                    {
                        E.CastTo(target);
                    }

                    if (Menu.Item("HarassW", true).GetValue <bool>() && W.IsReady())
                    {
                        if (HaveEBuff(target) && Q.IsReady())
                        {
                            W.Cast();
                        }
                    }

                    if (Menu.Item("HarassQ", true).GetValue <bool>() && Q.IsReady() && target.IsValidTarget(QExtend.Range))
                    {
                        if (!HaveEBuff(target) && target.IsValidTarget(Q.Range))
                        {
                            Q.CastTo(target);
                        }
                        else if (target.IsValidTarget(QExtend.Range) && HaveEBuff(target))
                        {
                            QExtend.Cast(target);
                        }
                    }
                }
            }
        }
Exemplo n.º 8
0
        private void Farm()
        {
            if (!ManaManager.HasMana("LaneClear"))
            {
                return;
            }

            var useQ = Menu.Item("UseQFarm", true).GetValue <bool>();
            var useW = Menu.Item("UseWFarm", true).GetValue <bool>();

            if (useQ && Utils.TickCount - CastSpellTime >= 400)
            {
                var allMinions = MinionManager.GetMinions(Player.Position, Q.Range);

                if (allMinions.Any())
                {
                    var minion = allMinions.FirstOrDefault();

                    if (minion != null)
                    {
                        var qExminions = MinionManager.GetMinions(Player.Position, 900);

                        if (QExtend.CountHits(allMinions, Player.Position.Extend(minion.Position, 900)) >= 2)
                        {
                            Q.CastOnUnit(minion);
                        }
                    }
                }
            }
            if (useW && Utils.TickCount - CastSpellTime >= 400)
            {
                var allMinionE = MinionManager.GetMinions(Player.ServerPosition, W.Range);

                if (allMinionE.Count > 2)
                {
                    var pred = W.GetCircularFarmLocation(allMinionE);

                    W.Cast(pred.Position);
                }
            }
        }
Exemplo n.º 9
0
        private void CastWq(Obj_AI_Hero target)
        {
            if (soilderCount() < 1 && menu.Item("qMulti", true).GetValue <KeyBind>().Active)
            {
                return;
            }

            if (Player.Distance(target) < 1150 && Player.Distance(target) > W.Range)
            {
                if (W.IsReady() && (Q.IsReady() || QSpell.State == SpellState.Surpressed))
                {
                    Vector3 wVec = Player.ServerPosition + Vector3.Normalize(target.ServerPosition - Player.ServerPosition) * W.Range;

                    var qPred = GetP(wVec, QExtend, target, true);

                    if (qPred.Hitchance >= getQHitchance())
                    {
                        W.Cast(wVec);
                        QExtend.Cast(qPred.CastPosition, packets());
                    }
                }
            }
        }
Exemplo n.º 10
0
        private void LaneClear()
        {
            if (ManaManager.HasEnoughMana(Menu.GetSlider("LaneClearMana")) && ManaManager.SpellFarm)
            {
                if (Menu.GetBool("LaneClearQ") && Utils.TickCount - CastSpellTime >= 400)
                {
                    var allMinions = MinionManager.GetMinions(Me.Position, Q.Range);

                    if (allMinions.Any())
                    {
                        var minion = allMinions.FirstOrDefault();

                        if (minion != null)
                        {
                            var qExminions = MinionManager.GetMinions(Me.Position, 900);

                            if (QExtend.CountHits(allMinions, Me.Position.Extend(minion.Position, 900)) >= 2)
                            {
                                Q.CastOnUnit(minion);
                            }
                        }
                    }
                }

                if (Menu.GetBool("LaneClearW") && Utils.TickCount - CastSpellTime >= 400)
                {
                    var allMinionE = MinionManager.GetMinions(Me.ServerPosition, W.Range);

                    if (allMinionE.Count > 2)
                    {
                        var pred = W.GetCircularFarmLocation(allMinionE);

                        W.Cast(pred.Position);
                    }
                }
            }
        }
Exemplo n.º 11
0
        private void LaneClear()
        {
            if (Me.ManaPercent >= Menu.Item("LaneClearMana", true).GetValue <Slider>().Value)
            {
                if (Menu.Item("LaneClearQ", true).GetValue <bool>() && Utils.TickCount - CastSpellTime >= 400)
                {
                    var allMinions = MinionManager.GetMinions(Me.Position, Q.Range);

                    if (allMinions.Any())
                    {
                        var minion = allMinions.FirstOrDefault();

                        if (minion != null)
                        {
                            var qExminions = MinionManager.GetMinions(Me.Position, 900);

                            if (QExtend.CountHits(allMinions, Me.Position.Extend(minion.Position, 900)) >= 2)
                            {
                                Q.CastOnUnit(minion);
                            }
                        }
                    }
                }
                if (Menu.Item("LaneClearW", true).GetValue <bool>() && Utils.TickCount - CastSpellTime >= 400)
                {
                    var allMinionE = MinionManager.GetMinions(Me.ServerPosition, W.Range);

                    if (allMinionE.Count > 2)
                    {
                        var pred = W.GetCircularFarmLocation(allMinionE);

                        W.Cast(pred.Position);
                    }
                }
            }
        }
Exemplo n.º 12
0
        private void Insec()
        {
            var target = (Obj_AI_Hero)_insecTarget;

            if (target == null)
            {
                return;
            }

            if (soilderCount() > 0)
            {
                if ((Q.IsReady() || QSpell.State == SpellState.Surpressed) && E.IsReady())
                {
                    var slaves = xSLxOrbwalker.Soilders.ToList();

                    foreach (var slave in slaves)
                    {
                        if (Player.Distance(target) < 800)
                        {
                            var qPred      = GetP(slave.Position, QExtend, target, true);
                            var vec        = target.ServerPosition - Player.ServerPosition;
                            var castBehind = qPred.CastPosition + Vector3.Normalize(vec) * 75;
                            _rVec = qPred.CastPosition - Vector3.Normalize(vec) * 300;

                            if (Q.IsReady() && (E.IsReady() || ESpell.State == SpellState.Surpressed) && R.IsReady() && qPred.Hitchance >= getQHitchance())
                            {
                                Q.Cast(castBehind, packets());
                                E.Cast(slave.Position, packets());
                                E.LastCastAttemptT = Environment.TickCount;
                            }
                        }
                    }
                }
                if (R.IsReady())
                {
                    if (Player.Distance(target) < 200 && Environment.TickCount - E.LastCastAttemptT > Game.Ping + 150)
                    {
                        //Game.PrintChat("rawr");
                        R.Cast(_rVec);
                    }
                }
            }
            else if (W.IsReady())
            {
                Vector3 wVec = Player.ServerPosition + Vector3.Normalize(target.ServerPosition - Player.ServerPosition) * W.Range;

                var qPred = GetP(wVec, QExtend, target, true);

                if ((Q.IsReady() || QSpell.State == SpellState.Surpressed) && (E.IsReady() || ESpell.State == SpellState.Surpressed) &&
                    R.IsReady() && Player.Distance(target) < 800 && qPred.Hitchance >= getQHitchance())
                {
                    var vec        = target.ServerPosition - Player.ServerPosition;
                    var castBehind = qPred.CastPosition + Vector3.Normalize(vec) * 75;
                    _rVec = Player.Position;

                    W.Cast(wVec);
                    QExtend.Cast(castBehind, packets());
                    E.Cast(getNearestSoilderToEnemy(target).Position, packets());
                }
                if (R.IsReady())
                {
                    if (Player.Distance(target) < 200 && Environment.TickCount - E.LastCastAttemptT > Game.Ping + 150)
                    {
                        //Game.PrintChat("rawr2");
                        R.Cast(_rVec);
                    }
                }
            }
        }
Exemplo n.º 13
0
        private static void AfterAttack(AttackableUnit unit, AttackableUnit ArgsTarget)
        {
            if (!unit.IsMe)
            {
                return;
            }

            if (isComboMode)
            {
                var target = (AIHeroClient)ArgsTarget;

                if (target != null && !target.IsDead && !target.IsZombie)
                {
                    if (ComboOption.UseE && E.IsReady() && (Q.IsReady() || target.Health < E.GetDamage(target)))
                    {
                        SpellManager.PredCast(E, target, true);
                    }

                    if (ComboOption.UseW && W.IsReady())
                    {
                        if (target.DistanceToPlayer() <= Me.AttackRange + Me.BoundingRadius)
                        {
                            if (ComboOption.GetBool("ComboWAlways"))
                            {
                                W.Cast();
                            }

                            if (Me.HealthPercent <= ComboOption.GetSlider("ComboWLowHp"))
                            {
                                W.Cast();
                            }
                        }

                        if (ComboOption.GetBool("ComboWBuff") && HaveEBuff(target) && Q.IsReady())
                        {
                            W.Cast();
                        }
                    }
                    else if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(QExtend.Range))
                    {
                        if (!HaveEBuff(target) && target.IsValidTarget(Q.Range))
                        {
                            if (ComboOption.GetBool("ComboFirstE") && E.IsReady() && ComboOption.UseE && target.IsValidTarget(E.Range))
                            {
                                SpellManager.PredCast(E, target, true);
                            }
                            else
                            {
                                SpellManager.PredCast(Q, target);
                            }
                        }
                        else if (target.IsValidTarget(QExtend.Range) && HaveEBuff(target))
                        {
                            QExtend.Cast(target);
                        }
                    }
                }
            }

            if (isJungleClearMode && JungleClearOption.HasEnouguMana)
            {
                var mobs = MinionManager.GetMinions(Me.Position, E.Range, MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth);

                if (mobs.Any())
                {
                    var mob = mobs.FirstOrDefault();

                    if (mob != null)
                    {
                        if (JungleClearOption.UseW && W.IsReady())
                        {
                            W.Cast();
                        }

                        if (JungleClearOption.UseQ && Q.IsReady() && mob.IsValidTarget(Q.Range))
                        {
                            Q.Cast(mob);
                        }
                    }
                }
            }
        }
Exemplo n.º 14
0
        private void Insec()
        {
            var target = (Obj_AI_Hero)_insecTarget;

            if (target == null)
            {
                return;
            }

            if (soilderCount() > 0)
            {
                if ((Q.IsReady() || qSpell.State == SpellState.Surpressed) && E.IsReady())
                {
                    var slaves = (from obj in ObjectManager.Get <Obj_AI_Base>() where obj.Name == "AzirSoldier" && obj.IsAlly && target.Distance(obj.ServerPosition) < 2000 select obj).ToList();

                    foreach (var slave in slaves)
                    {
                        if (Player.Distance(target) < 800)
                        {
                            var qPred      = GetP(slave.ServerPosition, QExtend, target, true);
                            var vec        = target.ServerPosition - Player.ServerPosition;
                            var castBehind = qPred.CastPosition + Vector3.Normalize(vec) * 75;
                            _rVec = qPred.CastPosition - Vector3.Normalize(vec) * 300;

                            if (Q.IsReady() && (E.IsReady() || eSpell.State == SpellState.Surpressed) && R.IsReady() && qPred.Hitchance >= getQHitchance())
                            {
                                Q.Cast(castBehind, packets());
                                E.Cast(slave.ServerPosition, packets());
                                E.LastCastAttemptT = Environment.TickCount;
                            }
                        }
                    }
                }
                if (R.IsReady())
                {
                    if (Player.Distance(target) < 200 && Environment.TickCount - E.LastCastAttemptT > Game.Ping + 150)
                    {
                        //Game.PrintChat("rawr");
                        R.Cast(_rVec);
                    }
                }
            }
            else if (W.IsReady())
            {
                Vector3 wVec = Player.ServerPosition + Vector3.Normalize(target.ServerPosition - Player.ServerPosition) * 450;

                var qPred = GetP(wVec, QExtend, target, true);

                if ((Q.IsReady() || qSpell.State == SpellState.Surpressed) && (E.IsReady() || eSpell.State == SpellState.Surpressed) &&
                    R.IsReady() && Player.Distance(target) < 800 && qPred.Hitchance >= getQHitchance())
                {
                    var vec        = target.ServerPosition - Player.ServerPosition;
                    var castBehind = qPred.CastPosition + Vector3.Normalize(vec) * 75;
                    _rVec = Player.Position;

                    W.Cast(wVec);
                    QExtend.Cast(castBehind, packets());
                    E.Cast(getNearestSoilderToEnemy(target).ServerPosition, packets());
                }
                if (R.IsReady())
                {
                    if (Player.Distance(target) < 200 && Environment.TickCount - E.LastCastAttemptT > Game.Ping + 150)
                    {
                        //Game.PrintChat("rawr2");
                        R.Cast(_rVec);
                    }
                }
            }
        }
Exemplo n.º 15
0
        private void Escape()
        {
            Vector3 wVec = Player.ServerPosition + Vector3.Normalize(Game.CursorPos - Player.ServerPosition) * 450;

            if (menu.Item("fastEscape").GetValue <bool>())
            {
                if (W.IsReady() || soilderCount() > 0)
                {
                    if ((E.IsReady() || eSpell.State == SpellState.Surpressed))
                    {
                        W.Cast(wVec);
                        W.LastCastAttemptT = Environment.TickCount;
                    }

                    if ((QExtend.IsReady() || qSpell.State == SpellState.Surpressed) &&
                        ((Environment.TickCount - E.LastCastAttemptT < Game.Ping + 500 &&
                          Environment.TickCount - E.LastCastAttemptT > Game.Ping + 50) || E.IsReady()))
                    {
                        if (Environment.TickCount - W.LastCastAttemptT > Game.Ping + 300 || eSpell.State == SpellState.Cooldown || !W.IsReady())
                        {
                            Vector3 qVec = Player.ServerPosition +
                                           Vector3.Normalize(Game.CursorPos - Player.ServerPosition) * 800;

                            var lastAttempt = (int)qVec.Distance(GetNearestSoilderToMouse().ServerPosition) / 1000;

                            Q.Cast(qVec, packets());
                            Q.LastCastAttemptT = Environment.TickCount + lastAttempt;
                            return;
                        }
                    }

                    if ((E.IsReady() || eSpell.State == SpellState.Surpressed))
                    {
                        if (Player.Distance(Game.CursorPos) > GetNearestSoilderToMouse().Distance(Game.CursorPos) && Environment.TickCount - Q.LastCastAttemptT > Game.Ping)
                        {
                            E.Cast(GetNearestSoilderToMouse().ServerPosition, packets());
                            E.LastCastAttemptT = Environment.TickCount - 250;
                            //Game.PrintChat("Rawr2");
                            return;
                        }
                        if (Environment.TickCount - W.LastCastAttemptT < Game.Ping + 300 && (Q.IsReady() || qSpell.State == SpellState.Surpressed))
                        {
                            E.Cast(wVec, packets());
                            E.LastCastAttemptT = Environment.TickCount - 250;
                            //Game.PrintChat("Rawr1");
                        }
                    }
                }
            }
            else
            {
                if (E.IsReady() || eSpell.State == SpellState.Surpressed)
                {
                    if (soilderCount() > 0)
                    {
                        Vector3 qVec = Player.ServerPosition +
                                       Vector3.Normalize(Game.CursorPos - Player.ServerPosition) * 800;

                        var slave = GetNearestSoilderToMouse();

                        var delay = (int)Math.Ceiling(slave.Distance(Player.ServerPosition));

                        if (QExtend.IsReady() || qSpell.State == SpellState.Surpressed)
                        {
                            Q.Cast(qVec, packets());
                        }

                        Utility.DelayAction.Add(delay,
                                                () => E.Cast(GetNearestSoilderToMouse().ServerPosition, packets()));
                        return;
                    }
                    if (W.IsReady())
                    {
                        W.Cast(wVec);

                        if (E.IsReady() || eSpell.State == SpellState.Surpressed)
                        {
                            E.Cast(wVec, packets());
                        }

                        if (QExtend.IsReady() || qSpell.State == SpellState.Surpressed)
                        {
                            Vector3 qVec = Player.ServerPosition +
                                           Vector3.Normalize(Game.CursorPos - Player.ServerPosition) * 800;

                            Utility.DelayAction.Add(300, () => Q.Cast(qVec, packets()));
                        }
                    }
                }
            }
        }
Exemplo n.º 16
0
        private void OnDoCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs Args)
        {
            if (!sender.IsMe || !Orbwalking.IsAutoAttack(Args.SData.Name))
            {
                return;
            }

            if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
            {
                var target = (Obj_AI_Hero)Args.Target;

                if (target != null && !target.IsDead && !target.IsZombie)
                {
                    if (Menu.Item("ComboE", true).GetValue <bool>() && E.IsReady() &&
                        (Q.IsReady() || target.Health < E.GetDamage(target)))
                    {
                        E.Cast(target.Position, true);
                    }

                    if (Menu.Item("ComboW", true).GetValue <bool>() && W.IsReady())
                    {
                        if (target.DistanceToPlayer() <= Orbwalking.GetRealAutoAttackRange(Me))
                        {
                            if (Menu.Item("ComboWAlways", true).GetValue <bool>())
                            {
                                W.Cast();
                            }

                            if (Me.HealthPercent <= Menu.Item("ComboWLowHp", true).GetValue <Slider>().Value)
                            {
                                W.Cast();
                            }
                        }

                        if (Menu.Item("ComboWBuff", true).GetValue <bool>() && HaveEBuff(target) && Q.IsReady())
                        {
                            W.Cast();
                        }
                    }

                    if (Menu.Item("ComboQ", true).GetValue <bool>() && Q.IsReady() && target.IsValidTarget(QExtend.Range))
                    {
                        if (!HaveEBuff(target) && target.IsValidTarget(Q.Range))
                        {
                            if (Menu.Item("ComboFirstE", true).GetValue <bool>() && E.IsReady() &&
                                Menu.Item("ComboE", true).GetValue <bool>() && target.IsValidTarget(E.Range))
                            {
                                E.Cast(target.Position, true);
                            }
                            else
                            {
                                Q.CastTo(target);
                            }
                        }
                        else if (target.IsValidTarget(QExtend.Range) && HaveEBuff(target))
                        {
                            QExtend.Cast(target);
                        }
                    }
                }
            }

            if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
            {
                if (Me.ManaPercent >= Menu.Item("JungleClearMana", true).GetValue <Slider>().Value)
                {
                    var mobs = MinionManager.GetMinions(Me.Position, R.Range, MinionTypes.All, MinionTeam.Neutral,
                                                        MinionOrderTypes.MaxHealth);

                    if (mobs.Any())
                    {
                        var mob    = mobs.FirstOrDefault();
                        var bigmob = mobs.FirstOrDefault(x => !x.Name.ToLower().Contains("mini"));

                        if (Menu.Item("JungleClearW", true).GetValue <bool>() && W.IsReady() && bigmob != null &&
                            bigmob.IsValidTarget(W.Range))
                        {
                            W.Cast();
                        }

                        if (Menu.Item("JungleClearQ", true).GetValue <bool>() && Q.IsReady() && mob != null &&
                            mob.IsValidTarget(Q.Range))
                        {
                            Q.Cast(mob);
                        }
                    }
                }
            }
        }
Exemplo n.º 17
0
        private void Combo()
        {
            var target = TargetSelector.GetSelectedTarget() ??
                         TargetSelector.GetTarget(QExtend.Range, TargetSelector.DamageType.Physical);

            if (CheckTarget(target, QExtend.Range))
            {
                if (Menu.Item("ComboR", true).GetValue <bool>() && R.IsReady() && target.IsValidTarget(R.Range))
                {
                    if (Menu.Item("RSafe", true).GetValue <bool>() && !Me.UnderTurret(true))
                    {
                        foreach (
                            var rTarget in
                            HeroManager.Enemies.Where(
                                x =>
                                x.IsValidTarget(R.Range) &&
                                !Menu.Item("Dontr" + target.ChampionName.ToLower(), true).GetValue <bool>())
                            .OrderByDescending(x => E.IsReady() ? E.GetDamage(x) : 0 + Q.GetDamage(x) * 2))
                        {
                            if (rTarget.CountEnemiesInRange(R.Range) <= Menu.Item("RSwap", true).GetValue <Slider>().Value)
                            {
                                if (Menu.Item("RAlly", true).GetValue <bool>() && Me.UnderAllyTurret() &&
                                    rTarget.DistanceToPlayer() <= 350)
                                {
                                    R.CastOnUnit(rTarget);
                                }

                                if (Menu.Item("RKill", true).GetValue <bool>() && target.Health < ComboDamage(target))
                                {
                                    R.CastOnUnit(rTarget);
                                }
                            }
                        }
                    }
                }

                if (Menu.Item("ComboE", true).GetValue <bool>() && E.IsReady() && target.IsValidTarget(E.Range) &&
                    (Q.IsReady() || target.Health < E.GetDamage(target)))
                {
                    E.CastTo(target);
                }

                if (Menu.Item("ComboW", true).GetValue <bool>() && W.IsReady())
                {
                    if (target.DistanceToPlayer() <= Orbwalking.GetRealAutoAttackRange(Me))
                    {
                        if (Menu.Item("ComboWAlways", true).GetValue <bool>())
                        {
                            W.Cast();
                        }

                        if (Me.HealthPercent <= Menu.Item("ComboWLowHp", true).GetValue <Slider>().Value)
                        {
                            W.Cast();
                        }
                    }

                    if (Menu.Item("ComboWBuff", true).GetValue <bool>() && HaveEBuff(target) && Q.IsReady())
                    {
                        W.Cast();
                    }
                }

                if (Menu.Item("ComboQ", true).GetValue <bool>() && Q.IsReady() && target.IsValidTarget(QExtend.Range))
                {
                    if (!HaveEBuff(target) && target.IsValidTarget(Q.Range))
                    {
                        if (Menu.Item("ComboFirstE", true).GetValue <bool>() && E.IsReady() &&
                            Menu.Item("ComboE", true).GetValue <bool>() && target.IsValidTarget(E.Range))
                        {
                            E.CastTo(target);
                        }
                        else
                        {
                            Q.CastTo(target);
                        }
                    }
                    else if (target.IsValidTarget(QExtend.Range) && HaveEBuff(target))
                    {
                        QExtend.Cast(target);
                    }
                }
            }
        }
Exemplo n.º 18
0
        private void Escape()
        {
            Vector3 wVec = Player.ServerPosition + Vector3.Normalize(Game.CursorPos - Player.ServerPosition) * W.Range;

            if (menu.Item("fastEscape", true).GetValue <bool>())
            {
                if (W.IsReady() || soilderCount() > 0)
                {
                    if ((E.IsReady() || ESpell.State == SpellState.Surpressed))
                    {
                        W.Cast(wVec);
                        W.LastCastAttemptT = Environment.TickCount;
                    }

                    if ((QExtend.IsReady() || QSpell.State == SpellState.Surpressed) &&
                        ((Environment.TickCount - E.LastCastAttemptT < Game.Ping + 500 &&
                          Environment.TickCount - E.LastCastAttemptT > Game.Ping + 50) || E.IsReady()))
                    {
                        if (Environment.TickCount - W.LastCastAttemptT > Game.Ping + 300 || ESpell.State == SpellState.Cooldown || !W.IsReady())
                        {
                            Vector3 qVec = Player.ServerPosition +
                                           Vector3.Normalize(Game.CursorPos - Player.ServerPosition) * 800;

                            var lastAttempt = (int)qVec.Distance(GetNearestSoilderToMouse().Position) / 1000;

                            Q.Cast(qVec, packets());
                            Q.LastCastAttemptT = Environment.TickCount + lastAttempt;
                            return;
                        }
                    }

                    if ((E.IsReady() || ESpell.State == SpellState.Surpressed))
                    {
                        if (Player.Distance(Game.CursorPos) > GetNearestSoilderToMouse().Position.Distance(Game.CursorPos) && Environment.TickCount - Q.LastCastAttemptT > Game.Ping)
                        {
                            E.Cast(GetNearestSoilderToMouse().Position, packets());
                            E.LastCastAttemptT = Environment.TickCount - 250;
                            //Game.PrintChat("Rawr2");
                            return;
                        }
                        if (Environment.TickCount - W.LastCastAttemptT < Game.Ping + 300 && (Q.IsReady() || QSpell.State == SpellState.Surpressed))
                        {
                            E.Cast(wVec, packets());
                            E.LastCastAttemptT = Environment.TickCount - 250;
                            //Game.PrintChat("Rawr1");
                        }
                    }
                }
            }
            else
            {
                if (Environment.TickCount - E.LastCastAttemptT < 250 + Game.Ping / 2 && Environment.TickCount - E.LastCastAttemptT > _delay && ESpell.State == SpellState.Cooldown && _point != Vector3.Zero)
                {
                    Q2.Cast(_vecPoint, packets());
                }

                if ((E.IsReady() || ESpell.State == SpellState.Surpressed) && _point != Vector3.Zero)
                {
                    if (soilderCount() < 1 && W.IsReady())
                    {
                        W.Cast(wVec);
                    }
                    else if (soilderCount() < 1 && !W.IsReady())
                    {
                        return;
                    }

                    if (GetNearestSoilderToMouse() == null)
                    {
                        return;
                    }

                    var nearSlave = GetNearestSoilderToMouse();

                    if (E.IsReady() || ESpell.State == SpellState.Surpressed)
                    {
                        E.Cast(nearSlave.Position, packets());
                    }

                    if (QExtend.IsReady() || QSpell.State == SpellState.Surpressed)
                    {
                        _vecPoint = nearSlave.Position + Vector3.Normalize(_point - nearSlave.Position) * 700;
                        _delay    = (int)(100 * (Player.Distance(nearSlave.Position) / 800) + menu.Item("escapeDelay", true).GetValue <Slider>().Value);

                        //Game.PrintChat("Delay" + _delay);
                    }
                }
            }
        }
Exemplo n.º 19
0
        private void JungleClear()
        {
            if (!ManaManager.HasMana("JungleClear"))
            {
                return;
            }

            var mobs = MinionManager.GetMinions(Player.Position, 800, MinionTypes.All, MinionTeam.Neutral,
                                                MinionOrderTypes.MaxHealth);

            if (mobs.Any())
            {
                var mob = mobs.FirstOrDefault();

                if (!IsMelee)
                {
                    if (Menu.Item("UseEJungle", true).GetValue <bool>() && E.IsReady() &&
                        Menu.Item("UseQJungle", true).GetValue <bool>() && Q.IsReady())
                    {
                        var gateVector = Player.ServerPosition +
                                         Vector3.Normalize(Game.CursorPos - Player.ServerPosition) * 50;

                        if (mob != null && mob.IsValidTarget(QExtend.Range))
                        {
                            E.Cast(gateVector);
                            QExtend.Cast(mob.Position);
                        }
                    }

                    if (Menu.Item("UseQJungle", true).GetValue <bool>() && Q.IsReady())
                    {
                        var qFarm = MinionManager.GetBestLineFarmLocation(mobs.Select(x => x.Position.To2D()).ToList(),
                                                                          Q.Width, Q.Range);

                        if (qFarm.MinionsHit >= 1)
                        {
                            Q.Cast(qFarm.Position);
                        }
                    }

                    if (Menu.Item("UseWJungle", true).GetValue <bool>() && W.IsReady())
                    {
                        if (mob.Distance(Player) <= 550)
                        {
                            W.Cast();
                        }
                    }

                    if (Menu.Item("UseRJungle", true).GetValue <bool>() && R.IsReady())
                    {
                        if (Qcd != 0 && Wcd != 0 && Ecd != 0)
                        {
                            R.Cast();
                        }
                    }
                }
                else
                {
                    if (Menu.Item("UseWJungleHam", true).GetValue <bool>() && W2.IsReady() && mob.IsValidTarget(300))
                    {
                        W2.Cast();
                    }

                    if (Menu.Item("UseQJungleHam", true).GetValue <bool>() && Q2.IsReady() && mob.IsValidTarget(Q2.Range))
                    {
                        Q2.CastOnUnit(mob);
                    }

                    if (Menu.Item("UseEJungleHam", true).GetValue <bool>() && E2.IsReady() && mob.IsValidTarget(E2.Range))
                    {
                        E2.CastOnUnit(mob);
                    }

                    if (Menu.Item("UseRJungle", true).GetValue <bool>() && R.IsReady())
                    {
                        if (Q1Cd != 0 && W1Cd != 0 && E1Cd != 0)
                        {
                            R.Cast();
                        }
                    }
                }
            }
        }
Exemplo n.º 20
0
        private static void Combo()
        {
            var target = TargetSelector.GetTarget(QExtend.Range, TargetSelector.DamageType.Physical);

            if (target.IsValidTarget(QExtend.Range))
            {
                if (ComboOption.UseR && R.IsReady() && target.IsValidTarget(R.Range))
                {
                    if (MiscOption.GetBool("RSafe") && !Me.UnderTurret(true))
                    {
                        foreach (
                            var rTarget in
                            ObjectManager.Heroes.Enemies.Where(
                                x =>
                                x.IsValidTarget(R.Range) &&
                                !MiscOption.GetBool("Dontr" + target.ChampionName.ToLower()))
                            .OrderByDescending(x => E.IsReady() ? E.GetDamage(x) : 0 + Q.GetDamage(x) * 2))
                        {
                            if (rTarget.CountEnemiesInRange(R.Range) <= MiscOption.GetSlider("RSwap"))
                            {
                                if (MiscOption.GetBool("RAlly") && Me.UnderAllyTurret() && rTarget.DistanceToPlayer() <= 350)
                                {
                                    R.CastOnUnit(rTarget);
                                }

                                if (MiscOption.GetBool("RKill") && target.Health < MyDamageCalculate.GetComboDamage(target))
                                {
                                    R.CastOnUnit(rTarget);
                                }
                            }
                        }
                    }
                }

                if (ComboOption.UseE && E.IsReady() && target.IsValidTarget(E.Range) &&
                    (Q.IsReady() || target.Health < E.GetDamage(target)))
                {
                    SpellManager.PredCast(E, target, true);
                }

                if (ComboOption.UseW && W.IsReady())
                {
                    if (target.DistanceToPlayer() <= Me.AttackRange + Me.BoundingRadius)
                    {
                        if (ComboOption.GetBool("ComboWAlways"))
                        {
                            W.Cast();
                        }

                        if (Me.HealthPercent <= ComboOption.GetSlider("ComboWLowHp"))
                        {
                            W.Cast();
                        }
                    }

                    if (ComboOption.GetBool("ComboWBuff") && HaveEBuff(target) && Q.IsReady())
                    {
                        W.Cast();
                    }
                }

                if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(QExtend.Range))
                {
                    if (!HaveEBuff(target) && target.IsValidTarget(Q.Range))
                    {
                        if (ComboOption.GetBool("ComboFirstE") && E.IsReady() && ComboOption.UseE && target.IsValidTarget(E.Range))
                        {
                            SpellManager.PredCast(E, target, true);
                        }
                        else
                        {
                            SpellManager.PredCast(Q, target);
                        }
                    }
                    else if (target.IsValidTarget(QExtend.Range) && HaveEBuff(target))
                    {
                        QExtend.Cast(target);
                    }
                }
            }
        }