示例#1
0
        private static void Items()
        {
            var itemen2 = TargetSelector.GetTarget(200, DamageType.Physical);
            var itemen  = TargetSelector.GetTarget(550, DamageType.Physical);

            if (itemen != null)
            {
                if (ItemMenu["botrk"].Cast <CheckBox>().CurrentValue&& Item.HasItem(botrk.Id) && Item.CanUseItem(botrk.Id) && Player.Instance.HealthPercent <= ItemMenu["bork"].Cast <Slider>().CurrentValue)
                {
                    Item.UseItem(botrk.Id, itemen);
                }
                if (ItemMenu["bilge"].Cast <CheckBox>().CurrentValue&& Item.HasItem(bilgewater.Id) && Item.CanUseItem(bilgewater.Id))
                {
                    Item.UseItem(bilgewater.Id, itemen);
                }
                if (ItemMenu["tia"].Cast <CheckBox>().CurrentValue&& Item.HasItem(tiamat.Id) && Item.CanUseItem(tiamat.Id))
                {
                    Item.UseItem(tiamat.Id, itemen2);
                }
                if (ItemMenu["hydra"].Cast <CheckBox>().CurrentValue&& Item.HasItem(hydra.Id) && Item.CanUseItem(hydra.Id))
                {
                    Item.UseItem(hydra.Id, itemen2);
                }
            }
            if (ItemMenu["youmuu"].Cast <CheckBox>().CurrentValue)
            {
                if (Youmuu.IsOwned() && Youmuu.IsReady() && Youmuu.IsInRange(itemen))
                {
                    Youmuu.Cast();
                }
            }
        }
示例#2
0
 private static void UseItem(Obj_AI_Hero target)
 {
     if (target != null && (target.HealthPercent < 40 || Player.HealthPercent < 50))
     {
         if (Bilgewater.IsReady)
         {
             Bilgewater.Cast(target);
         }
         if (BotRuinedKing.IsReady)
         {
             BotRuinedKing.Cast(target);
         }
     }
     if (Youmuu.IsReady && Player.CountEnemy(W.Range + E.Range) > 0)
     {
         Youmuu.Cast();
     }
     if (Tiamat.IsReady && Player.CountEnemy(Tiamat.Range) > 0)
     {
         Tiamat.Cast();
     }
     if (Hydra.IsReady && Player.CountEnemy(Hydra.Range) > 0)
     {
         Hydra.Cast();
     }
     if (Titanic.IsReady && Player.CountEnemy(Player.GetRealAutoAttackRange()) > 0)
     {
         Titanic.Cast();
     }
 }
示例#3
0
文件: Zed.cs 项目: geramz/PortAIO
 private static void UseItem(AIHeroClient target)
 {
     if (target != null && (HaveR(target) || target.HealthPercent < 40 || Player.HealthPercent < 50))
     {
         if (Bilgewater.IsReady())
         {
             Bilgewater.Cast(target);
         }
         if (BotRuinedKing.IsReady())
         {
             BotRuinedKing.Cast(target);
         }
     }
     if (Youmuu.IsReady() && Player.CountEnemyHeroesInRange(R.Range + E.Range) > 0)
     {
         Youmuu.Cast();
     }
     if (Tiamat.IsReady() && Player.CountEnemyHeroesInRange(Tiamat.Range) > 0)
     {
         Tiamat.Cast();
     }
     if (Hydra.IsReady() && Player.CountEnemyHeroesInRange(Hydra.Range) > 0)
     {
         Hydra.Cast();
     }
     if (Titanic.IsReady() && !Player.Spellbook.IsAutoAttacking && Orbwalker.LastTarget != null)
     {
         Titanic.Cast();
     }
 }
示例#4
0
 private void UseItem(Obj_AI_Base Target, bool IsFarm = false)
 {
     if (Bilgewater.IsReady() && !IsFarm)
     {
         Bilgewater.Cast(Target);
     }
     if (BladeRuined.IsReady() && !IsFarm)
     {
         BladeRuined.Cast(Target);
     }
     if (Tiamat.IsReady() && IsFarm ? Player.Distance3D(Target) <= Tiamat.Range : Player.CountEnemysInRange((int)Tiamat.Range) >= 1)
     {
         Tiamat.Cast();
     }
     if (Hydra.IsReady() && IsFarm ? Player.Distance3D(Target) <= Hydra.Range : (Player.CountEnemysInRange((int)Hydra.Range) >= 2 || (Player.GetAutoAttackDamage(Target, true) < Target.Health && Player.CountEnemysInRange((int)Hydra.Range) == 1)))
     {
         Hydra.Cast();
     }
     if (RanduinOmen.IsReady() && Player.CountEnemysInRange((int)RanduinOmen.Range) >= 1 && !IsFarm)
     {
         RanduinOmen.Cast();
     }
     if (Youmuu.IsReady() && Player.CountEnemysInRange((int)Orbwalk.GetAutoAttackRange()) >= 1 && !IsFarm)
     {
         Youmuu.Cast();
     }
 }
示例#5
0
 private static void UseItem(Obj_AI_Hero target)
 {
     if (target != null &&
         ((HaveRMark(target) && rShadow.IsValid()) || target.HealthPercent < 40 || Player.HealthPercent < 50))
     {
         if (Bilgewater.IsReady)
         {
             Bilgewater.Cast(target);
         }
         if (BotRuinedKing.IsReady)
         {
             BotRuinedKing.Cast(target);
         }
     }
     if (Youmuu.IsReady && Common.CountEnemy(R.Range + 200) > 0)
     {
         Youmuu.Cast();
     }
     if (Tiamat.IsReady && Common.CountEnemy(Tiamat.Range) > 0)
     {
         Tiamat.Cast();
     }
     if (Hydra.IsReady && Common.CountEnemy(Hydra.Range) > 0)
     {
         Hydra.Cast();
     }
     if (Titanic.IsReady && Common.CountEnemy(Titanic.Range) > 0)
     {
         Titanic.Cast();
     }
 }
