Пример #1
0
        private static void AfterAttack(AttackableUnit unit, AttackableUnit ArgsTarget)
        {
            if (!unit.IsMe || Me.IsDead || ArgsTarget == null || ArgsTarget.IsDead || !ArgsTarget.IsValidTarget() || ArgsTarget.ObjectType != GameObjectType.AIHeroClient)
            {
                return;
            }

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

                if (!target.IsDead && !target.IsZombie)
                {
                    if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                    {
                        SpellManager.PredCast(Q, target);
                    }
                    else if (ComboOption.UseW && W.IsReady() && target.IsValidTarget(W.Range))
                    {
                        SpellManager.PredCast(W, target, true);
                    }
                }
            }
            else if (isHarassMode && HarassOption.HasEnouguMana)
            {
                var target = (AIHeroClient)ArgsTarget;

                if (!target.IsDead && !target.IsZombie && HarassOption.GetHarassTarget(target.ChampionName))
                {
                    if (HarassOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                    {
                        SpellManager.PredCast(Q, target);
                    }

                    if (HarassOption.UseW && W.IsReady() && target.IsValidTarget(W.Range))
                    {
                        SpellManager.PredCast(W, target, true);
                    }
                }
            }
        }
Пример #2
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                if (HarassOption.UseQ && Q.IsReady())
                {
                    foreach (
                        var target in
                        ObjectManager.Heroes.Enemies.Where(
                            x =>
                            x.IsValidTarget(Q.Range) &&
                            HarassOption.GetHarassTarget(x.ChampionName)))
                    {
                        if (target.IsValidTarget(Q.Range))
                        {
                            SpellManager.PredCast(Q, target);
                        }
                    }
                }

                if (HarassOption.UseW && W.IsReady())
                {
                    foreach (
                        var target in
                        ObjectManager.Heroes.Enemies.Where(
                            x =>
                            x.IsValidTarget(W.Range) &&
                            HarassOption.GetHarassTarget(x.ChampionName)))
                    {
                        if (target.IsValidTarget(W.Range))
                        {
                            SpellManager.PredCast(W, target, true);
                        }
                    }
                }
            }
        }
Пример #3
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                if (E.IsReady())
                {
                    if (HarassOption.UseE)
                    {
                        var target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                        if (target.IsValidTarget(E.Range))
                        {
                            E.CastOnUnit(target, true);
                        }
                    }

                    if (HarassOption.GetBool("HarassEToMinion"))
                    {
                        foreach (var minion in MinionManager.GetMinions(E.Range).Where(m =>
                                                                                       m.Health < Me.GetAutoAttackDamage(m) && m.CountEnemiesInRange(m.BoundingRadius + 150) >= 1))
                        {
                            var etarget = E.GetTarget();

                            if (etarget != null)
                            {
                                return;
                            }

                            E.CastOnUnit(minion, true);
                            myOrbwalker.ForceTarget(minion);
                        }
                    }
                }
            }
        }
Пример #4
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                var target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                if (target.IsValidTarget(R.Range))
                {
                    if (HarassOption.UseR && R.IsReady() && HarassOption.GetSlider("HarassRLimit") >= GetRCount &&
                        target.IsValidTarget(R.Range))
                    {
                        SpellManager.PredCast(R, target, true);
                    }

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

                    if (HarassOption.UseE && E.IsReady() && target.IsValidTarget(E.Range))
                    {
                        SpellManager.PredCast(E, target, true);
                    }
                }
            }
        }
Пример #5
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                if (HarassOption.UseW && W.IsReady() && !Me.HasBuff("AsheQAttack"))
                {
                    var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                    if (target.IsValidTarget(W.Range))
                    {
                        SpellManager.PredCast(W, target);
                    }
                }
            }
        }
Пример #6
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana && HarassOption.UseQ && Q.IsReady())
            {
                var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                if (target.IsValidTarget(Q.Range))
                {
                    SpellManager.PredCast(Q, target, true);
                }
            }
        }
