C# AIHeroClient.LSIsValidTarget方法代码示例

        public static void TwoChainsActive(AIHeroClient target)
        {
            //string t = "";
            //if (target.IsValidTarget())
            //{
            //    foreach (var x in target.Buffs)
            //    {
            //        t += ", " + x.Name;
            //    }
            //    Game.PrintChat(t);
            //}

            R2.SetSkillshot(0.25f, 70, 1600, true, SkillshotType.SkillshotLine);
            Orbwalker.MoveTo(Game.CursorPos);
            if (target != null && target.LSIsValidTarget(Program.Q.Range) && (Program.Rstate != 3 || !R2.IsReady()))
            {
                Program.Q.Cast(target);
            }
            if (target != null && target.LSIsValidTarget(Program.E.Range) && Program.E.IsReady() && !ObjectManager.Player.LSIsDashing()
                 && !target.HasBuff("LeblancSoulShackleM") && Environment.TickCount - LastChainM >= 1500 + Game.Ping)
            {
                Program.E.Cast(target);
                LastChain = Environment.TickCount;
            }
            if (target != null && target.LSIsValidTarget(Program.E.Range) && Program.R.IsReady() && !ObjectManager.Player.LSIsDashing() && Program.Rstate == 3
                && !target.HasBuff("LeblancSoulShackle") && Environment.TickCount - LastChain >= 1500 + Game.Ping)
            {
                R2.Cast(target);
                LastChainM = Environment.TickCount;
            }
            if (target.LSIsValidTarget(Program.W.Range) && Program.getCheckBoxItem(Program.spellMenu, "Wcombo") && (Program.Rstate != 3 || !R2.IsReady()))
            {
                Program.CastW(target);
            }
        }

        public static void OnInterruptableTarget(AIHeroClient sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            if (!MenuConfig.InterruptMenu || sender.IsInvulnerable) return;

            if (sender.LSIsValidTarget(Spells.W.Range))
            {
                if (Spells.W.IsReady())
                {
                    Spells.W.Cast(sender);
                }
            }
        }

        private static void Interrupter2_OnInterruptableTarget(AIHeroClient sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            var PacketCast = getCheckBoxItem(SkyLv_Taric.Misc, "Taric.UsePacketCast");

            if (Player.LSIsRecalling() || sender.IsAlly) return;

            if (getCheckBoxItem(SkyLv_Taric.Misc, "Taric.AutoEInterrupt") && E.IsReady() && sender.LSIsValidTarget(E.Range))
                E.Cast(sender, PacketCast);

            if (getCheckBoxItem(SkyLv_Taric.Combo, "Taric.UseEFromAlly") && E.IsReady() && Player.Mana >= E.ManaCost)
            {
                foreach (var AllyHero 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 && AllyHero.LSDistance(t) < E.Range).FirstOrDefault();

                    if (getCheckBoxItem(SkyLv_Taric.Combo, AllyHero.NetworkId + "TargetInterruptEComboFromAlly") && Allytarget.NetworkId == sender.NetworkId)
                    {
                        E.Cast(sender.ServerPosition, PacketCast);
                        return;
                    }
                }
            }
        }

        private static bool AutoKill()
        {
            var wRange = W.IsReady() && W.IsFirstW() && getCheckBoxItem(ksMenu, "KSGapclose") ? W.Range : 0;
            var enemies =
                HeroManager.Enemies.Where(
                    enemy =>
                        enemy.LSIsValidTarget(wRange + E.Range) && !enemy.IsZombie &&
                        enemy.Health < GetComboDamage(enemy, SpellSlot.Q, WCastTime)).ToList();

            if (!enemies.Any())
            {
                return false;
            }

            if (!KSTarget.LSIsValidTarget(wRange + E.Range))
            {
                KSTarget = null;
            }

            KSTarget = enemies.MinOrDefault(e => e.Health);

            if (KSTarget == null || !KSTarget.IsValid)
            {
                return false;
            }

            var pos = Player.ServerPosition.LSExtend(KSTarget.ServerPosition, W.Range);

            if (!E.IsInRange(KSTarget) && KSTarget.LSIsValidTarget(E.Range + W.Range) &&
                KSTarget.Health < GetKSDamage(KSTarget, false, pos))
            {
                if (!pos.IsValidWPoint() || !W.IsFirstW() || !W.Cast(pos))
                {
                    return false;
                }

                Console.WriteLine("KS: Gapclose W");
                return true;
            }

            if (KSTarget.Health < GetKSDamage(KSTarget))
            {
                Combo(KSTarget, true);
                return true;
            }

            return false;
        }

        private static void Interrupter2_OnInterruptableTarget(AIHeroClient t, Interrupter2.InterruptableTargetEventArgs args)
        {
            if (!getCheckBoxItem(qMenu, "intQ") || !Q.IsReady())
                return;

            if (t.LSIsValidTarget(Q.Range))
            {
                Q.Cast(t);
            }
        }

 private static void Interrupter2_OnInterruptableTarget(AIHeroClient sender,
     Interrupter2.InterruptableTargetEventArgs args)
 {
     if (E.IsReady() && sender.LSIsValidTarget(E.Range) && getCheckBoxItem(eMenu, "EInterrupter"))
     {
         E.Cast(sender);
     }
 }

 internal static void RyzeInterruptableSpell(AIHeroClient sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     var wSpell = getCheckBoxItem(MenuManager.eventMenu, "useW2I");
     if (!wSpell || !sender.LSIsValidTarget(W.Range)) return;
     W.Cast(sender);
 }

 private static void Interrupter2_OnInterruptableTarget(AIHeroClient sender,
     Interrupter2.InterruptableTargetEventArgs args)
 {
     if (!getCheckBoxItem(rMenu, "OPTI"))
         return;
     if (R.IsReady() && sender.LSDistance(BallPos) < R.Range)
     {
         R.Cast();
         Program.debug("interupt");
     }
     else if (Q.IsReady() && Player.Mana > RMANA + QMANA && sender.LSIsValidTarget(Q.Range))
         Q.Cast(sender.ServerPosition);
 }

        private static void OnInterruptableTarget(AIHeroClient sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            if (sender == null || !sender.LSIsValidTarget(Q.Range) || !sender.IsEnemy)
            {
                return;
            }

            if (sender.IsValid && args.DangerLevel == Interrupter2.DangerLevel.High && getCheckBoxItem(miscMenu, "ElZilean.Q.Interrupt"))
            {
                if (Q.IsReady() && sender.LSIsValidTarget(Q.Range))
                {
                    var prediction = Q.GetPrediction(sender);
                    if (prediction.HitChance >= EloBuddy.SDK.Enumerations.HitChance.High)
                    {
                        Q.Cast(prediction.CastPosition);
                    }
                }
                W.Cast();
            }
        }

        private void Interrupter2_OnInterruptableTarget(
            AIHeroClient sender,
            Interrupter2.InterruptableTargetEventArgs args)
        {
            if (args.DangerLevel != Interrupter2.DangerLevel.High
                || sender.LSDistance(Player) > spells[Spells.R].Range)
            {
                return;
            }

            if (sender.LSIsValidTarget(spells[Spells.R].Range) && args.DangerLevel == Interrupter2.DangerLevel.High
                && spells[Spells.R].IsReady())
            {
                spells[Spells.R].Cast(sender);
            }
        }

 public static bool CastIgnite(AIHeroClient target)
 {
     return Ignite.IsReady() && target.LSIsValidTarget(600) &&
            target.Health + 5 < myHero.GetSummonerSpellDamage(target, DamageLibrary.SummonerSpells.Ignite) &&
            myHero.Spellbook.CastSpell(Ignite, target);
 }

 private static bool ShouldReset(AIHeroClient hero)
 {
     try
     {
         return !hero.LSIsValidTarget(float.MaxValue, false) || hero.IsZombie ||
                hero.HasBuffOfType(BuffType.Invulnerability) || hero.IsInvulnerable;
     }
     catch (Exception e)
     {
         Console.WriteLine(e);
     }
     return false;
 }

 private static void OnInterruptableTarget(AIHeroClient sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (sender == null) return;
     if (getCheckBoxItem(miscMenu, "misc.interrupt") && sender.LSIsValidTarget(Spells.E.Range) &&
         Spells.E.IsReady() && Player.HealthPercent <= sender.HealthPercent)
         Spells.E.CastOnUnit(sender);
 }

        /// <summary>
        ///     Interrupts an interruptable target.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="args">The <see cref="Interrupter2.InterruptableTargetEventArgs" /> instance containing the event data.</param>
        private void Interrupter2OnOnInterruptableTarget(
            AIHeroClient sender,
            Interrupter2.InterruptableTargetEventArgs args)
        {
            if (!miscMenu["UseEInterrupt"].Cast<CheckBox>().CurrentValue || !this.E.IsReady() || !sender.LSIsValidTarget(this.E.Range))
            {
                return;
            }

            if (args.DangerLevel == Interrupter2.DangerLevel.Medium || args.DangerLevel == Interrupter2.DangerLevel.High)
            {
                this.E.Cast(sender);
            }
        }

        private static void OnInterruptableTarget(AIHeroClient sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            if (sender.IsAlly || sender.IsMe)
            {
                return;
            }

            if (args.DangerLevel != Interrupter2.DangerLevel.High || sender.LSDistance(Player) > W.Range)
            {
                return;
            }

            if (sender.LSIsValidTarget(Q.Range) && Q.IsReady() && getCheckBoxItem(interrupterMenu, "ElAlistar.Interrupter.Q"))
            {
                Q.Cast();
            }

            if (sender.LSIsValidTarget(W.Range) && W.IsReady() &&
                getCheckBoxItem(interrupterMenu, "ElAlistar.Interrupter.W"))
            {
                W.Cast(sender);
            }
        }