示例#6
0
        private void AssassinateProgram(Obj_AI_Hero target)
        {
            if ((target == null) || !target.IsValidTarget())
            {
                return;
            }

            if (E.Instance.IsReady() && !Q.IsInRange(target))
            {
                E.Cast(target.Position);
            }
            if (Q.Instance.IsReady())
            {
                Q.CastOnUnit(target);
            }
            if ((_isMidAir && target.IsValidTarget(Hydra.Range)) ||
                target.IsValidTarget(Tiamat.Range) ||
                target.IsValidTarget(TitanicHydra.Range))
            {
                if (Hydra.IsReady())
                {
                    Hydra.Cast();
                }
                if (TitanicHydra.IsReady())
                {
                    TitanicHydra.Cast();
                }
                if (Tiamat.IsReady())
                {
                    Tiamat.Cast();
                }
            }
            if (W.Instance.IsReady())
            {
                SebbySpell(W, target);
            }

            if (Youmuu.IsReady() && target.IsValidTarget(Player.AttackRange + 400))
            {
                Youmuu.Cast();
            }
            if (Hydra.IsReady() && target.IsValidTarget(Hydra.Range))
            {
                Hydra.Cast();
            }
            if (TitanicHydra.IsReady() && target.IsValidTarget(TitanicHydra.Range))
            {
                TitanicHydra.Cast();
            }
            if (Tiamat.IsReady() && target.IsValidTarget(Tiamat.Range))
            {
                Tiamat.Cast();
            }
        }
示例#7
0
 private void UseItem(Obj_AI_Base Target)
 {
     if (Bilgewater.IsReady())
     {
         Bilgewater.Cast(Target);
     }
     if (BladeRuined.IsReady())
     {
         BladeRuined.Cast(Target);
     }
     if (Youmuu.IsReady() && Player.CountEnemysInRange((int)Orbwalk.GetAutoAttackRange()) >= 1)
     {
         Youmuu.Cast();
     }
 }
示例#8
0
        private static void talonCombo()
        {
            var comboTarget    = TargetSelector.GetTarget(2000, TargetSelector.DamageType.Physical);
            var distanceTarget = ObjectManager.Player.Distance(comboTarget.Position.To2D());
            var manaPercentage = ObjectManager.Player.Mana / ObjectManager.Player.MaxMana * 100;

            if (ObjectManager.Player.HasBuff("talonshadowassaultbuff") && menu.Item("useSafeCombo").GetValue <bool>())
            {
                return;
            }
            if (menu.Item("useItemsCombo").GetValue <bool>())
            {
                if (Hydra.IsReady() && distanceTarget <= Hydra.Range)
                {
                    Hydra.Cast();
                }
                if (Tiamat.IsReady() && distanceTarget <= Tiamat.Range)
                {
                    Tiamat.Cast();
                }
                if (Youmuu.IsReady())
                {
                    Youmuu.Cast();
                }
            }
            //if (manaPercentage < menu.Item("comboMana").GetValue<float>()) Game.PrintChat("nomama");
            Game.PrintChat(manaPercentage.ToString());
            if (Q.IsReady() && ObjectManager.Player.Spellbook.IsAutoAttacking && menu.Item("useQCombo").GetValue <bool>())
            {
                Q.Cast();
            }
            if (W.IsReady() && distanceTarget <= W.Range && menu.Item("useWCombo").GetValue <bool>())
            {
                talonCastW(comboTarget, W.GetPrediction(comboTarget).UnitPosition.To2D());
            }
            if (E.IsReady() && distanceTarget <= E.Range && menu.Item("useECombo").GetValue <bool>())
            {
                E.Cast(comboTarget);
            }
            if (R.IsReady() && distanceTarget <= R.Range && menu.Item("useRCombo").GetValue <bool>())
            {
                R.Cast();
            }
        }
示例#9
0
 internal static void ItemUsage(EventArgs args)
 {
     if (ModesMenu3["useYoumuu"].Cast <CheckBox>().CurrentValue&& Youmuu.IsReady())
     {
         Youmuu.Cast();
     }
     if (ModesMenu3["usehextech"].Cast <CheckBox>().CurrentValue&& Item.CanUseItem(hextech.Id))
     {
         var htarget = TargetSelector.GetTarget(700, DamageType.Magical); // 700 = hextech.Range
         if (htarget != null && htarget.IsValid)
         {
             Item.UseItem(hextech.Id, htarget);
         }
     }
     if (ModesMenu3["useBotrk"].Cast <CheckBox>().CurrentValue)
     {
         var ReadyCutlass = Item.CanUseItem(Cutlass.Id);
         var ReadyBotrk   = Item.CanUseItem(Botrk.Id);
         if (!ReadyBotrk && !ReadyCutlass || Player.Instance.HealthPercent > ModesMenu3["minHPBotrk"].Cast <Slider>().CurrentValue)
         {
             return;
         }
         var btarget = TargetSelector.GetTarget(550, DamageType.Physical); // 550 = Botrk.Range
         if (btarget != null && btarget.IsValid &&
             btarget.HealthPercent < ModesMenu3["enemyMinHPBotrk"].Cast <Slider>().CurrentValue)
         {
             if (ReadyCutlass)
             {
                 Item.UseItem(Cutlass.Id, btarget);
             }
             if (ReadyBotrk)
             {
                 Botrk.Cast(btarget);
             }
         }
     }
 }