Пример #7
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                if (HarassOption.UseE && E.IsReady())
                {
                    var target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical, true,
                                                          ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                    if (target.IsValidTarget(E.Range))
                    {
                        if (HarassOption.GetBool("HarassE2Passive"))
                        {
                            if (target.IsValidTarget(E.Range) && Has2WStacks(target))
                            {
                                E.CastOnUnit(target, true);
                            }
                        }
                        else
                        {
                            if (CondemnCheck(Me.ServerPosition, target))
                            {
                                E.CastOnUnit(target, true);
                            }
                        }
                    }
                }
            }
        }
Пример #8
0
        private static void AfterAttack(AttackableUnit unit, AttackableUnit tar)
        {
            if (!unit.IsMe || Me.IsDead)
            {
                return;
            }

            myOrbwalker.ForceTarget(null);

            if (tar == null || tar.IsDead || !tar.IsVisible)
            {
                return;
            }

            if (isComboMode)
            {
                if (ComboOption.GetBool("ComboAQA"))
                {
                    var target = tar as AIHeroClient;

                    if (target != null && !target.IsDead && !target.IsZombie && Q.IsReady())
                    {
                        AfterQLogic(target);
                        return;
                    }
                }
            }

            if (isHarassMode || (isFarmMode && MyManaManager.SpellHarass))
            {
                if (HarassOption.HasEnouguMana && HarassOption.UseQ)
                {
                    var target = tar as AIHeroClient;

                    if (target != null && !target.IsDead && !target.IsZombie && Q.IsReady() && HarassOption.GetHarassTarget(target.ChampionName))
                    {
                        if (HarassOption.GetBool("HarassQ2Passive") && !Has2WStacks(target))
                        {
                            return;
                        }

                        AfterQLogic(target);
                        return;
                    }
                }
            }

            if (isLaneClearMode && LaneClearOption.HasEnouguMana && LaneClearOption.UseQ)
            {
                if (tar.ObjectType == GameObjectType.obj_AI_Turret || tar.ObjectType == GameObjectType.obj_Turret ||
                    tar.ObjectType == GameObjectType.obj_HQ || tar.ObjectType == GameObjectType.obj_Barracks ||
                    tar.ObjectType == GameObjectType.obj_BarracksDampener)
                {
                    if (Me.CountEnemiesInRange(850) == 0)
                    {
                        if (Me.CanMoveMent())
                        {
                            Q.Cast(Game.CursorPosition, true);
                            return;
                        }
                    }
                }
                else if (tar.ObjectType == GameObjectType.obj_AI_Minion && tar.Team != GameObjectTeam.Neutral)
                {
                    var minions =
                        MinionManager.GetMinions(Me.Position, Me.AttackRange + Me.BoundingRadius)
                        .Where(m => m.Health <= Me.GetAutoAttackDamage(m) + Q.GetDamage(m))
                        .ToArray();

                    if (minions.Any() && minions.Length >= 1)
                    {
                        var minion         = minions.OrderBy(m => m.Health).FirstOrDefault();
                        var afterQPosition = Me.ServerPosition.Extend(Game.CursorPosition, Q.Range);

                        if (minion != null && afterQPosition.Distance(minion.ServerPosition) <= Me.AttackRange + Me.BoundingRadius)
                        {
                            if (Q.Cast(Game.CursorPosition, true))
                            {
                                myOrbwalker.ForceTarget(minion);
                                return;
                            }
                        }
                    }
                }
            }

            if (isJungleClearMode && tar.ObjectType == GameObjectType.obj_AI_Minion && tar.Team == GameObjectTeam.Neutral && JungleClearOption.HasEnouguMana && JungleClearOption.UseQ)
            {
                var mobs = MinionManager.GetMinions(Me.Position, 800, MinionTypes.All, MinionTeam.Neutral,
                                                    MinionOrderTypes.MaxHealth);

                if (mobs.Any())
                {
                    if (Me.CanMoveMent())
                    {
                        Q.Cast(Game.CursorPosition, true);
                    }
                }
            }
        }
