示例#1
0
        static void JungleClear()
        {
            var mobs = MinionManager.GetMinions(Player.ServerPosition, Orbwalking.GetRealAutoAttackRange(Player) + 50,
                                                MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth);

            if (mobs.Count <= 0)
            {
                return;
            }

            if (Q.IsReady() && Menu.Item("qyq").GetValue <bool>() && getManaPer > 45)
            {
                Q.Cast(mobs[0].Position);
            }

            if (W.IsReady() && Menu.Item("qyw").GetValue <bool>())
            {
                if (getManaPer > Menu.Item("qymp").GetValue <Slider>().Value)
                {
                    if (mobs.Count >= 2)
                    {
                        CardSelect.StartSelecting(Cards.Red);
                    }
                }
                else
                {
                    CardSelect.StartSelecting(Cards.Blue);
                }
            }
        }
示例#2
0
        static void Combo()
        {
            var Combotarget = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);

            if (Menu.Item("lzw").GetValue <bool>())
            {
                if (W.IsReady() || Player.HasBuff("PickACard"))
                {
                    if (Combotarget.IsValidTarget(W.Range))
                    {
                        foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where
                                     (target => !target.IsMe && target.Team != ObjectManager.Player.Team))
                        {
                            if (target.Health < W.GetDamage(target) && Player.Distance(target, true) < 600 && !target.IsDead && target.IsValidTarget())
                            {
                                CardSelect.StartSelecting(Cards.Blue);
                            }
                            else
                            {
                                CardSelect.StartSelecting(Cards.Yellow);
                            }
                        }
                    }
                }
            }
        }
示例#3
0
        public static void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
        {
            if (Player.Instance.IsDead)
            {
                return;
            }

            if (sender.IsMe && args.SData.Name.ToLower() == "gate" && Status_CheckBox(M_Misc, "Misc_Auto_Yel"))
            {
                CardSelect.StartSelecting(Cards.Yellow);
            }

            if (Status_CheckBox(M_Item, "Item_Zy") == false)
            {
                return;
            }
            if (!Zhonyas.IsOwned() || !Zhonyas.IsReady())
            {
                return;
            }
            if (!(args.Target is AIHeroClient))
            {
                return;
            }

            var hero = sender as AIHeroClient;

            if (hero.IsEnemy)
            {
                var hitme = Player.Instance.Distance(args.End + (args.SData.CastRadius / 2)) < 100;

                if (Status_CheckBox(M_Item, "R." + hero.ChampionName.ToLower()) && args.Slot == SpellSlot.R)
                {
                    if ((hero.ChampionName != "Caitlyn" || hero.ChampionName != "Zed" || hero.ChampionName != "Karthus" || hero.ChampionName != "Morgana" || hero.ChampionName != "Fizz") && args.Slot == SpellSlot.R)
                    {
                        if (hitme)
                        {
                            Core.DelayAction(() => Zhonyas.Cast(), (int)args.SData.SpellCastTime + 150);
                        }
                    }
                }

                if (args.Target.IsMe || hitme)
                {
                    var spelldamageme = hero.GetSpellDamage(Player.Instance, args.Slot);
                    var damagepercent = (spelldamageme / Player.Instance.TotalShieldHealth()) * 100;
                    var death         = damagepercent >= Player.Instance.HealthPercent || spelldamageme >= Player.Instance.TotalShieldHealth() || hero.GetAutoAttackDamage(Player.Instance, true) >= Player.Instance.TotalShieldHealth();

                    if (Player.Instance.HealthPercent <= Status_Slider(M_Item, "Item.Zy.SHp") || death || damagepercent >= Status_Slider(M_Item, "Item.Zy.SDmg"))
                    {
                        if ((hero.ChampionName != "Caitlyn" || hero.ChampionName != "Zed" || hero.ChampionName != "Karthus" || hero.ChampionName != "Morgana" || hero.ChampionName != "Fizz") && args.Slot == SpellSlot.R)
                        {
                            Core.DelayAction(() => Zhonyas.Cast(), (int)args.SData.SpellCastTime + 150);
                        }
                    }
                }
            }
        }
示例#4
0
        static void Obj_AI_Hero_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
        {
            var AUTOYELLOW = Menu.Item("AutoYellow").GetValue <bool>();

            if (args.SData.Name == "gate" && AUTOYELLOW)
            {
                CardSelect.StartSelecting(Cards.Yellow);
            }
        }