示例#10
0
        /// <summary>
        ///     Handles combo
        /// </summary>
        public static void Combo()
        {
            var target = TargetSelector.SelectedTarget
                         ?? TargetSelector.GetTarget(spells[Spells.E].Range, TargetSelector.DamageType.Physical);

            if (target.IsValidTarget() == false)
            {
                return;
            }

            if (TargetSelector.SelectedTarget != null)
            {
                Orbwalker.ForceTarget(target);
            }

            #region RengarR

            if (Ferocity <= 3)
            {
                if (spells[Spells.Q].IsReady() && IsActive("Combo.Use.Q") &&
                    Player.CountEnemiesInRange(Player.AttackRange + Player.BoundingRadius + 100) != 0)
                {
                    spells[Spells.Q].Cast();
                }

                if (!RengarR)
                {
                    if (!HasPassive)
                    {
                        if (spells[Spells.E].IsReady() && IsActive("Combo.Use.E"))
                        {
                            CastE(target);
                        }
                    }
                    else
                    {
                        if (spells[Spells.E].IsReady() && IsActive("Combo.Use.E"))
                        {
                            if (Player.IsDashing())
                            {
                                CastE(target);
                            }
                        }
                    }
                }

                if (spells[Spells.W].IsReady() && IsActive("Combo.Use.W"))
                {
                    CastW();
                }
            }

            if (Ferocity == 4)
            {
                switch (IsListActive("Combo.Prio").SelectedIndex)
                {
                case 0:
                    if (!RengarR)
                    {
                        if (spells[Spells.E].IsReady() && !HasPassive)
                        {
                            CastE(target);

                            if (IsActive("Combo.Switch.E") && Utils.GameTimeTickCount - LastSwitch >= 350)
                            {
                                MenuInit.Menu.Item("Combo.Prio")
                                .SetValue(new StringList(new[] { "E", "W", "Q" }, 2));
                                LastSwitch = Utils.GameTimeTickCount;
                            }
                        }
                    }
                    else
                    {
                        if (spells[Spells.E].IsReady() && IsActive("Combo.Use.E"))
                        {
                            if (Player.IsDashing())
                            {
                                CastE(target);
                            }
                        }
                    }
                    break;

                case 1:
                    if (IsActive("Combo.Use.W") && spells[Spells.W].IsReady())
                    {
                        CastW();
                    }
                    break;

                case 2:
                    if (spells[Spells.Q].IsReady() && IsActive("Combo.Use.Q") &&
                        Player.CountEnemiesInRange(Player.AttackRange + Player.BoundingRadius + 100) != 0)
                    {
                        spells[Spells.Q].Cast();
                    }
                    break;
                }
            }

            #region Summoner spells

            if (Youmuu.IsReady() && Youmuu.IsOwned() && target.IsValidTarget(spells[Spells.Q].Range))
            {
                Youmuu.Cast();
            }

            if (IsActive("Combo.Use.Ignite") && target.IsValidTarget(600f) && IgniteDamage(target) >= target.Health)
            {
                Player.Spellbook.CastSpell(Ignite, target);
            }

            #endregion
        }