Пример #9
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                if (HarassOption.UseW && W.IsReady())
                {
                    var wTarget = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                    if (wTarget.IsValidTarget(W.Range))
                    {
                        SpellManager.PredCast(W, wTarget, true);
                    }
                }

                if (HarassOption.UseE && E.IsReady())
                {
                    var eTarget = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                    if (eTarget.IsValidTarget(E.Range))
                    {
                        if (HarassOption.GetBool("HarassEStack"))
                        {
                            if (eTarget.DistanceToPlayer() > E.Range * 0.8 && eTarget.IsValidTarget(E.Range) &&
                                GetEStackCount(eTarget) >= HarassOption.GetSlider("HarassEStackCount"))
                            {
                                E.Cast();
                            }
                        }

                        if (HarassOption.GetBool("HarassEFull") && GetEStackCount(eTarget) >= 6)
                        {
                            E.Cast();
                        }
                    }
                }
            }
        }
Пример #10
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                if (HarassOption.UseQ && Q.IsReady())
                {
                    var target = TargetSelector.GetTarget(Q.Range + 300, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                    if (target.IsValidTarget(Q.Range))
                    {
                        Q.CastOnUnit(target, true);
                    }
                    else if (target.IsValidTarget(Q.Range + 300) && HarassOption.GetBool("HarassQMinion"))
                    {
                        if (Me.HasBuff("JhinPassiveReload") || (!Me.HasBuff("JhinPassiveReload") &&
                                                                Me.CountEnemiesInRange(Orbwalker.GetRealAutoAttackRange(Me)) == 0))
                        {
                            var qPred       = Core.Prediction.GetPrediction(target, 0.25f);
                            var bestQMinion =
                                MinionManager.GetMinions(qPred.CastPosition, 300)
                                .Where(x => x.IsValidTarget(Q.Range))
                                .OrderBy(x => x.Distance(target))
                                .ThenBy(x => x.Health)
                                .FirstOrDefault();

                            if (bestQMinion != null)
                            {
                                Q.CastOnUnit(bestQMinion, true);
                            }
                        }
                    }
                }

                if (HarassOption.UseE && E.IsReady() && Utils.TickCount - LastECast > 2500 && !IsAttack)
                {
                    var eTarget = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Magical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                    if (eTarget.IsValidTarget(E.Range))
                    {
                        SpellManager.PredCast(E, eTarget, true);
                    }
                }

                if (HarassOption.UseW && W.IsReady())
                {
                    var target = TargetSelector.GetTarget(1500f, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                    if (target.IsValidTarget(W.Range))
                    {
                        if (HarassOption.GetBool("HarassWOnly") && !HasPassive(target))
                        {
                            return;
                        }

                        SpellManager.PredCast(W, target, true);
                    }
                }
            }
        }
Пример #11
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                if (HarassOption.UseQ && Q.IsReady())
                {
                    foreach (var target in ObjectManager.Heroes.Enemies.Where(x => x.IsValidTarget(QExtend.Range) && HarassOption.GetHarassTarget(x.ChampionName)))
                    {
                        if (target.IsValidTarget(QExtend.Range))
                        {
                            QLogic(target, HarassOption.GetBool("HarassQExtend"));
                            return;
                        }
                    }
                }

                if (HarassOption.UseW && W.IsReady())
                {
                    foreach (var target in ObjectManager.Heroes.Enemies.Where(x => x.IsValidTarget(W.Range) && HarassOption.GetHarassTarget(x.ChampionName)))
                    {
                        if (target.IsValidTarget(W.Range))
                        {
                            var wPred = W.GetPrediction(target);

                            if (wPred.Hitchance >= HitChance.VeryHigh)
                            {
                                W.Cast(wPred.CastPosition, true);
                                return;
                            }
                        }
                    }
                }
            }
        }