示例#5
0
        static void Interrupter2_OnInterruptableTarget(Obj_AI_Hero target, Interrupter2.InterruptableTargetEventArgs args)
        {
            if (Menu.Item("dd").GetValue <bool>() && W.IsReady() && W.IsInRange(target))
            {
                CardSelect.StartSelecting(Cards.Yellow);
            }

            if (Player.HasBuff("goldcardpreattack") && Orbwalking.InAutoAttackRange(target))
            {
                Player.IssueOrder(GameObjectOrder.AttackUnit, target);
            }
        }
示例#6
0
        static void HarassW()
        {
            var target = TargetSelector.GetTarget(1300, TargetSelector.DamageType.Physical);

            if (Player.Distance(target.ServerPosition) < Player.AttackRange - 40 && !Menu.Item("srw").GetValue <bool>())
            {
                CardSelect.StartSelecting(Cards.Blue);
            }

            if (Player.Distance(target, true) < Player.AttackRange - 150 && !Menu.Item("srwr").GetValue <bool>())
            {
                CardSelect.StartSelecting(Cards.Red);
            }
        }
        private void OnCardSelectBackClicked(object sender, MouseEventArgs e)
        {
            CardSelect cardSelect = sender as CardSelect;

            if (selectedBackCard != null)
            {
                selectedBackCard.Deselect();
            }

            selectedBackCard = cardSelect;
            cardSelect.Select();

            UpdateButtonPlayState();
        }
示例#8
0
        static void AntiGapcloser_OnEnemyGapcloser(ActiveGapcloser gapcloser)
        {
            if (gapcloser.Sender.IsAlly)
            {
                return;
            }
            if (Menu.Item("tj").GetValue <bool>() && W.IsReady() && W.IsInRange(gapcloser.End))
            {
                CardSelect.StartSelecting(Cards.Yellow);
            }

            if (Player.HasBuff("goldcardpreattack") && Orbwalking.InAutoAttackRange(gapcloser.Sender))
            {
                Player.IssueOrder(GameObjectOrder.AttackUnit, gapcloser.Sender);
            }
        }
示例#9
0
        private static void CardSelects()
        {
            if (Menu.Item("yellow").GetValue <KeyBind>().Active)
            {
                CardSelect.StartSelecting(Cards.Yellow);
            }


            if (Menu.Item("blue").GetValue <KeyBind>().Active)
            {
                CardSelect.StartSelecting(Cards.Blue);
            }


            if (Menu.Item("red").GetValue <KeyBind>().Active)
            {
                CardSelect.StartSelecting(Cards.Red);
            }
        }
示例#10
0
        static void LaneClear()
        {
            if (Q.IsReady() && Menu.Item("qxq").GetValue <bool>() && getManaPer > 40)
            {
                var allMinionsQ = MinionManager.GetMinions(Player.ServerPosition, Q.Range, MinionTypes.All, MinionTeam.Enemy);
                var locQ        = Q.GetLineFarmLocation(allMinionsQ);

                if (locQ.MinionsHit >= 3)
                {
                    Q.Cast(locQ.Position);
                }
            }

            var minioncount = MinionManager.GetMinions(Player.Position, 1500).Count;

            if (!Menu.Item("qxw").GetValue <bool>())
            {
                if (minioncount > 0)
                {
                    if (getManaPer > Menu.Item("qxmp").GetValue <Slider>().Value)
                    {
                        if (minioncount >= 3)
                        {
                            CardSelect.StartSelecting(Cards.Red);
                        }
                        else
                        {
                            CardSelect.StartSelecting(Cards.Blue);
                        }
                    }
                    else
                    {
                        CardSelect.StartSelecting(Cards.Blue);
                    }
                }
            }
        }
