Beispiel #1
0
        public static void AutoR()
        {
            var MinimumHpSafeAutoR = SkyLv_Taric.Menu.Item("Taric.MinimumHpSafeAutoR").GetValue <Slider>().Value;
            var PacketCast         = SkyLv_Taric.Menu.Item("Taric.UsePacketCastCombo").GetValue <bool>();

            if (R.IsReady() && Player.Mana >= R.ManaCost && CustomLib.enemyChampionInPlayerRange(700) > 0 && Player.HealthPercent <= MinimumHpSafeAutoR)
            {
                R.Cast(Player, PacketCast);
            }
        }
Beispiel #2
0
        public static void LaneClearLogic()
        {
            var PacketCast = SkyLv_Taric.Menu.Item("Taric.UsePacketCastLaneClear").GetValue <bool>();

            var UseQLaneClear = SkyLv_Taric.Menu.Item("Taric.UseQLaneClear").GetValue <bool>();
            var UseWLaneClear = SkyLv_Taric.Menu.Item("Taric.UseWLaneClear").GetValue <bool>();
            var UseELaneClear = SkyLv_Taric.Menu.Item("Taric.UseELaneClear").GetValue <bool>();

            var QMiniManaLaneClear = SkyLv_Taric.Menu.Item("Taric.QMiniManaLaneClear").GetValue <Slider>().Value;
            var WMiniManaLaneClear = SkyLv_Taric.Menu.Item("Taric.WMiniManaLaneClear").GetValue <Slider>().Value;
            var EMiniManaLaneClear = SkyLv_Taric.Menu.Item("Taric.EMiniManaLaneClear").GetValue <Slider>().Value;

            var QMiniMinimionAroundLaneClear = SkyLv_Taric.Menu.Item("Taric.QMiniMinimionAroundLaneClear").GetValue <Slider>().Value;
            var WMiniMinimionAroundLaneClear = SkyLv_Taric.Menu.Item("Taric.WMiniMinimionAroundLaneClear").GetValue <Slider>().Value;
            var EMiniHitLaneClear            = SkyLv_Taric.Menu.Item("Taric.EMiniHitLaneClear").GetValue <Slider>().Value;

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

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

                if (UseELaneClear && Player.ManaPercent > EMiniManaLaneClear && E.IsReady() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveLaneClear").GetValue <bool>()))
                {
                    var allMinionsE = MinionManager.GetMinions(Player.Position, E.Range, MinionTypes.All, MinionTeam.Enemy);

                    if (allMinionsE.Any())
                    {
                        var farmAll = Q.GetLineFarmLocation(allMinionsE, 150f);
                        if (farmAll.MinionsHit >= EMiniHitLaneClear)
                        {
                            E.Cast(farmAll.Position, PacketCast);
                            return;
                        }
                    }
                }

                if (UseWLaneClear && CustomLib.EnemyMinionInPlayerRange(E.Range) >= WMiniMinimionAroundLaneClear && Player.ManaPercent > WMiniManaLaneClear && W.IsReady() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveLaneClear").GetValue <bool>()) && (!E.IsReady() || !UseELaneClear))
                {
                    W.Cast(Player, PacketCast);
                    return;
                }

                if (UseQLaneClear && CustomLib.EnemyMinionInPlayerRange(E.Range) >= QMiniMinimionAroundLaneClear && Player.ManaPercent > QMiniManaLaneClear && Q.IsReady() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveLaneClear").GetValue <bool>()) && (!E.IsReady() || !UseELaneClear) && (Player.HealthPercent < 100 || (!W.IsReady() || !UseWLaneClear)))
                {
                    Q.Cast(Player, PacketCast);
                    return;
                }
            }
        }
Beispiel #3
0
        public static void AutoR()
        {
            var PacketCast            = getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UsePacketCast");
            var MinimumHpSafeAutoR    = getSliderItem(SkyLv_Taric.Combo, "Taric.MinimumHpSafeAutoR");
            var MinimumEnemySafeAutoR = getSliderItem(SkyLv_Taric.Combo, "Taric.MinimumEnemySafeAutoR");

            if (Player.LSIsRecalling())
            {
                return;
            }

            if (R.IsReady() && Player.Mana >= R.ManaCost && CustomLib.enemyChampionInPlayerRange(800) >= MinimumEnemySafeAutoR && Player.HealthPercent <= MinimumHpSafeAutoR)
            {
                R.Cast(Player, PacketCast);
            }
        }
Beispiel #4
0
        public static void AutoW()
        {
            var PacketCast            = SkyLv_Taric.Menu.Item("Taric.UsePacketCast").GetValue <bool>();
            var MinimumHpSafeAutoW    = SkyLv_Taric.Menu.Item("Taric.MinimumHpSafeAutoW").GetValue <Slider>().Value;
            var MinimumEnemySafeAutoW = SkyLv_Taric.Menu.Item("Taric.MinimumEnemySafeAutoW").GetValue <Slider>().Value;

            if (Player.IsRecalling())
            {
                return;
            }

            if (W.IsReady() && Player.Mana >= W.ManaCost && CustomLib.enemyChampionInPlayerRange(800) >= MinimumEnemySafeAutoW && Player.HealthPercent <= MinimumHpSafeAutoW)
            {
                W.Cast(Player, PacketCast);
            }
        }
Beispiel #5
0
        public static void ComboLogic()
        {
            var PacketCast = SkyLv_Taric.Menu.Item("Taric.UsePacketCastCombo").GetValue <bool>();
            var useQ       = SkyLv_Taric.Menu.Item("Taric.UseQCombo").GetValue <bool>();
            var useW       = SkyLv_Taric.Menu.Item("Taric.UseWCombo").GetValue <bool>();
            var useE       = SkyLv_Taric.Menu.Item("Taric.UseECombo").GetValue <bool>();

            if (SkyLv_Taric.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
            {
                var target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);

                if (target.IsValidTarget())
                {
                    if (useE && E.IsReady() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveCombo").GetValue <bool>()))
                    {
                        if (Player.Distance(target) < E.Range)
                        {
                            E.CastIfHitchanceEquals(target, HitChance.VeryHigh, PacketCast);
                            return;
                        }
                    }

                    if (useW && W.IsReady() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveCombo").GetValue <bool>()) && (!E.IsReady() || !useE))
                    {
                        W.Cast(Player, PacketCast);
                        return;
                    }

                    if (useQ && Q.IsReady() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveCombo").GetValue <bool>()) && (!E.IsReady() || !useE) && (Player.HealthPercent < 100 || (!W.IsReady() || !useW)))
                    {
                        Q.Cast(Player, PacketCast);
                        return;
                    }
                }
            }
        }
Beispiel #6
0
        public static void JungleClearLogic()
        {
            var PacketCast = SkyLv_Taric.Menu.Item("Taric.UsePacketCastJungleClear").GetValue <bool>();
            var useQ       = SkyLv_Taric.Menu.Item("Taric.UseQJungleClear").GetValue <bool>();
            var useW       = SkyLv_Taric.Menu.Item("Taric.UseWJungleClear").GetValue <bool>();
            var useE       = SkyLv_Taric.Menu.Item("Taric.UseEJungleClear").GetValue <bool>();

            var MiniManaQ = SkyLv_Taric.Menu.Item("Taric.QMiniManaJungleClear").GetValue <Slider>().Value;
            var MiniManaW = SkyLv_Taric.Menu.Item("Taric.WMiniManaJungleClear").GetValue <Slider>().Value;
            var MiniManaE = SkyLv_Taric.Menu.Item("Taric.EMiniManaJungleClear").GetValue <Slider>().Value;

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

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

                if (useE && E.IsReady() && Player.ManaPercent > MiniManaE)
                {
                    if (SkyLv_Taric.Menu.Item("Taric.SpellOnlyBigMonster").GetValue <bool>())
                    {
                        foreach (var target in ObjectManager.Get <Obj_AI_Base>().Where(target => SkyLv_Taric.Monsters.Contains(target.BaseSkinName) && !target.IsDead))
                        {
                            if (target.IsValidTarget() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveJungleClear").GetValue <bool>()))
                            {
                                E.CastIfHitchanceEquals(target, HitChance.VeryHigh, PacketCast);
                            }
                        }
                    }
                    else if (!SkyLv_Taric.Menu.Item("Taric.SpellOnlyBigMonster").GetValue <bool>() && MinionN.IsValidTarget() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveJungleClear").GetValue <bool>()))
                    {
                        E.CastIfHitchanceEquals(MinionN, HitChance.VeryHigh, PacketCast);
                    }
                }

                if (useW && W.IsReady() && Player.ManaPercent > MiniManaW && (!E.IsReady() || !useE))
                {
                    if (SkyLv_Taric.Menu.Item("Taric.SpellOnlyBigMonster").GetValue <bool>())
                    {
                        foreach (var target in ObjectManager.Get <Obj_AI_Base>().Where(target => SkyLv_Taric.Monsters.Contains(target.BaseSkinName) && !target.IsDead))
                        {
                            if (target.IsValidTarget() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveJungleClear").GetValue <bool>()))
                            {
                                W.Cast(Player, PacketCast);
                            }
                        }
                    }
                    else if (!SkyLv_Taric.Menu.Item("Taric.SpellOnlyBigMonster").GetValue <bool>() && MinionN.IsValidTarget() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveJungleClear").GetValue <bool>()))
                    {
                        W.Cast(Player, PacketCast);
                    }
                }

                if (useQ && Q.IsReady() && Player.ManaPercent > MiniManaQ && (!E.IsReady() || !useE) && (!W.IsReady() || !useW))
                {
                    if (SkyLv_Taric.Menu.Item("Taric.SpellOnlyBigMonster").GetValue <bool>())
                    {
                        foreach (var target in ObjectManager.Get <Obj_AI_Base>().Where(target => SkyLv_Taric.Monsters.Contains(target.BaseSkinName) && !target.IsDead))
                        {
                            if (target.IsValidTarget() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveJungleClear").GetValue <bool>()))
                            {
                                Q.Cast(Player, PacketCast);
                            }
                        }
                    }
                    else if (!SkyLv_Taric.Menu.Item("Taric.SpellOnlyBigMonster").GetValue <bool>() && MinionN.IsValidTarget() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveJungleClear").GetValue <bool>()))
                    {
                        Q.Cast(Player, PacketCast);
                    }
                }
            }
        }
Beispiel #7
0
        public static void HarassLogic()
        {
            var PacketCast = SkyLv_Taric.Menu.Item("Taric.UsePacketCast").GetValue <bool>();
            var UseQHarass = SkyLv_Taric.Menu.Item("Taric.UseQHarass").GetValue <bool>();
            var UseWHarass = SkyLv_Taric.Menu.Item("Taric.UseWHarass").GetValue <bool>();
            var UseEHarass = SkyLv_Taric.Menu.Item("Taric.UseEHarass").GetValue <bool>();

            var QMiniManaHarass = SkyLv_Taric.Menu.Item("Taric.QMiniManaHarass").GetValue <Slider>().Value;
            var WMiniManaHarass = SkyLv_Taric.Menu.Item("Taric.WMiniManaHarass").GetValue <Slider>().Value;
            var EMiniManaHarass = SkyLv_Taric.Menu.Item("Taric.EMiniManaHarass").GetValue <Slider>().Value;

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

            if (target.IsValidTarget())
            {
                if (UseEHarass && Player.ManaPercent > EMiniManaHarass && E.IsReady() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveHarass").GetValue <bool>()))
                {
                    if (Player.Distance(target) < E.Range)
                    {
                        E.CastIfHitchanceEquals(target, HitChance.VeryHigh, PacketCast);
                        return;
                    }
                }

                if (UseWHarass && Player.ManaPercent > WMiniManaHarass && W.IsReady() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveHarass").GetValue <bool>()) && (!E.IsReady() || !UseEHarass))
                {
                    W.Cast(Player, PacketCast);
                    return;
                }

                if (UseQHarass && Player.ManaPercent > QMiniManaHarass && Q.IsReady() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveHarass").GetValue <bool>()) && (!E.IsReady() || !UseEHarass) && (Player.HealthPercent < 100 || (!W.IsReady() || !UseWHarass)))
                {
                    Q.Cast(Player, PacketCast);
                    return;
                }
            }
        }
Beispiel #8
0
        public static void AntiGapcloser_OnEnemyGapcloser(ActiveGapcloser gapcloser)
        {
            var MinimumHpEGapCloser    = getSliderItem(SkyLv_Taric.Combo, "Taric.MinimumHpEGapCloser");
            var MinimumEnemyEGapCloser = getSliderItem(SkyLv_Taric.Combo, "Taric.MinimumEnemyEGapCloser");
            var UseAutoEGapCloser      = getCheckBoxItem(SkyLv_Taric.Combo, "Taric.UseAutoEGapCloser");
            var PacketCast             = getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UsePacketCast");

            if (Player.LSIsRecalling())
            {
                return;
            }

            if (UseAutoEGapCloser && gapcloser.End.LSDistance(Player.ServerPosition) < E.Range && Player.HealthPercent <= MinimumHpEGapCloser && CustomLib.enemyChampionInPlayerRange(800) >= MinimumEnemyEGapCloser)
            {
                E.Cast(gapcloser.End, PacketCast);
            }
        }
Beispiel #9
0
        public static void ComboLogic()
        {
            var PacketCast                 = SkyLv_Taric.Menu.Item("Taric.UsePacketCast").GetValue <bool>();
            var useQ                       = SkyLv_Taric.Menu.Item("Taric.UseQCombo").GetValue <bool>();
            var useW                       = SkyLv_Taric.Menu.Item("Taric.UseWCombo").GetValue <bool>();
            var useE                       = SkyLv_Taric.Menu.Item("Taric.UseECombo").GetValue <bool>();
            var MinimumStackSelfQCombo     = SkyLv_Taric.Menu.Item("Taric.MinimumStackSelfQCombo").GetValue <Slider>().Value;
            var MinimumHpPercentSelfQCombo = SkyLv_Taric.Menu.Item("Taric.MinimumHpPercentSelfQCombo").GetValue <Slider>().Value;

            if (SkyLv_Taric.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
            {
                var target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);

                if (target.IsValidTarget(E.Range))
                {
                    if (useE && E.IsReady() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveCombo").GetValue <bool>() || Player.Distance(target) > Orbwalking.GetRealAutoAttackRange(Player)))
                    {
                        if (Player.Distance(target) < E.Range)
                        {
                            E.CastIfHitchanceEquals(target, HitChance.VeryHigh, PacketCast);
                            return;
                        }
                    }

                    if (target.IsValidTarget(Orbwalking.GetRealAutoAttackRange(Player)))
                    {
                        if (!SkyLv_Taric.Menu.Item("Taric.UseWIncomingDamageCombo").GetValue <bool>() && useW && W.IsReady() && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveCombo").GetValue <bool>()) && (!E.IsReady() || !useE))
                        {
                            W.Cast(Player, PacketCast);
                            return;
                        }

                        if (useQ && Q.IsReady() && Q.Instance.Ammo >= MinimumStackSelfQCombo && Player.HealthPercent <= MinimumHpPercentSelfQCombo && (!CustomLib.HavePassiveAA() || !SkyLv_Taric.Menu.Item("Taric.UseTaricAAPassiveCombo").GetValue <bool>()) && (!E.IsReady() || !useE) && (Player.HealthPercent < 100 || (!W.IsReady() || !useW)))
                        {
                            Q.Cast(Player, PacketCast);
                            return;
                        }
                    }
                }

                #region Ally E
                if (SkyLv_Taric.Menu.Item("Taric.UseEFromAlly").GetValue <bool>() && E.IsReady() && Player.Mana >= E.ManaCost)
                {
                    foreach (var AllyHeroE in ObjectManager.Get <AIHeroClient>().Where(a => !a.IsMe && !a.IsDead && a.Team == ObjectManager.Player.Team && Player.Distance(a) < 1600 && (a.HasBuff("TaricWAllyBuff") || a.HasBuff("TaricW"))))
                    {
                        var Allytarget = ObjectManager.Get <AIHeroClient>().Where(t => !t.IsDead && t.Team != ObjectManager.Player.Team && AllyHeroE.Distance(t) < E.Range).FirstOrDefault();

                        if (Allytarget.IsValidTarget())
                        {
                            if (SkyLv_Taric.Menu.Item(AllyHeroE.ChampionName + "AllyCCEComboFromAlly", true).GetValue <bool>() && (AllyHeroE.IsCharmed || AllyHeroE.IsStunned || AllyHeroE.IsRooted || AllyHeroE.Spellbook.IsAutoAttacking))
                            {
                                E.Cast(Allytarget.ServerPosition, PacketCast);
                                return;
                            }

                            if (SkyLv_Taric.Menu.Item(AllyHeroE.ChampionName + "TargetCCEComboFromAlly", true).GetValue <bool>() && (Allytarget.IsCharmed || Allytarget.IsStunned || Allytarget.IsRooted || Allytarget.Spellbook.IsAutoAttacking))
                            {
                                E.Cast(Allytarget.ServerPosition, PacketCast);
                                return;
                            }

                            if (SkyLv_Taric.Menu.Item(AllyHeroE.ChampionName + "AlwaysComboFromAlly", true).GetValue <bool>())
                            {
                                E.Cast(Allytarget.ServerPosition, PacketCast);
                                return;
                            }
                        }
                    }
                }
                #endregion

                #region UseQAlly
                if (SkyLv_Taric.Menu.Item("Taric.UseQAlly").GetValue <bool>() && SkyLv_Taric.Menu.Item("Taric.UseQAllyMode").GetValue <StringList>().SelectedIndex == 0)
                {
                    if (Q.IsReady() && Player.Mana >= Q.ManaCost)
                    {
                        foreach (var AllyHeroQ in HeroManager.Allies.Where(x => !x.IsMe && !x.IsDead && Player.Distance(x) < Q.Range &&
                                                                           Q.Instance.Ammo >= SkyLv_Taric.Menu.Item(x.ChampionName + "MinimumStacksQAlly").GetValue <Slider>().Value&&
                                                                           x.HealthPercent <= SkyLv_Taric.Menu.Item(x.ChampionName + "MinimumHpQAlly").GetValue <Slider>().Value))
                        {
                            if (AllyHeroQ.IsValidTarget())
                            {
                                Q.Cast(PacketCast);
                                return;
                            }
                        }
                    }
                }
                #endregion

                #region UseWAlly
                if (SkyLv_Taric.Menu.Item("Taric.UseWAlly").GetValue <bool>() && SkyLv_Taric.Menu.Item("Taric.UseWAllyMode").GetValue <StringList>().SelectedIndex == 0)
                {
                    if (W.IsReady() && Player.Mana >= W.ManaCost)
                    {
                        var AllyHeroW = HeroManager.Allies.Where(x => !x.IsMe && !x.IsDead && Player.Distance(x) <= W.Range &&
                                                                 !SkyLv_Taric.Menu.Item(x.ChampionName + "IncomingDamageWAlly", true).GetValue <bool>() &&
                                                                 x.HealthPercent <= SkyLv_Taric.Menu.Item(x.ChampionName + "MinimumHpWAlly").GetValue <Slider>().Value).MinOrDefault(t => t.HealthPercent);

                        if (AllyHeroW.IsValidTarget())
                        {
                            W.Cast(AllyHeroW, PacketCast);
                            return;
                        }
                    }
                }
                #endregion
            }
        }
Beispiel #10
0
        public static void ComboLogic()
        {
            var PacketCast = getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UsePacketCast");
            var useQ       = getCheckBoxItem(SkyLv_Taric.Combo, "Taric.UseQCombo");
            var useW       = getCheckBoxItem(SkyLv_Taric.Combo, "Taric.UseWCombo");
            var useE       = getCheckBoxItem(SkyLv_Taric.Combo, "Taric.UseECombo");

            var MinimumStackSelfQCombo     = getSliderItem(SkyLv_Taric.Combo, "Taric.MinimumStackSelfQCombo");
            var MinimumHpPercentSelfQCombo = getSliderItem(SkyLv_Taric.Combo, "Taric.MinimumHpPercentSelfQCombo");

            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
            {
                var target = TargetSelector.GetTarget(E.Range, DamageType.Physical);

                if (target.LSIsValidTarget(E.Range))
                {
                    if (useE && E.IsReady() && (!CustomLib.HavePassiveAA() || !getCheckBoxItem(SkyLv_Taric.Combo, "Taric.UseTaricAAPassiveCombo") || Player.LSDistance(target) > Orbwalking.GetRealAutoAttackRange(Player)))
                    {
                        if (Player.LSDistance(target) < E.Range)
                        {
                            E.CastIfHitchanceEquals(target, EloBuddy.SDK.Enumerations.HitChance.High, PacketCast);
                            return;
                        }
                    }

                    if (target.LSIsValidTarget(Orbwalking.GetRealAutoAttackRange(Player)))
                    {
                        if (!getCheckBoxItem(SkyLv_Taric.Combo, "Taric.UseWIncomingDamageCombo") && useW && W.IsReady() && (!CustomLib.HavePassiveAA() || !getCheckBoxItem(SkyLv_Taric.Combo, "Taric.UseTaricAAPassiveCombo")) && (!E.IsReady() || !useE))
                        {
                            W.Cast(Player, PacketCast);
                            return;
                        }

                        if (useQ && Q.IsReady() && Q.Instance.Ammo >= MinimumStackSelfQCombo && Player.HealthPercent <= MinimumHpPercentSelfQCombo && (!CustomLib.HavePassiveAA() || !getCheckBoxItem(SkyLv_Taric.Combo, "Taric.UseTaricAAPassiveCombo")) && (!E.IsReady() || !useE) && (Player.HealthPercent < 100 || (!W.IsReady() || !useW)))
                        {
                            Q.Cast(Player, PacketCast);
                            return;
                        }
                    }
                }

                #region Ally E
                if (getCheckBoxItem(SkyLv_Taric.Combo, "Taric.UseEFromAlly") && E.IsReady() && Player.Mana >= E.ManaCost)
                {
                    foreach (var AllyHeroE in ObjectManager.Get <AIHeroClient>().Where(a => !a.IsMe && !a.IsDead && a.Team == ObjectManager.Player.Team && Player.LSDistance(a) < 1600 && (a.HasBuff("TaricWAllyBuff") || a.HasBuff("TaricW"))))
                    {
                        var Allytarget = ObjectManager.Get <AIHeroClient>().Where(t => !t.IsDead && t.Team != ObjectManager.Player.Team && AllyHeroE.LSDistance(t) < E.Range).FirstOrDefault();

                        if (Allytarget.LSIsValidTarget())
                        {
                            if (getCheckBoxItem(SkyLv_Taric.Combo, AllyHeroE.NetworkId + "AllyCCEComboFromAlly") && (AllyHeroE.IsCharmed || AllyHeroE.IsStunned || AllyHeroE.IsRooted || !AllyHeroE.CanAttack))
                            {
                                E.Cast(Allytarget.ServerPosition, PacketCast);
                                return;
                            }

                            if (getCheckBoxItem(SkyLv_Taric.Combo, AllyHeroE.NetworkId + "TargetCCEComboFromAlly") && (Allytarget.IsCharmed || Allytarget.IsStunned || Allytarget.IsRooted || !Allytarget.CanAttack))
                            {
                                E.Cast(Allytarget.ServerPosition, PacketCast);
                                return;
                            }

                            if (getCheckBoxItem(SkyLv_Taric.Combo, AllyHeroE.NetworkId + "AlwaysComboFromAlly"))
                            {
                                E.Cast(Allytarget.ServerPosition, PacketCast);
                                return;
                            }
                        }
                    }
                }
                #endregion

                #region UseQAlly
                if (getCheckBoxItem(SkyLv_Taric.Combo, "Taric.UseQAlly") && getBoxItem(SkyLv_Taric.Combo, "Taric.UseQAllyMode") == 0)
                {
                    if (Q.IsReady() && Player.Mana >= Q.ManaCost)
                    {
                        foreach (var AllyHeroQ in HeroManager.Allies.Where(x => !x.IsMe && !x.IsDead && Player.LSDistance(x) < Q.Range &&
                                                                           Q.Instance.Ammo >= getSliderItem(SkyLv_Taric.Combo, x.NetworkId + "MinimumStacksQAlly") &&
                                                                           x.HealthPercent <= getSliderItem(SkyLv_Taric.Combo, x.NetworkId + "MinimumHpQAlly")))
                        {
                            if (AllyHeroQ.LSIsValidTarget())
                            {
                                Q.Cast(PacketCast);
                                return;
                            }
                        }
                    }
                }
                #endregion

                #region UseWAlly
                if (getCheckBoxItem(SkyLv_Taric.Combo, "Taric.UseWAlly") && getBoxItem(SkyLv_Taric.Combo, "Taric.UseWAllyMode") == 0)
                {
                    if (W.IsReady() && Player.Mana >= W.ManaCost)
                    {
                        var AllyHeroW = HeroManager.Allies.Where(x => !x.IsMe && !x.IsDead && Player.LSDistance(x) <= W.Range &&
                                                                 !getCheckBoxItem(SkyLv_Taric.Combo, x.NetworkId + "IncomingDamageWAlly") &&
                                                                 x.HealthPercent <= getSliderItem(SkyLv_Taric.Combo, x.NetworkId + "MinimumHpWAlly")).MinOrDefault(t => t.HealthPercent);

                        if (AllyHeroW.LSIsValidTarget())
                        {
                            W.Cast(AllyHeroW, PacketCast);
                            return;
                        }
                    }
                }
                #endregion
            }
        }
Beispiel #11
0
        public static void JungleClearLogic()
        {
            var PacketCast = getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UsePacketCast");
            var useQ       = getCheckBoxItem(SkyLv_Taric.JungleClear, "Taric.UseQJungleClear");
            var useW       = getCheckBoxItem(SkyLv_Taric.JungleClear, "Taric.UseWJungleClear");
            var useE       = getCheckBoxItem(SkyLv_Taric.JungleClear, "Taric.UseEJungleClear");

            var MiniManaQ = getSliderItem(SkyLv_Taric.JungleClear, "Taric.QMiniManaJungleClear");
            var MiniManaW = getSliderItem(SkyLv_Taric.JungleClear, "Taric.WMiniManaJungleClear");
            var MiniManaE = getSliderItem(SkyLv_Taric.JungleClear, "Taric.EMiniManaJungleClear");

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

            if (MinionN.LSIsValidTarget() && (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear)))
            {
                if (getCheckBoxItem(SkyLv_Taric.Misc, "Taric.SafeJungleClear") && Player.CountEnemiesInRange(1500) > 0)
                {
                    return;
                }

                if (useE && E.IsReady() && Player.ManaPercent > MiniManaE)
                {
                    if (getCheckBoxItem(SkyLv_Taric.Misc, "Taric.SpellOnlyBigMonster"))
                    {
                        foreach (var target in ObjectManager.Get <Obj_AI_Base>().Where(target => SkyLv_Taric.Monsters.Contains(target.BaseSkinName) && !target.IsDead))
                        {
                            if (target.LSIsValidTarget() && (!CustomLib.HavePassiveAA() || !getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UseTaricAAPassiveJungleClear")))
                            {
                                E.CastIfHitchanceEquals(target, EloBuddy.SDK.Enumerations.HitChance.High, PacketCast);
                            }
                        }
                    }
                    else if (!getCheckBoxItem(SkyLv_Taric.Misc, "Taric.SpellOnlyBigMonster") && MinionN.LSIsValidTarget() && (!CustomLib.HavePassiveAA() || !getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UseTaricAAPassiveJungleClear")))
                    {
                        E.CastIfHitchanceEquals(MinionN, EloBuddy.SDK.Enumerations.HitChance.High, PacketCast);
                    }
                }

                if (useW && W.IsReady() && Player.ManaPercent > MiniManaW && (!E.IsReady() || !useE))
                {
                    if (getCheckBoxItem(SkyLv_Taric.Misc, "Taric.SpellOnlyBigMonster"))
                    {
                        foreach (var target in ObjectManager.Get <Obj_AI_Base>().Where(target => SkyLv_Taric.Monsters.Contains(target.BaseSkinName) && !target.IsDead))
                        {
                            if (target.LSIsValidTarget() && (!CustomLib.HavePassiveAA() || !getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UseTaricAAPassiveJungleClear")))
                            {
                                W.Cast(Player, PacketCast);
                            }
                        }
                    }
                    else if (!getCheckBoxItem(SkyLv_Taric.Misc, "Taric.SpellOnlyBigMonster") && MinionN.LSIsValidTarget() && (!CustomLib.HavePassiveAA() || !getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UseTaricAAPassiveJungleClear")))
                    {
                        W.Cast(Player, PacketCast);
                    }
                }

                if (useQ && Q.IsReady() && Player.ManaPercent > MiniManaQ && (!E.IsReady() || !useE) && (!W.IsReady() || !useW))
                {
                    if (getCheckBoxItem(SkyLv_Taric.Misc, "Taric.SpellOnlyBigMonster"))
                    {
                        foreach (var target in ObjectManager.Get <Obj_AI_Base>().Where(target => SkyLv_Taric.Monsters.Contains(target.BaseSkinName) && !target.IsDead))
                        {
                            if (target.LSIsValidTarget() && (!CustomLib.HavePassiveAA() || !getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UseTaricAAPassiveJungleClear")))
                            {
                                Q.Cast(Player, PacketCast);
                            }
                        }
                    }
                    else if (!getCheckBoxItem(SkyLv_Taric.Misc, "Taric.SpellOnlyBigMonster") && MinionN.LSIsValidTarget() && (!CustomLib.HavePassiveAA() || !getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UseTaricAAPassiveJungleClear")))
                    {
                        Q.Cast(Player, PacketCast);
                    }
                }
            }
        }
Beispiel #12
0
        public static void AntiGapcloser_OnEnemyGapcloser(ActiveGapcloser gapcloser)
        {
            var MinimumHpEGapCloser    = SkyLv_Taric.Menu.Item("Taric.MinimumHpEGapCloser").GetValue <Slider>().Value;
            var MinimumEnemyEGapCloser = SkyLv_Taric.Menu.Item("Taric.MinimumEnemyEGapCloser").GetValue <Slider>().Value;
            var UseAutoEGapCloser      = SkyLv_Taric.Menu.Item("Taric.UseAutoEGapCloser").GetValue <bool>();
            var PacketCast             = SkyLv_Taric.Menu.Item("Taric.UsePacketCast").GetValue <bool>();

            if (Player.IsRecalling())
            {
                return;
            }

            if (UseAutoEGapCloser && gapcloser.End.Distance(Player.ServerPosition) < E.Range && Player.HealthPercent <= MinimumHpEGapCloser && CustomLib.enemyChampionInPlayerRange(800) >= MinimumEnemyEGapCloser)
            {
                E.Cast(gapcloser.End, PacketCast);
            }
        }
Beispiel #13
0
        public static void HarassLogic()
        {
            var PacketCast = getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UsePacketCast");
            var UseQHarass = getCheckBoxItem(SkyLv_Taric.Harass, "Taric.UseQHarass");
            var UseWHarass = getCheckBoxItem(SkyLv_Taric.Harass, "Taric.UseWHarass");
            var UseEHarass = getCheckBoxItem(SkyLv_Taric.Harass, "Taric.UseEHarass");

            var QMiniManaHarass = getSliderItem(SkyLv_Taric.Harass, "Taric.QMiniManaHarass");
            var WMiniManaHarass = getSliderItem(SkyLv_Taric.Harass, "Taric.WMiniManaHarass");
            var EMiniManaHarass = getSliderItem(SkyLv_Taric.Harass, "Taric.EMiniManaHarass");

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

            if (target.LSIsValidTarget())
            {
                if (UseEHarass && Player.ManaPercent > EMiniManaHarass && E.IsReady() && (!CustomLib.HavePassiveAA() || !getCheckBoxItem(SkyLv_Taric.Harass, "Taric.UseTaricAAPassiveHarass")))
                {
                    if (Player.LSDistance(target) < E.Range)
                    {
                        E.CastIfHitchanceEquals(target, EloBuddy.SDK.Enumerations.HitChance.High, PacketCast);
                        return;
                    }
                }

                if (UseWHarass && Player.ManaPercent > WMiniManaHarass && W.IsReady() && (!CustomLib.HavePassiveAA() || !getCheckBoxItem(SkyLv_Taric.Harass, "Taric.UseTaricAAPassiveHarass")) && (!E.IsReady() || !UseEHarass))
                {
                    W.Cast(Player, PacketCast);
                    return;
                }

                if (UseQHarass && Player.ManaPercent > QMiniManaHarass && Q.IsReady() && (!CustomLib.HavePassiveAA() || !getCheckBoxItem(SkyLv_Taric.Harass, "Taric.UseTaricAAPassiveHarass")) && (!E.IsReady() || !UseEHarass) && (Player.HealthPercent < 100 || (!W.IsReady() || !UseWHarass)))
                {
                    Q.Cast(Player, PacketCast);
                    return;
                }
            }
        }
Beispiel #14
0
        public static void AutoQ()
        {
            var PacketCast            = getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UsePacketCast");
            var MinimumHpSafeAutoQ    = getSliderItem(SkyLv_Taric.Combo, "Taric.MinimumHpSafeAutoQ");
            var MinimumEnemySafeAutoQ = getSliderItem(SkyLv_Taric.Combo, "Taric.MinimumEnemySafeAutoQ");
            var MinimumStackSafeAutoQ = getSliderItem(SkyLv_Taric.Combo, "Taric.MinimumStackSafeAutoQ");

            if (Player.LSIsRecalling())
            {
                return;
            }

            if (Q.IsReady() && Player.Mana >= Q.ManaCost && Q.Instance.Ammo >= MinimumStackSafeAutoQ && CustomLib.enemyChampionInPlayerRange(800) >= MinimumEnemySafeAutoQ && Player.HealthPercent <= MinimumHpSafeAutoQ)
            {
                Q.Cast(Player, PacketCast);
            }
        }
Beispiel #15
0
        public static void AutoQ()
        {
            var PacketCast            = SkyLv_Taric.Menu.Item("Taric.UsePacketCast").GetValue <bool>();
            var MinimumHpSafeAutoQ    = SkyLv_Taric.Menu.Item("Taric.MinimumHpSafeAutoQ").GetValue <Slider>().Value;
            var MinimumEnemySafeAutoQ = SkyLv_Taric.Menu.Item("Taric.MinimumEnemySafeAutoQ").GetValue <Slider>().Value;
            var MinimumStackSafeAutoQ = SkyLv_Taric.Menu.Item("Taric.MinimumStackSafeAutoQ").GetValue <Slider>().Value;

            if (Player.IsRecalling())
            {
                return;
            }

            if (Q.IsReady() && Player.Mana >= Q.ManaCost && Q.Instance.Ammo >= MinimumStackSafeAutoQ && CustomLib.enemyChampionInPlayerRange(800) >= MinimumEnemySafeAutoQ && Player.HealthPercent <= MinimumHpSafeAutoQ)
            {
                Q.Cast(Player, PacketCast);
            }
        }