示例#1
0
        private static void AutoSpells(EventArgs args)
        {
            //E
            Edetonation();
            //R
            Actives();
            if (Config.Item("semi-ult").GetValue <KeyBind>().Active)
            {
                var target = TargetSelector.GetTarget(R1.Range, TargetSelector.DamageType.Magical);
                if (target == null || !target.IsValid)
                {
                    return;
                }
                if (R1.IsReady())
                {
                    SpellCast(target, R1.Range, R1, false, 1, false, PredR("prediction.R"));
                }
            }
            if (Config.Item("semi-w").GetValue <KeyBind>().Active)
            {
                var ally = HeroManager.Allies.Where(a => a.IsValid && !a.IsMinion && !a.IsMe).OrderBy(a => a.Distance(Game.CursorPosRaw)).FirstOrDefault();
                if (W1.IsReady())
                {
                    W1.Cast(ally);
                }
            }

            if (Q1.IsReady() && Config.Item("autospells.Q.cc").GetValue <bool>())
            {
                var target = TargetSelector.GetTarget(Q1.Range, TargetSelector.DamageType.Magical);
                if (target == null || !target.IsValid)
                {
                    return;
                }
                var cc = target.HasBuffOfType(BuffType.Snare) ||
                         target.HasBuffOfType(BuffType.Suppression) ||
                         target.HasBuffOfType(BuffType.Taunt) ||
                         target.HasBuffOfType(BuffType.Stun) ||
                         target.HasBuffOfType(BuffType.Charm) ||
                         target.HasBuffOfType(BuffType.Fear);
            }

            if (Q1.IsReady() && Config.Item("autospells.Q.collision").GetValue <bool>())
            {
                var enemies = HeroManager.Enemies.Where(e => e.IsValidTarget(Q1.Range));
                foreach (var enemy in enemies)
                {
                    if (enemy == null)
                    {
                        return;
                    }
                    var collisionobjects = Q1.GetPrediction(enemy).CollisionObjects.Where(c => c.IsEnemy && !c.IsMinion);
                    if (collisionobjects.Count() == 1)
                    {
                        Q1.Cast(enemy);
                    }
                }
            }
        }
示例#2
0
        public static void KS()
        {
            var PacketCast  = SkyLv_AurelionSol.Menu.Item("AurelionSol.PacketCastKS").GetValue <bool>();
            var useIgniteKS = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseIgniteKS").GetValue <bool>();
            var useQKS      = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseQKS").GetValue <bool>();
            var useWKS      = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseWKS").GetValue <bool>();
            var useRKS      = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseRKS").GetValue <bool>();

            foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(target => !target.IsMe && target.Team != ObjectManager.Player.Team))
            {
                if (!target.HasBuff("SionPassiveZombie") && !target.HasBuff("Udying Rage") && !target.HasBuff("JudicatorIntervention"))
                {
                    if (useQKS && Q.IsReady() && target.Health < MathsLib.QDamage(target) && !target.IsDead)
                    {
                        var prediction = Q.GetPrediction(target);
                        if (prediction.Hitchance >= HitChance.High)
                        {
                            Q.Cast(prediction.CastPosition, PacketCast);
                            return;
                        }
                    }

                    if (useWKS && W1.IsReady() && target.Health < W1.GetDamage(target) && !target.IsDead)
                    {
                        if (Player.Distance(target) > W1.Range - 20 && Player.Distance(target) < W1.Range + 20 && MathsLib.isWInLongRangeMode())
                        {
                            W2.Cast(PacketCast);
                            return;
                        }

                        if (Player.Distance(target) > W2.Range - 20 && Player.Distance(target) < W2.Range + 20 && !MathsLib.isWInLongRangeMode())
                        {
                            W1.Cast(PacketCast);
                            return;
                        }
                        return;
                    }

                    if (useRKS && R.IsReady() && target.Health < MathsLib.RDamage(target) && !target.IsDead)
                    {
                        var prediction = R.GetPrediction(target);
                        if (prediction.Hitchance == HitChance.VeryHigh)
                        {
                            R.Cast(prediction.CastPosition, PacketCast);
                            return;
                        }
                        return;
                    }

                    if (useIgniteKS && SkyLv_AurelionSol.IgniteSlot.IsReady() && target.Health < Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) && Player.Distance(target) <= 600 && !target.IsDead && target.IsValidTarget())
                    {
                        Player.Spellbook.CastSpell(SkyLv_AurelionSol.IgniteSlot);
                        return;
                    }
                }
            }
        }
        /// <summary>
        ///     The cast W melee.
        /// </summary>
        private static void CastWMelee()
        {
            var Minions = GameObjects.JungleLarge.Where(x => x.IsValidTarget(W1.Range));

            foreach (var Minion in Minions)
            {
                if (W1.IsReady())
                {
                    W1.Cast();
                }
            }
        }