示例#11
0
        public static void Harass()
        {
            if (Player.Instance.IsDead)
            {
                return;
            }

            var target = TargetSelector.GetTarget(1500, DamageType.Magical);

            if (target != null)
            {
                if (Status_CheckBox(M_Harras, "Harass_W") && Player.Instance.Distance(target) <= Player.Instance.AttackRange + 100)
                {
                    if (Player.Instance.ManaPercent < Status_Slider(M_Harras, "Harras_W_Blue"))
                    {
                        if (Player.Instance.HealthPercent >= 50)
                        {
                            CardSelect.StartSelecting(Cards.Blue);
                        }
                    }

                    switch (Status_ComboBox(M_Harras, "Harras_W_Pick"))
                    {
                    case 0:         //Auto
                        if (target.CountAllyMinionsInRange(200) >= 3 || target.CountAllyChampionsInRange(200) >= 1)
                        {
                            CardSelect.StartSelecting(Cards.Red);
                        }
                        else
                        {
                            if (Player.Instance.CountAllyChampionsInRange(Player.Instance.AttackRange) >= 1)
                            {
                                CardSelect.StartSelecting(Cards.Yellow);
                            }
                            else if (Player.Instance.Distance(target) <= Player.Instance.AttackRange - 150)
                            {
                                CardSelect.StartSelecting(Cards.Yellow);
                            }
                        }
                        break;

                    case 1:         //Red
                        CardSelect.StartSelecting(Cards.Red);
                        break;

                    case 2:         //Yellow
                        if (Player.Instance.CountAllyChampionsInRange(Player.Instance.AttackRange) >= 1)
                        {
                            CardSelect.StartSelecting(Cards.Yellow);
                        }
                        else if (Player.Instance.Distance(target) <= Player.Instance.AttackRange - 150)
                        {
                            CardSelect.StartSelecting(Cards.Yellow);
                        }
                        break;
                    }
                }

                if (Status_CheckBox(M_Harras, "Harass_Q") && Player.Instance.ManaPercent >= Status_Slider(M_Harras, "Harass_Q_Mana"))
                {
                    if (SpellManager.Q.IsReady() && SpellManager.Q.IsInRange(target))
                    {
                        var Qprediction = SpellManager.Q.GetPrediction(target);

                        if (Qprediction.HitChancePercent >= Status_Slider(M_Harras, "Harass_Q_Pre"))
                        {
                            SpellManager.Q.Cast(Qprediction.CastPosition);
                        }
                    }
                }
            }
        } //End Harass