示例#11
0
        /// <summary>
        ///     Handles combo
        /// </summary>
        public static void Combo()
        {
            try
            {
                var target = TargetSelector.SelectedTarget ?? TargetSelector.GetTarget(spells[Spells.E].Range, DamageType.Physical);
                if (target.IsValidTarget() == false)
                {
                    return;
                }

                #region RengarR

                if (Ferocity <= 4)
                {
                    if (spells[Spells.Q].IsReady() && MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.Q") &&
                        Player.CountEnemiesInRange(Player.AttackRange
                                                   + Player.BoundingRadius + 100) != 0)
                    {
                        if (Orbwalker.CanMove)
                        {
                            spells[Spells.Q].Cast();
                        }
                    }

                    if (!RengarR)
                    {
                        if (!HasPassive)
                        {
                            if (spells[Spells.E].IsReady() && MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.E"))
                            {
                                var targetE = TargetSelector.GetTarget(spells[Spells.E].Range, DamageType.Physical);
                                if (targetE.IsValidTarget())
                                {
                                    spells[Spells.E].Cast(targetE);
                                }
                                foreach (var target2 in HeroManager.Enemies.Where(x => x.IsValidTarget(spells[Spells.E].Range) && !x.IsZombie))
                                {
                                    spells[Spells.E].Cast(target2);
                                }
                            }
                        }
                        else
                        {
                            if (spells[Spells.E].IsReady() && MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.E"))
                            {
                                if (Player.IsDashing())
                                {
                                    var targetE = TargetSelector.GetTarget(spells[Spells.E].Range, DamageType.Physical);
                                    if (targetE.IsValidTarget())
                                    {
                                        spells[Spells.E].Cast(targetE);
                                    }
                                    foreach (var target2 in HeroManager.Enemies.Where(x => x.IsValidTarget(spells[Spells.E].Range) && !x.IsZombie))
                                    {
                                        spells[Spells.E].Cast(target2);
                                    }
                                }
                            }
                        }
                    }

                    CastItems(target);

                    if (spells[Spells.W].IsReady() && MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.W"))
                    {
                        CastW();
                        CastItems(target);
                    }
                }

                if (Ferocity == 5)
                {
                    switch (MenuInit.getBoxItem(MenuInit.comboMenu, "Combo.Prio"))
                    {
                    case 0:
                        if (!RengarR)
                        {
                            if (spells[Spells.E].IsReady() && !HasPassive)
                            {
                                if (Orbwalker.CanMove)
                                {
                                    var targetE = TargetSelector.GetTarget(spells[Spells.E].Range, DamageType.Physical);
                                    if (targetE.IsValidTarget())
                                    {
                                        spells[Spells.E].Cast(targetE);
                                    }
                                    foreach (var target2 in HeroManager.Enemies.Where(x => x.IsValidTarget(spells[Spells.E].Range) && !x.IsZombie))
                                    {
                                        spells[Spells.E].Cast(target2);
                                    }
                                }

                                if (MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Switch.E") && Environment.TickCount - Rengar.LastE >= 500 &&
                                    Utils.GameTimeTickCount - LastSwitch >= 350)
                                {
                                    MenuInit.comboMenu["Combo.Prio"].Cast <ComboBox>().CurrentValue = 2;
                                    LastSwitch = Utils.GameTimeTickCount;
                                }
                            }
                        }
                        else
                        {
                            if (spells[Spells.E].IsReady() && MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.E"))
                            {
                                if (Player.IsDashing())
                                {
                                    var targetE = TargetSelector.GetTarget(spells[Spells.E].Range, DamageType.Physical);
                                    if (targetE.IsValidTarget())
                                    {
                                        spells[Spells.E].Cast(targetE);
                                    }
                                    foreach (var target2 in HeroManager.Enemies.Where(x => x.IsValidTarget(spells[Spells.E].Range) && !x.IsZombie))
                                    {
                                        spells[Spells.E].Cast(target2);
                                    }
                                }
                            }
                        }
                        break;

                    case 1:
                        if (MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.W") && spells[Spells.W].IsReady())
                        {
                            CastW();
                        }
                        break;

                    case 2:
                        if (spells[Spells.Q].IsReady() && MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.Q") && Player.CountEnemiesInRange(Player.AttackRange + Player.BoundingRadius + 100) != 0)
                        {
                            if (Orbwalker.CanMove)
                            {
                                spells[Spells.Q].Cast();
                            }
                        }
                        break;
                    }

                    if (!RengarR)
                    {
                        if (MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.E.OutOfRange"))
                        {
                            CastE(target);
                        }
                    }
                }

                #region Summoner spells

                if (Youmuu.IsReady() && target.IsValidTarget(spells[Spells.Q].Range))
                {
                    Youmuu.Cast();
                }

                if (MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.Smite") && !RengarR && Smite != SpellSlot.Unknown &&
                    Player.Spellbook.CanUseSpell(Smite) == SpellState.Ready && !target.IsZombie)
                {
                    Player.Spellbook.CastSpell(Smite, target);
                }

                if (MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.Ignite") && target.IsValidTarget(600f) && IgniteDamage(target) >= target.Health)
                {
                    Player.Spellbook.CastSpell(Ignite, target);
                }

                #endregion
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
示例#12
0
        private static void Combo()
        {
            var target = GetEnemy(W.Range, TargetSelector.DamageType.Physical);

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

            var useW       = Menu.Item("WCombo").IsActive();
            var rCombo     = Menu.Item("RCombo").IsActive();
            var onlyKill   = Menu.Item("RWhenKill").IsActive();
            var smartUlt   = Menu.Item("SmartUlt").IsActive();
            var youmuuitem = Menu.Item("UseYoumuu").IsActive();
            var ultCount   = Menu.Item("rcount").GetValue <Slider>().Value;

            var comboDamage       = GetComboDamage(target);
            var getUltComboDamage = GetUltComboDamage(target);

            var ultType = Menu.Item("ElTalon.Combo.Mode").GetValue <StringList>().SelectedIndex;

            switch (ultType)
            {
            case 0:
                FightItems();
                if (target.IsValidTarget(Q.Range))
                {
                    EloBuddy.Player.IssueOrder(GameObjectOrder.AttackUnit, target);
                }

                if (Q.IsReady() && target.IsValidTarget(Q.Range))
                {
                    Q.Cast(target);
                }

                if (useW && W.IsReady())
                {
                    W.Cast(target);
                }

                if (onlyKill && rCombo && Q.IsReady() && ObjectManager.Get <AIHeroClient>().Count(aiHero => aiHero.IsValidTarget(R.Range)) >= ultCount)
                {
                    if (comboDamage >= target.Health)
                    {
                        R.Cast();
                    }
                }

                if (onlyKill && R.IsReady() && smartUlt)
                {
                    if (getUltComboDamage >= target.Health)
                    {
                        R.Cast();
                    }
                }

                if (!onlyKill && rCombo && Q.IsReady() && ObjectManager.Get <AIHeroClient>().Count(aiHero => aiHero.IsValidTarget(R.Range)) >= ultCount)
                {
                    R.Cast();
                }

                break;

            case 1:

                if (R.IsReady() && R.IsInRange(target))
                {
                    R.Cast();
                }

                if (useW && W.IsReady())
                {
                    W.Cast(target);
                }

                FightItems();
                break;
            }

            if (youmuuitem && Player.Distance(target) <= 400f && Youmuu.IsReady())
            {
                Youmuu.Cast();
            }

            if (target.IsValidTarget(600f) && IgniteDamage(target) >= target.Health && Menu.Item("UseIgnite").IsActive())
            {
                Player.Spellbook.CastSpell(ignite, target);
            }
        }
示例#13
0
        private static void Combo()
        {
            foreach (var Enemy in EntityManager.Heroes.Enemies)
            {
                if (Enemy.IsValidTarget())
                {
                    if (Smite != null && Smite.IsReady() && ComboSmite.CurrentValue)
                    {
                        var target = TargetSelector.SelectedTarget == null
                            ? TargetSelector.GetTarget(700, DamageType.Physical)
                            : TargetSelector.SelectedTarget;

                        if (target != null && target.IsValidTarget() && !target.IsDead && (target.Position - Player.Position).Length() < 500)
                        {
                            Smite.Cast(target);
                        }
                        else
                        {
                            Smite.Cast(target);
                        }
                    }
                    if (Cutlass.IsOwned() && Cutlass.IsReady() && ComboItems.CurrentValue && !Player.IsDead)
                    {
                        var target = TargetSelector.SelectedTarget == null
                            ? TargetSelector.GetTarget(550, DamageType.Physical)
                            : TargetSelector.SelectedTarget;

                        if (target != null && target.IsValidTarget() && !target.IsDead && Cutlass.IsInRange(target))
                        {
                            Cutlass.Cast(target);
                        }
                        else
                        {
                            Cutlass.Cast(target);
                        }
                    }
                    if (Botrk.IsOwned() && Botrk.IsReady() && ComboItems.CurrentValue && !Player.IsDead)
                    {
                        var target = TargetSelector.SelectedTarget == null
                            ? TargetSelector.GetTarget(550, DamageType.Physical)
                            : TargetSelector.SelectedTarget;

                        if (target != null && target.IsValidTarget() && !target.IsDead && Botrk.IsInRange(target))
                        {
                            Botrk.Cast(target);
                        }
                        else
                        {
                            Botrk.Cast(target);
                        }
                    }
                    if (Youmuu.IsOwned() && Youmuu.IsReady() && ComboItems.CurrentValue && !Player.IsDead)
                    {
                        if (Player.CountEnemyChampionsInRange(500) > 0)
                        {
                            Youmuu.Cast();
                        }
                    }
                    if (Ravenous_Hydra.IsOwned() && Ravenous_Hydra.IsReady() && ComboItems.CurrentValue && !Player.IsDead)
                    {
                        if (Player.CountEnemyChampionsInRange(385) > 0)
                        {
                            Ravenous_Hydra.Cast();
                        }
                    }
                    if (Tiamat.IsOwned() && Tiamat.IsReady() && ComboItems.CurrentValue && !Player.IsDead)
                    {
                        if (Player.CountEnemyChampionsInRange(385) > 0)
                        {
                            Tiamat.Cast();
                        }
                    }
                    if (Titanic_Hydra.IsOwned() && Titanic_Hydra.IsReady() && ComboItems.CurrentValue && !Player.IsDead)
                    {
                        if (Player.CountEnemyChampionsInRange(385) > 0)
                        {
                            Titanic_Hydra.Cast();
                        }
                    }
                    if (!ComboQAA.CurrentValue && ComboQ.CurrentValue && Q.IsReady() && Enemy.IsValidTarget(E.Range))
                    {
                        Q.Cast();
                    }
                    if (!Enemy.IsDead && Enemy != null && Enemy.IsValidTarget(E.Range) && ComboE.CurrentValue)
                    {
                        if ((Enemy.Position - Player.Position).Length() > ComboEmin.CurrentValue)
                        {
                            E.Cast(Enemy);
                        }
                        if (E.GetSpellDamage(Enemy) >= Enemy.TotalShieldHealth())
                        {
                            E.Cast(Enemy);
                        }
                        if (Enemy.IsDashing())
                        {
                            E.Cast(Enemy);
                        }
                        if (Enemy.HealthPercent < 15)
                        {
                            E.Cast(Enemy);
                        }
                    }
                    if (ComboW.CurrentValue && W.IsReady())
                    {
                        var target = TargetSelector.GetTarget(250, DamageType.Physical);
                        if (target != null)
                        {
                            W.Cast();
                        }
                    }
                    if (ComboR.CurrentValue && R.IsReady())
                    {
                        var RDamage = R.GetSpellDamage(Enemy);
                        if (Player.CountEnemyChampionsInRange(R.Range) >= ComboRmin.CurrentValue)
                        {
                            if (Enemy.HasBuff("xenzhaointimidate"))
                            {
                                R.Cast();
                            }
                        }
                        if (Enemy.TotalShieldHealth() < RDamage)
                        {
                            R.Cast();
                        }
                    }
                }
            }
        }
示例#14
0
 private static void Fight(string mode)
 {
     if (mode == "Combo" && GetValue <bool>(mode, "R") && R.IsReady())
     {
         var target = R.GetTarget();
         if (target != null && CanKill(target, GetRDmg(target)))
         {
             if (Player.Distance(target) > 550 ||
                 (!Orbwalking.InAutoAttackRange(target) && (!GetValue <bool>(mode, "Q") || !Q.IsReady()) &&
                  (!GetValue <bool>(mode, "W") || !W.IsReady()) && (!GetValue <bool>(mode, "E") || !E.IsReady())))
             {
                 if (R.Cast(target).IsCasted())
                 {
                     if (GetValue <bool>(mode, "RItem") && Youmuu.IsReady())
                     {
                         LeagueSharp.Common.Utility.DelayAction.Add(10, () => Youmuu.Cast());
                     }
                     return;
                 }
             }
         }
     }
     if (mode == "Combo" && GetValue <bool>(mode, "E") && GetValue <bool>(mode, "EGap") && E.IsReady())
     {
         var target = E.GetTarget(Orbwalking.GetAutoAttackRange() - 30);
         if (target != null && !Orbwalking.InAutoAttackRange(target) &&
             Orbwalking.InAutoAttackRange(target, 20, Player.ServerPosition.Extend(Game.CursorPos, E.Range)) &&
             E.Cast(Player.ServerPosition.Extend(Game.CursorPos, E.Range)))
         {
             return;
         }
     }
     if (GetValue <bool>(mode, "PSave") && HavePassive)
     {
         return;
     }
     if (GetValue <bool>(mode, "E") &&
         (E.IsReady() || (mode == "Combo" && E.IsReady(GetValue <Slider>(mode, "EDelay").Value))))
     {
         return;
     }
     if (GetValue <bool>(mode, "Q") && Q.IsReady())
     {
         var target = Q.GetTarget() ?? Q2.GetTarget();
         if (target != null)
         {
             if (((Orbwalking.InAutoAttackRange(target) && !HavePassive) ||
                  (!Orbwalking.InAutoAttackRange(target, 20) && Q.IsInRange(target))) &&
                 Q.CastOnUnit(target))
             {
                 return;
             }
             if ((mode == "Harass" || GetValue <bool>(mode, "QExtend")) && !Q.IsInRange(target) &&
                 CastExtendQ(target))
             {
                 return;
             }
         }
     }
     if ((!GetValue <bool>(mode, "Q") || !Q.IsReady()) && GetValue <bool>(mode, "W") && W.IsReady() &&
         !Player.IsDashing())
     {
         var target = W.GetTarget();
         if (target != null &&
             ((Orbwalking.InAutoAttackRange(target) && !HavePassive) || !Orbwalking.InAutoAttackRange(target, 20)))
         {
             if (Orbwalking.InAutoAttackRange(target))
             {
                 W2.CastIfWillHit(target, -1);
             }
             else
             {
                 W.CastIfWillHit(target, -1);
             }
         }
     }
 }
示例#15
0
 private void NormalCombo(string Mode)
 {
     if (Mode == "Combo" && GetValue <bool>(Mode, "R") && R.IsReady())
     {
         var Target = R.GetTarget();
         if (Target != null && CanKill(Target, R, GetRDmg(Target)))
         {
             if (Player.Distance(Target, true) > Math.Pow(550, 2) || (!Orbwalk.InAutoAttackRange(Target) && Player.Distance(Target, true) <= Math.Pow(550, 2) && (!GetValue <bool>(Mode, "Q") || (GetValue <bool>(Mode, "Q") && !Q.IsReady())) && (!GetValue <bool>(Mode, "W") || (GetValue <bool>(Mode, "W") && !W.IsReady())) && (!GetValue <bool>(Mode, "E") || (GetValue <bool>(Mode, "E") && !E.IsReady()))))
             {
                 if (R.CastIfHitchanceEquals(Target, HitChance.Medium, PacketCast))
                 {
                     RTarget   = Target;
                     REndPos   = (Player.ServerPosition - Target.ServerPosition).Normalized();
                     RKillable = true;
                     if (GetValue <bool>(Mode, "RItem") && Youmuu.IsReady())
                     {
                         Utility.DelayAction.Add(10, () => Youmuu.Cast());
                     }
                     return;
                 }
             }
         }
     }
     if (Mode == "Combo" && GetValue <bool>(Mode, "E") && GetValue <bool>(Mode, "EGap") && E.IsReady())
     {
         var Target = E.GetTarget(Orbwalk.GetAutoAttackRange());
         if (Target != null && !Orbwalk.InAutoAttackRange(Target) && Target.Distance(Player.ServerPosition.Extend(Game.CursorPos, E.Range)) + 20 <= Orbwalk.GetAutoAttackRange(Player, Target) && E.Cast(Player.ServerPosition.Extend(Game.CursorPos, E.Range), PacketCast))
         {
             return;
         }
     }
     if (HavePassive(Mode) && GetValue <bool>(Mode, "PSave"))
     {
         return;
     }
     if (!GetValue <bool>(Mode, "E") || (GetValue <bool>(Mode, "E") && !E.IsReady()))
     {
         if (Mode == "Combo" && GetValue <bool>(Mode, "E") && E.IsReady(GetValue <Slider>(Mode, "EDelay").Value))
         {
             return;
         }
         if (GetValue <bool>(Mode, "Q") && Q.IsReady())
         {
             var Target = Q.GetTarget();
             if (Target == null)
             {
                 Target = Q2.GetTarget();
             }
             if (Target != null)
             {
                 if (((Orbwalk.InAutoAttackRange(Target) && !HavePassive(Mode)) || (Player.Distance(Target, true) > Math.Pow(Orbwalk.GetAutoAttackRange(Player, Target) + 20, 2) && Q.IsInRange(Target))) && Q.CastOnUnit(Target, PacketCast) && Player.IssueOrder(GameObjectOrder.AttackUnit, Target))
                 {
                     return;
                 }
                 else if ((Mode == "Harass" || (Mode == "Combo" && GetValue <bool>(Mode, "QExtend"))) && !Q.IsInRange(Target) && CastExtendQ(Target))
                 {
                     return;
                 }
             }
         }
         if ((!GetValue <bool>(Mode, "Q") || (GetValue <bool>(Mode, "Q") && !Q.IsReady())) && GetValue <bool>(Mode, "W") && W.IsReady() && !Player.IsDashing())
         {
             var Target = W.GetTarget();
             if (Target != null && ((Orbwalk.InAutoAttackRange(Target) && !HavePassive(Mode)) || (Player.Distance(Target, true) > Math.Pow(Orbwalk.GetAutoAttackRange(Player, Target) + 20, 2))))
             {
                 if ((Mode == "Harass" || (Mode == "Combo" && GetValue <bool>(Mode, "WPred"))) && W.CastIfHitchanceEquals(Target, HitChance.Medium, PacketCast))
                 {
                     return;
                 }
                 else if (Mode == "Combo" && !GetValue <bool>(Mode, "WPred") && W.Cast(W.GetPrediction(Target).CastPosition, PacketCast))
                 {
                     return;
                 }
             }
         }
     }
 }
示例#16
0
 private void Fight(string mode)
 {
     if (mode == "Combo" && GetValue <bool>(mode, "R") && R.IsReady())
     {
         var target = R.GetTarget();
         if (target != null && CanKill(target, GetRDmg(target)))
         {
             if (Player.Distance(target) > 550 ||
                 (!Orbwalk.InAutoAttackRange(target) && (!GetValue <bool>(mode, "Q") || !Q.IsReady()) &&
                  (!GetValue <bool>(mode, "W") || !W.IsReady()) && (!GetValue <bool>(mode, "E") || !E.IsReady())))
             {
                 if (R.CastIfHitchanceEquals(target, HitChance.High, PacketCast))
                 {
                     if (GetValue <bool>(mode, "RItem") && Youmuu.IsReady())
                     {
                         Utility.DelayAction.Add(10, () => Youmuu.Cast());
                     }
                     return;
                 }
             }
         }
     }
     if (mode == "Combo" && GetValue <bool>(mode, "E") && GetValue <bool>(mode, "EGap") && E.IsReady())
     {
         var target = E.GetTarget(Orbwalk.GetAutoAttackRange());
         if (target != null && !Orbwalk.InAutoAttackRange(target) &&
             Orbwalk.InAutoAttackRange(target, 20, Player.ServerPosition.Extend(Game.CursorPos, E.Range)) &&
             E.Cast(Player.ServerPosition.Extend(Game.CursorPos, E.Range), PacketCast))
         {
             return;
         }
     }
     if (GetValue <bool>(mode, "PSave") && HavePassive)
     {
         return;
     }
     if (GetValue <bool>(mode, "E") &&
         (E.IsReady() || (mode == "Combo" && E.IsReady(GetValue <Slider>(mode, "EDelay").Value))))
     {
         return;
     }
     if (GetValue <bool>(mode, "Q") && Q.IsReady())
     {
         var target = Q.GetTarget() ?? Q2.GetTarget();
         if (target != null)
         {
             if (((Orbwalk.InAutoAttackRange(target) && !HavePassive) ||
                  (!Orbwalk.InAutoAttackRange(target, 20) && Q.IsInRange(target))) &&
                 Q.CastOnUnit(target, PacketCast))
             {
                 return;
             }
             if ((mode == "Harass" || GetValue <bool>(mode, "QExtend")) && !Q.IsInRange(target) &&
                 CastExtendQ(target))
             {
                 return;
             }
         }
     }
     if ((!GetValue <bool>(mode, "Q") || !Q.IsReady()) && GetValue <bool>(mode, "W") && W.IsReady() &&
         !Player.IsDashing())
     {
         var target = W.GetTarget();
         if (target != null &&
             ((Orbwalk.InAutoAttackRange(target) && !HavePassive) || !Orbwalk.InAutoAttackRange(target, 20)))
         {
             if (mode == "Harass" || GetValue <bool>(mode, "WPred"))
             {
                 W.CastIfHitchanceEquals(target, HitChance.High, PacketCast);
             }
             else
             {
                 W.Cast(W.GetPrediction(target).CastPosition, PacketCast);
             }
         }
     }
 }
示例#17
0
        /// <summary>
        ///     Handles combo
        /// </summary>
        public static void Combo()
        {
            try
            {
                var target = TargetSelector.SelectedTarget ?? TargetSelector.GetTarget(spells[Spells.E].Range, DamageType.Physical);
                if (target.LSIsValidTarget() == false)
                {
                    return;
                }

                if (TargetSelector.SelectedTarget != null)
                {
                    Orbwalker.ForcedTarget = target;
                }

                #region RengarR

                if (Ferocity <= 4)
                {
                    if (spells[Spells.Q].IsReady() && MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.Q") &&
                        Player.LSCountEnemiesInRange(Player.AttackRange
                                                     + Player.BoundingRadius + 100) != 0)
                    {
                        spells[Spells.Q].Cast();
                    }

                    if (!RengarR)
                    {
                        if (!HasPassive)
                        {
                            if (spells[Spells.E].IsReady() && MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.E"))
                            {
                                CastE(target);
                            }
                        }
                        else
                        {
                            if (spells[Spells.E].IsReady() && MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.E"))
                            {
                                if (Player.LSIsDashing())
                                {
                                    CastE(target);
                                }
                            }
                        }
                    }

                    CastItems(target);

                    if (spells[Spells.W].IsReady() && MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.W"))
                    {
                        CastW();
                        CastItems(target);
                    }
                }

                if (Ferocity == 5)
                {
                    switch (MenuInit.getBoxItem(MenuInit.comboMenu, "Combo.Prio"))
                    {
                    case 0:
                        if (!RengarR)
                        {
                            if (spells[Spells.E].IsReady() && !HasPassive)
                            {
                                CastE(target);

                                if (MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Switch.E") && Utils.GameTimeTickCount - LastSwitch >= 350)
                                {
                                    MenuInit.comboMenu["Combo.Prio"].Cast <ComboBox>().CurrentValue = 2;
                                    LastSwitch = Utils.GameTimeTickCount;
                                }
                            }
                        }
                        else
                        {
                            if (spells[Spells.E].IsReady() && MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.E"))
                            {
                                if (Player.LSIsDashing())
                                {
                                    CastE(target);
                                }
                            }
                        }
                        break;

                    case 1:
                        if (MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.W") && spells[Spells.W].IsReady() && target.LSIsValidTarget(spells[Spells.W].Range))
                        {
                            CastW();
                        }
                        break;

                    case 2:
                        if (spells[Spells.Q].IsReady() && MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.Q") && Player.LSCountEnemiesInRange(Player.AttackRange + Player.BoundingRadius + 100) != 0)
                        {
                            spells[Spells.Q].Cast();
                        }
                        break;
                    }
                }

                #region Summoner spells


                if (Youmuu.IsReady() && Youmuu.IsOwned() && target.LSIsValidTarget(spells[Spells.Q].Range))
                {
                    Youmuu.Cast();
                }

                if (MenuInit.getCheckBoxItem(MenuInit.comboMenu, "Combo.Use.Ignite") && target.LSIsValidTarget(600f) && IgniteDamage(target) >= target.Health)
                {
                    Player.Spellbook.CastSpell(Ignite, target);
                }

                #endregion
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
示例#18
0
        public static void Execute()
        {
            if (LastRun > Environment.TickCount)
            {
                return;
            }

            var target =
                EntityManager.Heroes.Enemies.FirstOrDefault(e => !e.IsDead && e.IsInRange(Player.Instance, 1000));

            if (Player.Instance.IsRecalling() || Player.Instance.IsInShopRange() || target == null ||
                !Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
            {
                return;
            }

            if (Settings.Bilgewater && BilgewaterCutlass.IsOwned() && BilgewaterCutlass.IsReady())
            {
                if (Settings.BilgewaterMyHp >= Player.Instance.HealthPercent &&
                    target.HealthPercent <= Settings.BilgewaterTargetHp)
                {
                    BilgewaterCutlass.Cast(target);
                }
            }

            if (Settings.Blade && BladeOfTheRuinedKing.IsOwned() && BladeOfTheRuinedKing.IsReady())
            {
                if (Settings.BladeMyHp >= Player.Instance.HealthPercent &&
                    target.HealthPercent <= Settings.BladeTargetHp)
                {
                    BladeOfTheRuinedKing.Cast(target);
                }
            }

            if (Settings.Tiamat && Tiamat.IsOwned() && Tiamat.IsReady())
            {
                if (Settings.TiamatMyHp >= Player.Instance.HealthPercent &&
                    target.HealthPercent <= Settings.TiamatTargetHp)
                {
                    Tiamat.Cast();
                }
            }

            if (Settings.Hydra && Hydra.IsOwned() && Hydra.IsReady())
            {
                if (Settings.HydraMyHp >= Player.Instance.HealthPercent &&
                    target.HealthPercent <= Settings.HydraTargetHp)
                {
                    Hydra.Cast();
                }
            }

            if (Settings.Titanic && TitanicHydra.IsOwned() && TitanicHydra.IsReady())
            {
                if (Settings.TitanicMyHp >= Player.Instance.HealthPercent &&
                    target.HealthPercent <= Settings.TitanicTargetHp)
                {
                    TitanicHydra.Cast();
                }
            }

            if (Settings.Youmuu && Youmuu.IsOwned() && Youmuu.IsReady())
            {
                if (Settings.YoumuuMyHp >= Player.Instance.HealthPercent &&
                    target.HealthPercent <= Settings.YoumuuTargetHp)
                {
                    Youmuu.Cast();
                }
            }

            LastRun = Environment.TickCount + 200;
        }
示例#19
0
        public static void Execute()
        {
            var target = TargetSelector.GetTarget(1000, DamageType.Mixed);

            if (target == null)
            {
                var manamune = Player.Instance.Spellbook.Spells.FirstOrDefault(s => s.Name.ToLower().Contains("manamune"));

                if (manamune != null && manamune.ToggleState == 2)
                {
                    Manamune.Cast();
                }
            }

            if (Activator.lastUsed > Environment.TickCount)
            {
                return;
            }

            if (target != null && !Player.Instance.IsRecalling() &&
                (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) ||
                 Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear)))
            {
                if (Settings.Bilgewater && BilgewaterCutlass.IsOwned() && BilgewaterCutlass.IsReady() &&
                    target.IsValidTarget(BilgewaterCutlass.Range))
                {
                    if (target.HealthPercent < Settings.BilgewaterTargetHp)
                    {
                        BilgewaterCutlass.Cast(target);
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                if (Settings.Blade && BladeOfTheRuinedKing.IsOwned() && BladeOfTheRuinedKing.IsReady() &&
                    target.IsValidTarget(BladeOfTheRuinedKing.Range))
                {
                    if (Settings.BladeMyHp > Player.Instance.HealthPercent &&
                        target.HealthPercent < Settings.BladeTargetHp)
                    {
                        BladeOfTheRuinedKing.Cast(target);
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                var minions = EntityManager.MinionsAndMonsters.EnemyMinions.Count(m => m.IsValidTarget(Tiamat.Range));
                if (Settings.Tiamat && Tiamat.IsOwned() && Tiamat.IsReady() && target.IsValidTarget(Tiamat.Range) ||
                    minions > 2)
                {
                    if (target.HealthPercent < Settings.TiamatTargetHp && Misc.AACancel
                        ? EventsManager.CanAACancel
                        : Tiamat.IsReady())
                    {
                        Tiamat.Cast();
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                if (Settings.Hydra && Hydra.IsOwned() && Hydra.IsReady() && target.IsValidTarget(Hydra.Range) ||
                    minions > 2)
                {
                    if (target.HealthPercent < Settings.HydraTargetHp && Misc.AACancel
                        ? EventsManager.CanAACancel
                        : Hydra.IsReady())
                    {
                        Hydra.Cast();
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                if (Settings.Titanic && TitanicHydra.IsOwned() && TitanicHydra.IsReady() &&
                    target.IsValidTarget(TitanicHydra.Range) || minions > 2)
                {
                    if (target.HealthPercent < Settings.TitanicTargetHp && Misc.AACancel
                        ? EventsManager.CanAACancel
                        : TitanicHydra.IsReady())
                    {
                        TitanicHydra.Cast();
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                if (Settings.Youmuu && Youmuu.IsOwned() && Youmuu.IsReady() && target.IsValidTarget(Youmuu.Range))
                {
                    if (target.HealthPercent < Settings.YoumuuTargetHp)
                    {
                        Youmuu.Cast();
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                if (Settings.Hextech && Hextech.IsOwned() && Hextech.IsReady() && target.IsValidTarget(Hextech.Range))
                {
                    if (target.HealthPercent < Settings.HextechTargetHp)
                    {
                        Hextech.Cast(target);
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                if (Settings.Manamune && Manamune.IsOwned() && Manamune.IsReady() && target.IsValidTarget(Manamune.Range))
                {
                    if (target.HealthPercent < Settings.ManamuneTargetHP && Player.Instance.ManaPercent > Settings.ManamuneMana)
                    {
                        var manamune = Player.Instance.Spellbook.Spells.FirstOrDefault(s => s.Name.ToLower().Contains("manamune"));
                        if (manamune != null && manamune.ToggleState == 1)
                        {
                            Manamune.Cast();
                        }
                    }
                }
            }
        }
示例#20
0
        private void Combo()
        {
            var useQ                 = Config.Item("ComboUseQ").GetValue <bool>();
            var useW                 = Config.Item("ComboUseW").GetValue <bool>();
            var useE                 = Config.Item("ComboUseE").GetValue <bool>();
            var useR                 = Config.Item("ComboUseR").GetValue <bool>();
            var dontEUnderTurret     = Config.Item("ComboDontEUnderTurret").GetValue <bool>();
            var comboMinimumREnemies = Config.Item("ComboMinimumREnemies").GetValue <Slider>().Value;

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

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

            if (useR && (Player.CountEnemiesInRange(E.Range) >= comboMinimumREnemies) && R.Instance.IsReady())
            {
                R.Cast();
            }

            if (useE && E.Instance.IsReady() && !Q.IsInRange(target))
            {
                if (target.UnderTurret() && dontEUnderTurret)
                {
                    return;
                }
                E.Cast(target.Position);
            }
            if (useQ && Q.Instance.IsReady())
            {
                Q.CastOnUnit(target);
            }
            if ((_isMidAir && target.IsValidTarget(Hydra.Range)) || target.IsValidTarget(Tiamat.Range) ||
                target.IsValidTarget(TitanicHydra.Range))
            {
                if (Hydra.IsReady())
                {
                    Hydra.Cast();
                }
                if (TitanicHydra.IsReady())
                {
                    TitanicHydra.Cast();
                }
                if (Tiamat.IsReady())
                {
                    Tiamat.Cast();
                }
            }
            if (useW && W.Instance.IsReady())
            {
                SebbySpell(W, target);
            }

            if (Youmuu.IsReady() && target.IsValidTarget(Player.AttackRange + 400))
            {
                Youmuu.Cast();
            }
            if (Hydra.IsReady() && target.IsValidTarget(Hydra.Range))
            {
                Hydra.Cast();
            }
            if (TitanicHydra.IsReady() && target.IsValidTarget(TitanicHydra.Range))
            {
                TitanicHydra.Cast();
            }
            if (Tiamat.IsReady() && target.IsValidTarget(Tiamat.Range))
            {
                Tiamat.Cast();
            }
        }