示例#4
0
        /// <summary>
        ///     The cast W melee.
        /// </summary>
        private static void CastWMelee()
        {
            var target = Variables.TargetSelector.GetTarget(W1.Range, DamageType.Physical);

            if (target != null)
            {
                if (W1.IsReady() && target.IsValidTarget(W1.Range))
                {
                    W1.Cast();
                }
            }
        }
示例#5
0
        /// <summary>
        ///     The cast W melee.
        /// </summary>
        private static void CastWMelee()
        {
            var Minions = GameObjects.EnemyMinions.Where(x => x.IsValidTarget(W1.Range)).ToList();
            var FarmPos = W1.GetCircularFarmLocation(Minions, 300);
            var MinHit  = FarmPos.MinionsHit;

            if (W1.IsReady())
            {
                if (MinHit >= LaneHammerWHit.Value)
                {
                    W1.Cast();
                }
            }
        }
示例#6
0
        private static void OnAttack(AttackableUnit unit, AttackableUnit target)
        {
            if (realcdSW > 0)
            {
                return;
            }
            if (!unit.IsMe || unit.Name.Contains("elisespiderling"))
            {
                return;
            }

            var aaDelay = Player.AttackDelay * 200 + Game.Ping / 2f;

            if (Config.Item("wCombo").GetValue <bool>())
            {
                if (target.Type == GameObjectType.AIHeroClient &&
                    _orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
                {
                    LeagueSharp.Common.Utility.DelayAction.Add((int)aaDelay, () => W1.Cast());
                }
            }

            if (Config.Item("wHarass").GetValue <bool>())
            {
                if (target.Type == GameObjectType.AIHeroClient &&
                    _orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed)
                {
                    LeagueSharp.Common.Utility.DelayAction.Add((int)aaDelay, () => W1.Cast());
                }
            }

            if (_orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
            {
                if (Config.Item("jungleclear.w.spider").GetValue <bool>() &&
                    target.Type == GameObjectType.NeutralMinionCamp)
                {
                    LeagueSharp.Common.Utility.DelayAction.Add((int)aaDelay, () => W1.Cast());
                }

                if (Config.Item("laneclear.w.spider").GetValue <bool>() &&
                    target.Type == GameObjectType.obj_AI_Minion)
                {
                    LeagueSharp.Common.Utility.DelayAction.Add((int)aaDelay, () => W1.Cast());
                }
            }
        }
示例#7
0
        public static void OnAttack(AttackableUnit target, EventArgs args)
        {
            if (realcdSW > 0)
            {
                return;
            }
            if (!target.IsMe || target.Name.Contains("elisespiderling"))
            {
                return;
            }

            var aaDelay = Player.AttackDelay * 200 + Game.Ping / 2f;

            if (getCheckBoxItem(comboMenu, "wCombo"))
            {
                if (target.Type == GameObjectType.AIHeroClient &&
                    Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
                {
                    Utility.DelayAction.Add((int)aaDelay, () => W1.Cast());
                }
            }

            if (getCheckBoxItem(harassMenu, "wHarass"))
            {
                if (target.Type == GameObjectType.AIHeroClient &&
                    Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
                {
                    Utility.DelayAction.Add((int)aaDelay, () => W1.Cast());
                }
            }

            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
            {
                if (getCheckBoxItem(jungleClearMenu, "jungleclear.w.spider") &&
                    target.Type == GameObjectType.NeutralMinionCamp)
                {
                    Utility.DelayAction.Add((int)aaDelay, () => W1.Cast());
                }

                if (getCheckBoxItem(laneClearMenu, "laneclear.w.spider") &&
                    target.Type == GameObjectType.obj_AI_Minion)
                {
                    Utility.DelayAction.Add((int)aaDelay, () => W1.Cast());
                }
            }
        }
示例#8
0
        public static void JungleClearLogic()
        {
            var PacketCast = SkyLv_AurelionSol.Menu.Item("AurelionSol.UsePacketCastJungleClear").GetValue <bool>();
            var useQ       = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseQJungleClear").GetValue <bool>();
            var useW       = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseWJungleClear").GetValue <bool>();

            var MiniManaQ = SkyLv_AurelionSol.Menu.Item("AurelionSol.QMiniManaJungleClear").GetValue <Slider>().Value;
            var MiniManaW = SkyLv_AurelionSol.Menu.Item("AurelionSol.WMiniManaJungleClear").GetValue <Slider>().Value;

            var MinionN = MinionManager.GetMinions(Q.Range + 200, MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth).FirstOrDefault();

            if (MinionN.IsValidTarget() && SkyLv_AurelionSol.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
            {
                if (SkyLv_AurelionSol.Menu.Item("AurelionSol.SafeJungleClear").GetValue <bool>() && Player.CountEnemiesInRange(1500) > 0)
                {
                    return;
                }

                if (useQ && Player.ManaPercent > MiniManaQ && Q.IsReady())
                {
                    var prediction = Q.GetPrediction(MinionN);
                    if (prediction.Hitchance == HitChance.VeryHigh)
                    {
                        Q.Cast(prediction.CastPosition, PacketCast);
                    }
                }

                if (useW && W1.IsReady() && Player.ManaPercent > MiniManaW)
                {
                    if (Player.ManaPercent <= MiniManaW && MathsLib.isWInLongRangeMode())
                    {
                        W2.Cast(PacketCast);
                    }

                    if (Player.Distance(MinionN) > W1.Range - 20 && Player.Distance(MinionN) < W1.Range + 20 && MathsLib.isWInLongRangeMode())
                    {
                        W2.Cast(PacketCast);
                    }

                    if (Player.Distance(MinionN) > W2.Range - 20 && Player.Distance(MinionN) < W2.Range + 20 && !MathsLib.isWInLongRangeMode() && Player.ManaPercent > MiniManaW)
                    {
                        W1.Cast(PacketCast);
                    }
                }
            }
        }
示例#9
0
        private static void doHarass()
        {
            var Target    = SimpleTs.GetTarget(Q1.Range, SimpleTs.DamageType.Magical);
            var OrbTarget = LXOrbwalker.GetPossibleTarget();

            if (!IsCougar && (OrbTarget == null || !OrbTarget.IsMinion))
            {
                if (Q1.IsReady() && Config.Item("harass_Q1").GetValue <bool>())
                {
                    Q1.Cast(Target, PacketCasting);
                }

                if (W1.IsReady() && Config.Item("harass_W1").GetValue <bool>())
                {
                    W1.Cast(Target, PacketCasting);
                }
            }
        }
示例#10
0
文件: Combo.cs 项目: wade1990/PortAIO
        public static void ComboLogic()
        {
            var PacketCast            = SkyLv_AurelionSol.Menu.Item("AurelionSol.UsePacketCastCombo").GetValue <bool>();
            var useQ                  = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseQCombo").GetValue <bool>();
            var useW                  = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseWCombo").GetValue <bool>();
            var useR                  = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseRCombo").GetValue <bool>();
            var MinimumEnemyHitComboR = SkyLv_AurelionSol.Menu.Item("AurelionSol.MinimumEnemyHitComboR").GetValue <Slider>().Value;

            if (SkyLv_AurelionSol.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
            {
                var target = TargetSelector.GetTarget(W2.Range + 50, TargetSelector.DamageType.Magical);

                if (target.IsValidTarget())
                {
                    if (useR && R.IsReady() && Player.Mana >= R.ManaCost)
                    {
                        R.CastIfWillHit(target, MinimumEnemyHitComboR, PacketCast);
                    }

                    if (useQ && Q.IsReady() && Player.Mana >= Q.ManaCost)
                    {
                        Q.CastIfHitchanceEquals(target, HitChance.VeryHigh, PacketCast);
                    }

                    if (useW)
                    {
                        if (target.Distance(Player) <= W1.Range + 50 && CustomLib.isWInLongRangeMode())
                        {
                            W2.Cast(PacketCast);
                        }

                        if (target.Distance(Player) > W1.Range + 50 && target.Distance(Player) < W2.Range + 50 && !CustomLib.isWInLongRangeMode())
                        {
                            W1.Cast(PacketCast);
                        }

                        else if (CustomLib.enemyChampionInRange(900) == 0 && CustomLib.isWInLongRangeMode())
                        {
                            W2.Cast(PacketCast);
                        }
                    }
                }
            }
        }
示例#11
0
        public static void ComboLogic()
        {
            var PacketCast = SkyLv_AurelionSol.Menu.Item("AurelionSol.UsePacketCastCombo").GetValue <bool>();
            var useQ       = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseQCombo").GetValue <bool>();
            var useW       = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseWCombo").GetValue <bool>();



            if (SkyLv_AurelionSol.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
            {
                var target = TargetSelector.GetTarget(W2.Range + 50, TargetSelector.DamageType.Magical);

                if (target != null)
                {
                    if (useQ && Q.IsReady())
                    {
                        var prediction = Q.GetPrediction(target);
                        if (prediction.Hitchance >= HitChance.High)
                        {
                            Q.Cast(prediction.CastPosition, PacketCast);
                        }
                    }

                    if (useW)
                    {
                        if (target.Distance(Player) <= W1.Range + 50 && MathsLib.isWInLongRangeMode())
                        {
                            W2.Cast(PacketCast);
                        }

                        if (target.Distance(Player) > W1.Range + 50 && target.Distance(Player) < W2.Range + 50 && !MathsLib.isWInLongRangeMode())
                        {
                            W1.Cast(PacketCast);
                        }

                        else if (MathsLib.enemyChampionInRange(600 + 300) == 0 && MathsLib.isWInLongRangeMode())
                        {
                            W2.Cast(PacketCast);
                        }
                    }
                }
            }
        }
示例#12
0
        public static void HarassLogic()
        {
            var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);

            if (target != null)
            {
                var PacketCast = SkyLv_AurelionSol.Menu.Item("AurelionSol.UsePacketCastHarass").GetValue <bool>();

                var useQ      = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseQHarass").GetValue <bool>();
                var MiniManaQ = SkyLv_AurelionSol.Menu.Item("AurelionSol.QMiniManaHarass").GetValue <Slider>().Value;

                var useW      = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseWHarass").GetValue <bool>();
                var MiniManaW = SkyLv_AurelionSol.Menu.Item("AurelionSol.WMiniManaHarass").GetValue <Slider>().Value;

                if (useQ && Q.IsReady() && Player.Mana >= Q.ManaCost && Player.ManaPercent > MiniManaQ)
                {
                    var prediction = Q.GetPrediction(target);
                    if (prediction.Hitchance >= HitChance.High)
                    {
                        Q.Cast(prediction.CastPosition, PacketCast);
                    }
                }

                if (useW && W1.IsReady() && Player.ManaPercent > MiniManaW)
                {
                    if (Player.ManaPercent <= MiniManaW && MathsLib.isWInLongRangeMode())
                    {
                        W2.Cast(PacketCast);
                    }

                    if (Player.Distance(target) > W1.Range - 20 && Player.Distance(target) < W1.Range + 20 && MathsLib.isWInLongRangeMode())
                    {
                        W2.Cast(PacketCast);
                    }

                    if (Player.Distance(target) > W2.Range - 20 && Player.Distance(target) < W2.Range + 20 && !MathsLib.isWInLongRangeMode() && Player.ManaPercent > MiniManaW)
                    {
                        W1.Cast(PacketCast);
                    }
                }
            }
        }
示例#13
0
        public void manageW()
        {
            var target = ARAMTargetSelector.getBestTarget(1400f);

            if (target == null)
            {
                return;
            }
            if (!player.IsBurrowed())
            {
                if (W1.IsReady() &&
                    player.HealthPercent < 9 &&
                    player.Mana > 0)
                {
                    W1.Cast();
                }

                if (W1.IsReady() &&
                    !player.QActive())
                {
                    W1.Cast();
                }

                if (!E1.IsInRange(target) &&
                    player.Distance(target.Position) < E2.Range &&
                    W1.IsReady())
                {
                    W1.Cast();
                }
            }
            else if (player.IsBurrowed())
            {
                if (W2.IsReady() &&
                    player.IsUnder(target))
                {
                    W2.Cast();
                }
            }
        }
示例#14
0
        public static void KS()
        {
            var PacketCast  = SkyLv_AurelionSol.Menu.Item("AurelionSol.PacketCastKS").GetValue <bool>();
            var UseIgniteKS = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseIgniteKS").GetValue <bool>();
            var UseQKS      = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseQKS").GetValue <bool>();
            var UseWKS      = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseWKS").GetValue <bool>();
            var UseRKS      = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseRKS").GetValue <bool>();

            foreach (var target in ObjectManager.Get <AIHeroClient>().Where(target => !target.IsMe && !target.IsDead && target.Team != ObjectManager.Player.Team && !target.IsZombie && (SkyLv_AurelionSol.Ignite.Slot != SpellSlot.Unknown || !target.HasBuff("summonerdot"))))
            {
                if (UseQKS && Player.Distance(target) <= Q.Range && Q.IsReady() && target.Health < CustomLib.QDamage(target) && Player.Mana >= Q.ManaCost)
                {
                    Q.CastIfHitchanceEquals(target, HitChance.VeryHigh, PacketCast);
                }

                if (UseWKS && W1.IsReady() && target.Health < W1.GetDamage(target))
                {
                    if (Player.Distance(target) > W1.Range - 20 && Player.Distance(target) < W1.Range + 20 && CustomLib.isWInLongRangeMode())
                    {
                        W2.Cast(PacketCast);
                    }

                    if (Player.Distance(target) > W2.Range - 20 && Player.Distance(target) < W2.Range + 20 && !CustomLib.isWInLongRangeMode())
                    {
                        W1.Cast(PacketCast);
                    }
                }

                if (UseRKS && Player.Distance(target) <= R.Range && R.IsReady() && target.Health < CustomLib.RDamage(target) && Player.Mana >= R.ManaCost)
                {
                    R.CastIfHitchanceEquals(target, HitChance.VeryHigh, PacketCast);
                }

                if (UseIgniteKS && SkyLv_AurelionSol.Ignite.Slot != SpellSlot.Unknown && target.Health < Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) && Player.Distance(target) <= SkyLv_AurelionSol.Ignite.Range)
                {
                    SkyLv_AurelionSol.Ignite.Cast(target, true);
                }
            }
        }
示例#15
0
        private static void Wlogic(AIBaseClient sender, AIBaseClientProcessSpellCastEventArgs args)
        {
            try
            {
                if (sender.IsMe || sender == null || !sender.IsEnemy || sender.IsMinion || W1.Level < 1 || !sender.IsValid || !Config.Item("combo.W").GetValue <bool>() || Player.IsWindingUp)
                {
                    return;
                }
                var lowestally = HeroManager.Allies.Where(a => !a.IsDead && a.IsValidTarget(W1.Range) && a.IsValid && !a.IsMe).OrderBy(a => a.Health).FirstOrDefault();

                //Will Prioritize W cast on Allies
                if (args.Target.IsMe && W1.IsReady() && lowestally == null && sender.IsEnemy)
                {
                    W1.Cast(Game.CursorPosRaw);
                }

                if (lowestally.Distance(Player.Position) > W1.Range)
                {
                    return;
                }

                if (args.Target.IsMe && lowestally != null && W1.IsReady() && sender.IsEnemy)
                {
                    W1.Cast(lowestally);
                }

                //Ally Receiving Damage
                if (args.Target.Position.Distance(player.Position) <= W1.Range && args.Target.IsAlly && sender.IsEnemy && lowestally != null)
                {
                    W1.Cast(lowestally);
                }
            }
            catch (Exception)
            {
            }
        }
示例#16
0
        private static void AfterAttack(AttackableUnit sender, AttackableUnit ArgsTarget)
        {
            if (!sender.IsMe || Me.IsDead)
            {
                return;
            }

            havePassive = false;

            if (ArgsTarget == null || ArgsTarget.IsDead || ArgsTarget.Health <= 0)
            {
                return;
            }

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

                if (target != null && !target.IsDead)
                {
                    if (ComboOption.GetBool("ComboEReset") && E.IsReady() &&
                        target.IsValidTarget(Me.AttackRange + Me.BoundingRadius))
                    {
                        ELogic(target, 1);
                    }
                    else if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                    {
                        Q.CastOnUnit(target, true);
                    }
                    else if (ComboOption.UseW && W.IsReady() && target.IsValidTarget(W.Range))
                    {
                        if (ComboOption.GetBool("ComboWFast"))
                        {
                            W1.Cast(target.Position, true);
                        }
                        else
                        {
                            var wPred = W.GetPrediction(target);

                            if (wPred.Hitchance >= HitChance.VeryHigh)
                            {
                                W.Cast(wPred.CastPosition, true);
                            }
                        }
                    }
                }
            }
            else
            {
                if (isLaneClearMode && LaneClearOption.HasEnouguMana &&
                    (ArgsTarget.ObjectType == GameObjectType.obj_AI_Turret ||
                     ArgsTarget.ObjectType == GameObjectType.obj_Turret ||
                     ArgsTarget.ObjectType == GameObjectType.obj_HQ ||
                     ArgsTarget.ObjectType == GameObjectType.obj_BarracksDampener))
                {
                    if (LaneClearOption.UseE && E.IsReady())
                    {
                        E.Cast(Me.Position.Extend(Game.CursorPosition, 130), true);
                    }
                    else if (LaneClearOption.UseW && W.IsReady())
                    {
                        W1.Cast(Game.CursorPosition, true);
                    }
                }

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

                    if (mobs.Any())
                    {
                        if (JungleClearOption.UseE && E.IsReady())
                        {
                            E.Cast(Me.Position.Extend(Game.CursorPosition, 130), true);
                        }
                        else if (JungleClearOption.UseQ && Q.IsReady())
                        {
                            Q.CastOnUnit(mobs.FirstOrDefault(), true);
                        }
                        else if (JungleClearOption.UseW && W.IsReady())
                        {
                            W1.Cast(mobs.FirstOrDefault(), true);
                        }
                    }
                }
            }
        }
示例#17
0
        private static void doCombo()
        {
            var Target   = SimpleTs.GetTarget(Q1.Range, SimpleTs.DamageType.Magical);
            var Marked   = Target.HasBuff("nidaleepassivehunted", true);
            var Hunting  = Player.HasBuff("nidaleepassivehunting", true);
            var Distance = Player.Distance(Target);
            var useItems = Config.Item("combo_Items").GetValue <bool>();

            if (useItems)
            {
                if (Items.CanUseItem(Bork.Id))
                {
                    Bork.Cast(Target);
                }
                if (Items.CanUseItem(Cutlass.Id))
                {
                    Cutlass.Cast(Target);
                }
            }

            var comboUT = Config.Item("combo_UT").GetValue <bool>();

            /* Human Form */
            if (!IsCougar)
            {
                if (Marked && R.IsReady() && Config.Item("combo_R").GetValue <bool>() && Distance < 750f ||
                    (!Q1.IsReady() && !Q1.IsReady(2500) && Target.Distance(Player) < 300f) &&
                    (!Utility.UnderTurret(Target, true) || comboUT))
                {
                    R.CastOnUnit(Player, PacketCasting);
                }

                else if (Q1.IsReady() && Config.Item("combo_Q1").GetValue <bool>())
                {
                    Q1.Cast(Target, PacketCasting);
                }

                else if (W1.IsReady() && Config.Item("combo_W1").GetValue <bool>())
                {
                    W1.Cast(Target, PacketCasting);
                }

                else if (E1.IsReady() && Config.Item("combo_E1").GetValue <bool>() &&
                         (!R.IsReady() || !Marked && Distance < W2.Range + 75f))
                {
                    E1.CastOnUnit(Player, PacketCasting);
                }
            }

            /* Cougar Form */
            else
            {
                if (!Marked && R.IsReady() && Config.Item("combo_R").GetValue <bool>() && Distance < W2.Range + 75f)
                {
                    R.CastOnUnit(Player, PacketCasting);
                    return;
                }

                // Deathfire grasp / Blackfire Torch
                var dmg = Q1.GetDamage(Target, 1) + W1.GetDamage(Target, 1) + E1.GetDamage(Target, 1);
                if (Target.IsValidTarget(DFG.Range) && Q1.IsReady() && W1.IsReady() && E1.IsReady() && dmg < Target.Health && (dmg * 1.2f) + (Target.MaxHealth * (DFG.Id == 3188 ? 0.20f : 0.15f)) > Target.Health && useItems)
                {
                    DFG.Cast(Target);
                }

                if (Marked && Hunting && W2.IsReady() && Config.Item("combo_W2").GetValue <bool>() && Distance < 750f &&
                    Distance > 200f && (!Utility
                                        .UnderTurret(Target, true) || comboUT))
                {
                    Player.Spellbook.CastSpell(SpellSlot.W, Target);
                }
                else if (E2.IsReady() && Distance < 300f)
                {
                    var Pred = Prediction.GetPrediction(Target, 0.5f);
                    E2.Cast(Pred.CastPosition, PacketCasting);
                }
            }
        }
示例#18
0
        public static void LaneClearLogic()
        {
            var PacketCast = SkyLv_AurelionSol.Menu.Item("AurelionSol.UsePacketCastLaneClear").GetValue <bool>();

            var useQ = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseQLaneClear").GetValue <bool>();
            var useW = SkyLv_AurelionSol.Menu.Item("AurelionSol.UseWLaneClear").GetValue <bool>();

            var MiniManaQ = SkyLv_AurelionSol.Menu.Item("AurelionSol.QMiniManaLaneClear").GetValue <Slider>().Value;
            var MiniManaW = SkyLv_AurelionSol.Menu.Item("AurelionSol.WMiniManaLaneClear").GetValue <Slider>().Value;

            var MiniCountQ = SkyLv_AurelionSol.Menu.Item("AurelionSol.QLaneClearCount").GetValue <Slider>().Value;
            var MiniCountW = SkyLv_AurelionSol.Menu.Item("AurelionSol.WLaneClearCount").GetValue <Slider>().Value;

            var Minion = MinionManager.GetMinions(Q.Range, MinionTypes.All, MinionTeam.Enemy).FirstOrDefault();

            if (Minion.IsValidTarget() && SkyLv_AurelionSol.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
            {
                if (SkyLv_AurelionSol.Menu.Item("AurelionSol.SafeLaneClear").GetValue <bool>() && Player.CountEnemiesInRange(1500) > 0)
                {
                    return;
                }

                if (useQ && Player.ManaPercent > MiniManaQ && Q.IsReady())
                {
                    var allMinionsQ = MinionManager.GetMinions(Player.Position, Q.Range, MinionTypes.All, MinionTeam.Enemy);

                    if (allMinionsQ.Any())
                    {
                        var farmAll = Q.GetCircularFarmLocation(allMinionsQ, Q.Width);
                        if (farmAll.MinionsHit >= MiniCountQ)
                        {
                            Q.Cast(farmAll.Position, true);
                        }
                    }
                }

                if (useW && W1.IsReady())
                {
                    var allMinionsW1 = MinionManager.GetMinions(Player.Position + W1.Range - 20, W1.Range + 20, MinionTypes.All, MinionTeam.Enemy);
                    var allMinionsW2 = MinionManager.GetMinions(Player.Position + W2.Range - 20, W2.Range + 20, MinionTypes.All, MinionTeam.Enemy);

                    if (Player.ManaPercent <= MiniManaW && MathsLib.isWInLongRangeMode())
                    {
                        W2.Cast(PacketCast);
                    }

                    if (allMinionsW1.Any() && MathsLib.isWInLongRangeMode())
                    {
                        var farmAll = W1.GetCircularFarmLocation(allMinionsW1);
                        if (farmAll.MinionsHit >= MiniCountW)
                        {
                            W2.Cast(PacketCast);
                        }
                    }

                    if (allMinionsW2.Any() && !MathsLib.isWInLongRangeMode() && Player.ManaPercent > MiniManaW)
                    {
                        var farmAll = W2.GetCircularFarmLocation(allMinionsW2);
                        if (farmAll.MinionsHit >= MiniCountW)
                        {
                            W1.Cast(PacketCast);
                        }
                    }
                }
            }
        }
示例#19
0
        public override void OnJungleClear()
        {
            var minions = EntityManager.MinionsAndMonsters.Monsters.Where(t => t.IsValidTarget(spiderForm ? E2.Range : E1.Range));

            var jungleclear = Features.Find(f => f.NameFeature == "Jungle Clear");

            if (minions == null || !minions.Any(t => t.IsValidTarget(spiderForm ? E2.Range : E1.Range)) || jungleclear.SliderValue("jungleclear.mana") > Player.Instance.ManaPercent)
            {
                return;
            }

            var target = minions.Aggregate((curMax, x) => ((curMax == null && x.IsValid) || x.MaxHealth > curMax.MaxHealth ? x : curMax));

            if (!target.IsValidTarget(spiderForm ? E2.Range : E1.Range))
            {
                target = minions.FirstOrDefault();
            }

            if (spiderForm)
            {
                if (R.IsReady() && jungleclear.IsChecked("jungleclear.r"))
                {
                    if (W1.IsReady() && Q1.IsReady())
                    {
                        R.Cast();
                    }
                }

                if (Q2.IsReady() && jungleclear.IsChecked("jungleclear.q2") && Q2.IsInRange(target))
                {
                    Q2.Cast(target);
                }

                if (W2.IsReady() && jungleclear.IsChecked("jungleclear.w2") && Player.Instance.IsInAutoAttackRange(target))
                {
                    W2.Cast();
                }
            }
            else
            {
                if (R.IsReady() && jungleclear.IsChecked("jungleclear.r"))
                {
                    if (!Q1.IsReady() && !W1.IsReady())
                    {
                        if (W1.IsReady() && jungleclear.IsChecked("jungleclear.w") && W1.IsInRange(target))
                        {
                            W1.Cast(target.Position);
                            EloBuddy.SDK.Core.DelayAction(() => R.Cast(), 250);
                        }
                        else
                        {
                            R.Cast();
                        }
                    }
                }

                if (Q1.IsReady() && jungleclear.IsChecked("jungleclear.q") && Q1.IsInRange(target))
                {
                    Q1.Cast(target);
                }

                if (W1.IsReady() && jungleclear.IsChecked("jungleclear.w") && W1.IsInRange(target))
                {
                    W1.Cast(target.Position);
                }
            }
        }
示例#20
0
        public override void OnHarass()
        {
            var target = TargetSelector.GetTarget(spiderForm ? E2.Range : E1.Range, DamageType.Magical);

            var harass = Features.Find(f => f.NameFeature == "Harass");

            if (target == null || !target.IsValidTarget(1000) || harass.SliderValue("harass.mana") > Player.Instance.ManaPercent)
            {
                return;
            }

            if (spiderForm)
            {
                if (R.IsReady() && harass.IsChecked("harass.r"))
                {
                    if (!W2.IsReady() && !Q2.IsReady() && !Player.Instance.IsInAutoAttackRange(target))
                    {
                        R.Cast();
                    }
                }

                if (Q2.IsReady() && harass.IsChecked("harass.q2") && Q2.IsInRange(target))
                {
                    Q2.Cast(target);
                }

                if (E2.IsReady() && harass.IsChecked("harass.e2") && E2.IsInRange(target) && !Q2.IsInRange(target))
                {
                    E2.Cast(target);
                }

                if (W2.IsReady() && harass.IsChecked("harass.w2") && Player.Instance.IsInAutoAttackRange(target))
                {
                    W2.Cast();
                }
            }
            else
            {
                if (R.IsReady() && harass.IsChecked("harass.r"))
                {
                    if (!Q1.IsReady() && !E1.IsReady())
                    {
                        if (W1.IsReady() && harass.IsChecked("harass.w") && W1.IsInRange(target))
                        {
                            W1.Cast(W1.GetPrediction(target).CastPosition);
                            EloBuddy.SDK.Core.DelayAction(() => R.Cast(), 250);
                        }
                        else
                        {
                            R.Cast();
                        }
                    }
                }

                if (E1.IsReady() && harass.IsChecked("harass.e") && E1.IsInRange(target))
                {
                    SpellsUtil.HitChanceCast(E1, target);
                }

                if (Q1.IsReady() && harass.IsChecked("harass.q") && Q1.IsInRange(target))
                {
                    Q1.Cast(target);
                }

                if (W1.IsReady() && harass.IsChecked("harass.w") && W1.IsInRange(target))
                {
                    W1.Cast(W1.GetPrediction(target).CastPosition);
                }
            }
        }
示例#21
0
        public override void OnCombo()
        {
            var target = TargetSelector.GetTarget(spiderForm ? E2.Range : E1.Range, DamageType.Magical);

            if (target == null || !target.IsValidTarget())
            {
                return;
            }

            var combo = Features.Find(f => f.NameFeature == "Combo");

            if (spiderForm)
            {
                if (R.IsReady() && combo.IsChecked("combo.r"))
                {
                    if (W1.IsReady() && Q1.IsReady() && E1.IsReady())
                    {
                        R.Cast();
                    }
                }

                if (Q2.IsReady() && combo.IsChecked("combo.q2") && Q2.IsInRange(target))
                {
                    Q2.Cast(target);
                }

                if (E2.IsReady() && combo.IsChecked("combo.e2") && E2.IsInRange(target) && !Q2.IsInRange(target))
                {
                    E2.Cast(target);
                }

                if (W2.IsReady() && combo.IsChecked("combo.w2") && Player.Instance.IsInAutoAttackRange(target))
                {
                    W2.Cast();
                }
            }
            else
            {
                if (R.IsReady() && combo.IsChecked("combo.r"))
                {
                    if (!Q1.IsReady())
                    {
                        if (W1.IsReady() && combo.IsChecked("combo.w") && W1.IsInRange(target))
                        {
                            W1.Cast(W1.GetPrediction(target).CastPosition);
                            EloBuddy.SDK.Core.DelayAction(() => R.Cast(), 250);
                        }
                        else
                        {
                            R.Cast();
                        }
                    }
                }

                if (E1.IsReady() && combo.IsChecked("combo.e") && E1.IsInRange(target))
                {
                    SpellsUtil.HitChanceCast(E1, target);
                }

                if (Q1.IsReady() && combo.IsChecked("combo.q") && Q1.IsInRange(target))
                {
                    Q1.Cast(target);
                }
            }
        }