示例#12
0
    private void OnMouseUpAsButton()
    {
        if (open)
        {
            if (openObject.name.Equals(name))
            {
                switch (SceneManager.GetActiveScene().name)
                {
                case "mainMap":
                    GameObject.Find("1").GetComponent <BoxCollider2D>().enabled = true;
                    break;

                case "secondaryMap":
                    GameObject.Find("1").GetComponent <BoxCollider2D>().enabled = true;
                    GameObject.Find("2").GetComponent <BoxCollider2D>().enabled = true;
                    GameObject.Find("3").GetComponent <BoxCollider2D>().enabled = true;
                    GameObject.Find("4").GetComponent <BoxCollider2D>().enabled = true;
                    GameObject.Find("5").GetComponent <BoxCollider2D>().enabled = true;
                    GameObject.Find("6").GetComponent <BoxCollider2D>().enabled = true;
                    GameObject.Find("7").GetComponent <BoxCollider2D>().enabled = true;
                    GameObject.Find("8").GetComponent <BoxCollider2D>().enabled = true;
                    break;

                case "tertiaryMap":
                    for (int i = 1; i < count + 1; i++)
                    {
                        GameObject.Find(i.ToString()).GetComponent <BoxCollider>().enabled = true;
                    }
                    break;

                default:
                    break;
                }
                switch (name)
                {
                case "Backpack":
                    Destroy(openObject);
                    break;

                case "SelectCard":
                    GlobalVariable.FightCards.Clear();

                    for (int i = 0; i < CardSelect.count; i++)
                    {
                        GlobalVariable.FightCards.Add(CardSelect.fightCardsGrids[i].gameProp);
                    }
                    CardSelect.Clear();
                    BarScript.Clear();
                    Destroy(openObject);
                    break;

                case "SkillSelect":
                    SkillSelect.Clear();
                    Destroy(openObject);
                    break;

                default:
                    break;
                }
                open = false;
                return;
            }
            else
            {
                switch (openObject.name)
                {
                case "Backpack":
                    Destroy(openObject);
                    break;

                case "SelectCard":
                    GlobalVariable.FightCards.Clear();
                    for (int i = 0; i < CardSelect.count; i++)
                    {
                        GlobalVariable.FightCards.Add(CardSelect.fightCardsGrids[i].gameProp);
                    }
                    CardSelect.Clear();
                    BarScript.Clear();
                    Destroy(openObject);
                    break;

                case "SkillSelect":
                    SkillSelect.Clear();
                    Destroy(openObject);
                    break;

                default:
                    break;
                }
                switch (name)
                {
                case "Backpack":
                    openObject      = Instantiate(Resources.Load <GameObject>("PanelPrefabs/Backpack"), new Vector3(0, 0, 0), Quaternion.identity);
                    openObject.name = "Backpack";
                    break;

                case "SelectCard":
                    openObject      = Instantiate(Resources.Load <GameObject>("PanelPrefabs/SelectCard"), new Vector3(0, 0, 0), Quaternion.identity);
                    openObject.name = "SelectCard";
                    break;

                case "SkillSelect":
                    openObject      = Instantiate(Resources.Load <GameObject>("PanelPrefabs/SkillSelect"), new Vector3(0, 0, 0), Quaternion.identity);
                    openObject.name = "SkillSelect";
                    break;

                default:
                    break;
                }
                open = true;
                return;
            }
        }
        if (!open)
        {
            switch (SceneManager.GetActiveScene().name)
            {
            case "mainMap":
                GameObject.Find("1").GetComponent <BoxCollider2D>().enabled = false;
                break;

            case "secondaryMap":
                GameObject.Find("1").GetComponent <BoxCollider2D>().enabled = false;
                GameObject.Find("2").GetComponent <BoxCollider2D>().enabled = false;
                GameObject.Find("3").GetComponent <BoxCollider2D>().enabled = false;
                GameObject.Find("4").GetComponent <BoxCollider2D>().enabled = false;
                GameObject.Find("5").GetComponent <BoxCollider2D>().enabled = false;
                GameObject.Find("6").GetComponent <BoxCollider2D>().enabled = false;
                GameObject.Find("7").GetComponent <BoxCollider2D>().enabled = false;
                GameObject.Find("8").GetComponent <BoxCollider2D>().enabled = false;
                break;

            case "tertiaryMap":
                for (int i = 1; i < count + 1; i++)
                {
                    GameObject.Find(i.ToString()).GetComponent <BoxCollider>().enabled = false;
                }
                break;

            default:
                break;
            }
            switch (name)
            {
            case "Backpack":
                openObject      = Instantiate(Resources.Load <GameObject>("PanelPrefabs/Backpack"), new Vector3(0, 0, 0), Quaternion.identity);
                openObject.name = "Backpack";
                break;

            case "SelectCard":
                openObject      = Instantiate(Resources.Load <GameObject>("PanelPrefabs/SelectCard"), new Vector3(0, 0, 0), Quaternion.identity);
                openObject.name = "SelectCard";
                break;

            case "SkillSelect":
                openObject      = Instantiate(Resources.Load <GameObject>("PanelPrefabs/SkillSelect"), new Vector3(0, 0, 0), Quaternion.identity);
                openObject.name = "SkillSelect";
                break;

            default:
                break;
            }
            open = true;
            return;
        }
    }
示例#13
0
 private void Awake()
 {
     _instance = this;
 }
示例#14
0
 // Use this for initialization
 void Start()
 {
     CardSelect.LoadData();
     LoadCards();
 }