Пример #12
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                if (HarassOption.UseW && W.IsReady())
                {
                    var target = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical, true,
                                                          ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                    if (target.IsValidTarget(W.Range) && target.DistanceToPlayer() > Q.Range)
                    {
                        SpellManager.PredCast(W, target);
                    }
                }

                if (HarassOption.UseQ && Q.IsReady())
                {
                    var target = TargetSelector.GetTarget(bigGunRange, TargetSelector.DamageType.Physical, true,
                                                          ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                    if (target.IsValidTarget(bigGunRange) && Orbwalker.CanAttack())
                    {
                        if (target.CountEnemiesInRange(150) >= 2 &&
                            Me.Mana > R.ManaCost + Q.ManaCost * 2 + W.ManaCost && target.DistanceToPlayer() > Q.Range)
                        {
                            Q.Cast();
                        }

                        if (target.DistanceToPlayer() > Q.Range && Me.Mana > R.ManaCost + Q.ManaCost * 2 + W.ManaCost)
                        {
                            Q.Cast();
                        }
                    }
                    else
                    {
                        if (Me.HasBuff("JinxQ") && Q.IsReady())
                        {
                            Q.Cast();
                        }
                    }
                }
                else if (Me.HasBuff("JinxQ") && Q.IsReady())
                {
                    Q.Cast();
                }
            }
        }
Пример #13
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                var target = TargetSelector.GetTarget(QExtend.Range, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                if (target.IsValidTarget(QExtend.Range))
                {
                    if (HarassOption.UseQ && Q.IsReady() && target.IsValidTarget(QExtend.Range))
                    {
                        QLogic(target, HarassOption.GetBool("HarassQ1"));
                    }

                    if (HarassOption.UseE && E.IsReady() && target.IsValidTarget(E.Range))
                    {
                        E.Cast(target.Position, true);
                    }
                }
            }
        }
Пример #14
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

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

                    if (HarassOption.UseE && E.IsReady() && target.IsValidTarget(E.Range) &&
                        target.HasBuff("kalistaexpungemarker"))
                    {
                        var buffcount = target.GetBuffCount("kalistaexpungemarker");

                        if (HarassOption.GetBool("HarassELeave") && target.DistanceToPlayer() >= 800 &&
                            target.IsValidTarget(E.Range) &&
                            buffcount >= HarassOption.GetSlider("HarassECount"))
                        {
                            E.Cast(true);
                        }

                        if (HarassOption.GetBool("HarassESlow"))
                        {
                            var EKillMinion = MinionManager.GetMinions(Me.Position, E.Range, MinionTypes.All,
                                                                       MinionTeam.NotAlly)
                                              .FirstOrDefault(x => x.HasBuff("kalistaexpungemarker") &&
                                                              x.DistanceToPlayer() <= E.Range && x.Health < GetRealEDamage(x));

                            if (EKillMinion != null && EKillMinion.DistanceToPlayer() <= E.Range &&
                                target.IsValidTarget(E.Range))
                            {
                                E.Cast(true);
                            }
                        }
                    }
                }
            }
        }
Пример #15
0
        private static void Harass()
        {
            if (HarassOption.HasEnouguMana)
            {
                var target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical, true, ObjectManager.Heroes.Enemies.Where(x => !HarassOption.GetHarassTarget(x.ChampionName)));

                if (target.IsValidTarget(E.Range) && !target.IsDead && !target.IsZombie)
                {
                    if (HarassOption.UseE && E.IsReady() && target.IsValidTarget(E.Range))
                    {
                        E.Cast(target);
                    }

                    if (HarassOption.UseW && W.IsReady() && target.IsValidTarget(W.Range))
                    {
                        W.Cast();
                    }

                    if (HarassOption.UseQ && Q.IsReady())
                    {
                        QLogic(target);
                    }
                }
            }
        }