示例#15
0
        public static void Jungle()
        {
            if (Player.Instance.IsDead)
            {
                return;
            }

            var monster = EntityManager.MinionsAndMonsters.Monsters.Where(m => m.IsValidTarget(850));

            if (monster == null)
            {
                return;
            }

            var MiniMonster = monster.Where(x => x.IsValidTarget(SpellManager.Q.Range) && x.Name.Contains("Mini"));

            if (MiniMonster != null && MiniMonster.FirstOrDefault(x => Player.Instance.Distance(x) <= Player.Instance.AttackRange) != null)
            {
                Orbwalker.ForcedTarget = MiniMonster.FirstOrDefault();
                monster = MiniMonster;
            }

            if (Status_CheckBox(M_Clear, "Jungle_W") && SpellManager.W.IsReady())
            {
                if (Player.Instance.ManaPercent < Status_Slider(M_Clear, "Jungle_W_TotalMana"))
                {
                    CardSelect.StartSelecting(Cards.Blue);
                }
                else
                {
                    switch (Status_ComboBox(M_Clear, "Jungle_W_Pick"))
                    {
                    case 0:         //Auto
                        var MKillNum   = monster.OrderBy(x => x.Health).Count(x => x.Distance(monster.FirstOrDefault()) <= 200 && x.Health <= Damage.PredictWDamage(x, Cards.Red));
                        var TotalNum   = monster.Count(x => x.Distance(monster.FirstOrDefault()) <= 200);
                        var BigMonster = monster.Where(x => x.IsValidTarget(Player.Instance.AttackRange + 100) && !x.Name.Contains("Mini")).FirstOrDefault();

                        if (MKillNum >= 2 || TotalNum >= 2)
                        {
                            CardSelect.StartSelecting(Cards.Red);
                        }

                        if (Player.Instance.Distance(BigMonster) <= BigMonster.AttackRange + 100)
                        {
                            CardSelect.StartSelecting(Cards.Yellow);
                        }
                        break;

                    case 1:         //Red
                        CardSelect.StartSelecting(Cards.Red);
                        break;

                    case 2:         //Yellow
                        CardSelect.StartSelecting(Cards.Yellow);
                        break;
                    }
                }
            }

            if (Status_CheckBox(M_Clear, "Jungle_Q") && SpellManager.Q.IsReady() && Player.Instance.ManaPercent > Status_Slider(M_Clear, "Jungle_Q_Mana"))
            {
                var target = EntityManager.MinionsAndMonsters.Monsters.Where(x => x.IsValidTarget(1450)).OrderBy(x => x.Health);

                if (target != null)
                {
                    var TargetNum = target.Count(x => x.Distance(target.FirstOrDefault()) <= 200);

                    var Qprediction = SpellManager.Q.GetPrediction(target.FirstOrDefault());

                    if (TargetNum >= 2)
                    {
                        SpellManager.Q.Cast(Qprediction.CastPosition);
                    }
                }
            }
        } //End Static Jungle
示例#16
0
        public static void Lane()
        {
            if (Player.Instance.IsDead)
            {
                return;
            }

            var targetW = EntityManager.MinionsAndMonsters.EnemyMinions.Where(x => x.IsValidTarget(Player.Instance.AttackRange + 100)).OrderBy(x => x.Health);

            if (targetW != null)
            {
                if (Status_CheckBox(M_Clear, "Lane_W_Blue") && Player.Instance.ManaPercent < Status_Slider(M_Clear, "Lane_W_TotalMana"))
                {
                    CardSelect.StartSelecting(Cards.Blue);
                }
                else if (Status_CheckBox(M_Clear, "Lane_W_Red") && Player.Instance.ManaPercent > Status_Slider(M_Clear, "Lane_W_TotalMana"))
                {
                    var TeamTurret = EntityManager.Turrets.Allies.Where(x => Player.Instance.Distance(x) <= 370).FirstOrDefault();

                    if ((TeamTurret != null && Player.Instance.Distance(TeamTurret) <= 370 && TeamTurret.CountEnemyMinionsInRange(420) >= 3) && Player.Instance.CountEnemyChampionsInRange(1700) == 0)
                    {
                        var PushNum = targetW.Count(x => x.Distance(targetW.FirstOrDefault()) <= 200);

                        if (PushNum >= Status_Slider(M_Clear, "Lane_W_RedHit"))
                        {
                            CardSelect.StartSelecting(Cards.Red);
                        }
                    }
                    else if (Player.Instance.CountEnemyChampionsInRange(1700) >= 1)
                    {
                        var KillNum = targetW.Count(x => x.Distance(targetW.FirstOrDefault()) <= 200 && x.Health <= Damage.DmgW(x, Cards.Red));

                        if (KillNum >= Status_Slider(M_Clear, "Lane_W_RedKill"))
                        {
                            CardSelect.StartSelecting(Cards.Red);
                        }
                    }
                }
            }

            if (Status_CheckBox(M_Clear, "Lane_Q") && Player.Instance.ManaPercent > Status_Slider(M_Clear, "Lane_Q_Mana"))
            {
                var target = EntityManager.MinionsAndMonsters.EnemyMinions.Where(x => x.IsValidTarget(SpellManager.Q.Range)).OrderBy(x => x.Health);

                if (target != null)
                {
                    switch (Status_ComboBox(M_Clear, "Lane_Q_Mode"))
                    {
                    case 0:     //Auto
                        var TeamTurret = EntityManager.Turrets.Allies.Where(x => Player.Instance.Distance(x) <= 350).FirstOrDefault();

                        if ((TeamTurret != null && Player.Instance.Distance(TeamTurret) <= 370 && TeamTurret.CountEnemyMinionsInRange(420) >= 3) &&
                            Player.Instance.CountEnemyChampionsInRange(1700) == 0)
                        {
                            target = target.OrderBy(x => x.Health);
                        }

                        if (Player.Instance.CountEnemyChampionsInRange(SpellManager.Q.Range) >= 1)
                        {
                            target = target.OrderBy(x => x.Health <= Damage.DmgQ(x));
                        }
                        break;

                    case 1:     //Falst clear"
                        target = target.OrderBy(x => x.Health);
                        break;

                    case 2:     //Killable clear
                        target = target.OrderBy(x => x.Health <= Damage.DmgQ(x));
                        break;
                    }

                    var targetPre = EntityManager.MinionsAndMonsters.GetLineFarmLocation(target, SpellManager.Q.Width, (int)SpellManager.Q.Range);

                    if (targetPre.HitNumber >= Status_Slider(M_Clear, "Lane_Q_Hit"))
                    {
                        SpellManager.Q.Cast(targetPre.CastPosition);
                    }
                }
            }
        } //End Static Lane
示例#17
0
        public static void Combo()
        {
            if (Player.Instance.IsDead)
            {
                return;
            }

            var target = TargetSelector.GetTarget(1500, DamageType.Magical);

            if (target != null)
            {
                if (Status_CheckBox(M_Combo, "Combo_W") && Player.Instance.Distance(target) <= Player.Instance.AttackRange + 100)
                {
                    if (Player.Instance.ManaPercent < Status_Slider(M_Combo, "Combo_W_Blue"))
                    {
                        if (Player.Instance.HealthPercent >= 50)
                        {
                            CardSelect.StartSelecting(Cards.Blue);
                        }
                    }

                    switch (Status_ComboBox(M_Combo, "Combo_W_Pick"))
                    {
                    case 0:         //Auto
                        if (target.CountAllyChampionsInRange(200) >= Status_Slider(M_Combo, "Combo_W_Red"))
                        {
                            CardSelect.StartSelecting(Cards.Red);
                        }
                        else
                        {
                            if (Player.Instance.CountAllyChampionsInRange(Player.Instance.AttackRange) >= 1)
                            {
                                CardSelect.StartSelecting(Cards.Yellow);
                            }
                            else if (Player.Instance.Distance(target) <= Player.Instance.AttackRange - 150)
                            {
                                CardSelect.StartSelecting(Cards.Yellow);
                            }
                        }
                        break;

                    case 1:         //Red
                        CardSelect.StartSelecting(Cards.Red);
                        break;

                    case 2:         //Yellow
                        CardSelect.StartSelecting(Cards.Yellow);
                        break;
                    }
                }

                if (Status_CheckBox(M_Combo, "Combo_Q") && Player.Instance.ManaPercent >= Status_Slider(M_Combo, "Combo_Q_Mana"))
                {
                    if (SpellManager.Q.IsReady() && SpellManager.Q.IsInRange(target))
                    {
                        switch (Status_ComboBox(M_Combo, "Combo_Q_Stun"))
                        {
                        case 0:         //아무떄나
                            var Qprediction = SpellManager.Q.GetPrediction(target);

                            if (Qprediction.HitChancePercent >= Status_Slider(M_Combo, "Combo_Q_Pre"))
                            {
                                SpellManager.Q.Cast(Qprediction.CastPosition);
                            }
                            break;

                        case 1:
                            if (target.HasBuffOfType(BuffType.Stun) || target.HasBuffOfType(BuffType.Snare) || target.HasBuffOfType(BuffType.Knockup) || target.HasBuffOfType(BuffType.Suppression) ||
                                target.IsRecalling())
                            {
                                SpellManager.Q.Cast(target);
                            }
                            break;
                        }
                    }
                }
            }
        }