protected override void CombatRotation()
        {
            // Reactivate auto attack (after dragon's breath)
            if (!ToolBox.UsingWand())
            {
                ToolBox.CheckAutoAttack(Attack);
            }

            base.CombatRotation();
            WoWUnit Target = ObjectManager.Target;

            // Stop wand use on multipull
            if (_iCanUseWand && ObjectManager.GetNumberAttackPlayer() > 1)
            {
                _iCanUseWand = false;
            }

            // Remove Curse
            if (ToolBox.HasCurseDebuff())
            {
                Thread.Sleep(Main.humanReflexTime);
                if (cast.OnSelf(RemoveCurse))
                {
                    return;
                }
            }

            // Mana Shield
            if (!Me.HaveBuff("Mana Shield") &&
                (Me.HealthPercent < 30 && Me.ManaPercentage > 50 ||
                 Me.HealthPercent < 10) &&
                cast.OnTarget(ManaShield))
            {
                return;
            }

            // Use Mana Stone
            if ((ObjectManager.GetNumberAttackPlayer() > 1 && Me.ManaPercentage < 50 || Me.ManaPercentage < 5) &&
                _foodManager.UseManaStone())
            {
                return;
            }

            // Combustion
            if (!Me.HaveBuff("Combustion") &&
                cast.OnSelf(Combustion))
            {
                return;
            }

            // Blast Wave
            if (settings.BlastWaveOnMulti &&
                ToolBox.GetNbEnemiesClose(10) > 1 &&
                ObjectManager.GetNumberAttackPlayer() > 1 &&
                cast.OnSelf(BlastWave))
            {
                return;
            }

            // Dragon's Breath
            if (Target.GetDistance <= 10f &&
                settings.UseDragonsBreath &&
                (Target.HealthPercent > settings.WandThreshold || ObjectManager.GetNumberAttackPlayer() > 1 || Me.HealthPercent < 40 || !_iCanUseWand) &&
                _polymorphedEnemy == null &&
                cast.OnSelf(DragonsBreath))
            {
                return;
            }

            // Fire Blast
            if (Target.HealthPercent <= settings.FireblastThreshold &&
                (Target.HealthPercent > settings.WandThreshold || ObjectManager.GetNumberAttackPlayer() > 1 || Me.HealthPercent < 40 || !_iCanUseWand) &&
                !Target.HaveBuff("Polymorph") &&
                cast.OnTarget(FireBlast))
            {
                return;
            }

            // Cone of Cold
            if (Target.GetDistance < 10 &&
                settings.UseConeOfCold &&
                _polymorphedEnemy == null &&
                cast.OnTarget(ConeOfCold))
            {
                return;
            }

            // FireBall
            if ((Target.HealthPercent > settings.WandThreshold || ObjectManager.GetNumberAttackPlayer() > 1 || Me.HealthPercent < 40 || !_iCanUseWand) &&
                !Target.HaveBuff("Polymorph") &&
                cast.OnTarget(Fireball))
            {
                return;
            }

            // Stop wand if banned
            if (ToolBox.UsingWand() &&
                UnitImmunities.Contains(ObjectManager.Target, "Shoot"))
            {
                if (cast.OnTarget(UseWand))
                {
                    return;
                }
            }

            // Spell if wand banned
            if (UnitImmunities.Contains(ObjectManager.Target, "Shoot"))
            {
                if (cast.OnTarget(Fireball) || cast.OnTarget(Frostbolt) || cast.OnTarget(ArcaneMissiles))
                {
                    return;
                }
            }

            // Use Wand
            if (!ToolBox.UsingWand() &&
                _iCanUseWand &&
                !cast.IsBackingUp &&
                !MovementManager.InMovement)
            {
                if (cast.OnTarget(UseWand, false))
                {
                    return;
                }
            }

            // Go in melee because nothing else to do
            if (!ToolBox.UsingWand() &&
                !UseWand.IsSpellUsable &&
                !RangeManager.CurrentRangeIsMelee() &&
                !cast.IsBackingUp &&
                Target.IsAlive)
            {
                Logger.Log("Going in melee");
                RangeManager.SetRangeToMelee();
                return;
            }
        }
        protected override void CombatRotation()
        {
            WoWUnit Target = ObjectManager.Target;

            // Fade
            if (AIORadar.CloseUnitsTargetingMe.Count > 0 &&
                cast.OnSelf(Fade))
            {
                return;
            }

            // Inner Focus  + spell
            if (Me.HaveBuff("Inner Focus") &&
                Target.HealthPercent > 80)
            {
                cast.OnTarget(DevouringPlague);
                cast.OnTarget(ShadowWordPain);
                return;
            }

            // Power Word Shield
            if (Me.HealthPercent < 50 &&
                !Me.HaveBuff("Power Word: Shield") &&
                !ToolBox.HasDebuff("Weakened Soul") &&
                settings.UsePowerWordShield &&
                cast.OnSelf(PowerWordShield))
            {
                return;
            }

            // Silence
            if (ToolBox.TargetIsCasting() &&
                cast.OnTarget(Silence))
            {
                return;
            }

            // Cure Disease
            if (settings.PartyCureDisease)
            {
                // PARTY Cure Disease
                WoWPlayer needCureDisease = AIOParty.GroupAndRaid
                                            .Find(m => ToolBox.HasDiseaseDebuff(m.Name));
                if (needCureDisease != null && cast.OnFocusUnit(CureDisease, needCureDisease))
                {
                    return;
                }
            }

            // PARTY Dispel Magic
            if (settings.PartyDispelMagic)
            {
                WoWPlayer needDispelMagic = AIOParty.GroupAndRaid
                                            .Find(m => ToolBox.HasMagicDebuff(m.Name));
                if (needDispelMagic != null && cast.OnFocusUnit(DispelMagic, needDispelMagic))
                {
                    return;
                }
            }

            // Combat ShadowForm
            if (!Me.HaveBuff("ShadowForm") &&
                cast.OnSelf(Shadowform))
            {
                return;
            }

            // ShadowFiend
            if (Me.ManaPercentage < 30 &&
                cast.OnTarget(Shadowfiend))
            {
                return;
            }

            // Vampiric Touch
            if (!Target.HaveBuff("Vampiric Touch") &&
                cast.OnTarget(VampiricTouch))
            {
                return;
            }

            if (settings.PartyVampiricEmbrace)
            {
                // Vampiric Embrace
                if (!Target.HaveBuff("Vampiric Embrace") &&
                    Target.HaveBuff("Vampiric Touch") &&
                    cast.OnTarget(VampiricEmbrace))
                {
                    return;
                }
            }

            // Inner Focus
            if (Target.HealthPercent > 80 &&
                cast.OnSelf(InnerFocus))
            {
                return;
            }

            // Devouring Plague
            if (!Target.HaveBuff("Devouring Plague") &&
                Target.HealthPercent > 80 &&
                cast.OnTarget(DevouringPlague))
            {
                return;
            }

            // PARTY Shadow Word Pain
            List <WoWUnit> enemiesWithoutPain = AIOParty.EnemiesFighting
                                                .Where(e => e.InCombatFlagOnly && !e.HaveBuff("Shadow Word: Pain"))
                                                .OrderBy(e => e.GetDistance)
                                                .ToList();

            if (enemiesWithoutPain.Count > 0 &&
                AIOParty.EnemiesFighting.Count - enemiesWithoutPain.Count < 3 &&
                cast.OnFocusUnit(ShadowWordPain, enemiesWithoutPain[0]))
            {
                return;
            }

            // Mind Blast
            if (Me.ManaPercentage > settings.PartyMindBlastThreshold &&
                cast.OnTarget(MindBlast))
            {
                return;
            }

            // Shadow Word Death
            if (Me.HealthPercent > settings.PartySWDeathThreshold &&
                settings.UseShadowWordDeath &&
                cast.OnTarget(ShadowWordDeath))
            {
                return;
            }

            // Mind FLay
            if (cast.OnTarget(MindFlay))
            {
                return;
            }

            // Stop wand if banned
            if (ToolBox.UsingWand() &&
                UnitImmunities.Contains(ObjectManager.Target, "Shoot") &&
                cast.OnTarget(UseWand))
            {
                return;
            }

            // Spell if wand banned
            if (UnitImmunities.Contains(ObjectManager.Target, "Shoot"))
            {
                if (cast.OnTarget(MindBlast) || cast.OnTarget(Smite))
                {
                    return;
                }
            }

            // Use Wand
            if (!ToolBox.UsingWand() &&
                _iCanUseWand &&
                cast.OnTarget(UseWand, false))
            {
                return;
            }
        }
        protected override void CombatRotation()
        {
            base.CombatRotation();

            WoWUnit target = ObjectManager.Target;

            // Soulshatter
            if (SoulShatter.IsSpellUsable &&
                settings.UseSoulShatter &&
                AIORadar.CloseUnitsTargetingMe.Count > 0 &&
                ToolBox.CountItemStacks("Soul Shard") > 0 &&
                cast.OnSelf(SoulShatter))
            {
                return;
            }

            // Life Tap
            if (Me.ManaPercentage < settings.PartyLifeTapManaThreshold &&
                Me.HealthPercent > settings.PartyLifeTapHealthThreshold &&
                settings.UseLifeTap &&
                cast.OnSelf(LifeTap))
            {
                return;
            }

            // Shadow Trance
            if (Me.HaveBuff("Shadow Trance") &&
                cast.OnTarget(ShadowBolt))
            {
                return;
            }

            // PARTY Seed of Corruption
            if (AIOParty.EnemiesFighting.Count >= settings.PartySeedOfCorruptionAmount &&
                SeedOfCorruption.KnownSpell)
            {
                List <WoWUnit> enemiesWithoutSeedOfCorruption = AIOParty.EnemiesFighting
                                                                .Where(e => !e.HaveBuff("Seed of Corruption"))
                                                                .OrderBy(e => e.GetDistance)
                                                                .ToList();
                if (enemiesWithoutSeedOfCorruption.Count > 0 &&
                    cast.OnFocusUnit(SeedOfCorruption, enemiesWithoutSeedOfCorruption[0]))
                {
                    Thread.Sleep(1000);
                    return;
                }
            }

            if (CurseOfTheElements.KnownSpell &&
                settings.PartyCurseOfTheElements)
            {
                // PARTY Curse of the Elements
                List <WoWUnit> enemiesWithoutCurseOfTheElements = AIOParty.EnemiesFighting
                                                                  .Where(e => !e.HaveBuff("Curse of the Elements"))
                                                                  .OrderBy(e => e.GetDistance)
                                                                  .ToList();
                if (enemiesWithoutCurseOfTheElements.Count > 0 &&
                    AIOParty.EnemiesFighting.Count - enemiesWithoutCurseOfTheElements.Count < 3 &&
                    cast.OnFocusUnit(CurseOfTheElements, enemiesWithoutCurseOfTheElements[0]))
                {
                    return;
                }
            }
            else
            {
                // PARTY Curse of Agony
                List <WoWUnit> enemiesWithoutCurseOfAgony = AIOParty.EnemiesFighting
                                                            .Where(e => !e.HaveBuff("Curse of Agony"))
                                                            .OrderBy(e => e.GetDistance)
                                                            .ToList();
                if (enemiesWithoutCurseOfAgony.Count > 0 &&
                    AIOParty.EnemiesFighting.Count - enemiesWithoutCurseOfAgony.Count < 3 &&
                    cast.OnFocusUnit(CurseOfAgony, enemiesWithoutCurseOfAgony[0]))
                {
                    return;
                }
            }

            // PARTY Unstable Affliction
            List <WoWUnit> enemiesWithoutUnstableAff = AIOParty.EnemiesFighting
                                                       .Where(e => !e.HaveBuff("Unstable Affliction"))
                                                       .OrderBy(e => e.GetDistance)
                                                       .ToList();

            if (enemiesWithoutUnstableAff.Count > 0 &&
                AIOParty.EnemiesFighting.Count - enemiesWithoutUnstableAff.Count < 3 &&
                cast.OnFocusUnit(UnstableAffliction, enemiesWithoutUnstableAff[0]))
            {
                return;
            }

            // PARTY Corruption
            List <WoWUnit> enemiesWithoutCorruption = AIOParty.EnemiesFighting
                                                      .Where(e => !e.HaveBuff("Corruption") && !e.HaveBuff("Seed of Corruption"))
                                                      .OrderBy(e => e.GetDistance)
                                                      .ToList();

            if (enemiesWithoutCorruption.Count > 0 &&
                AIOParty.EnemiesFighting.Count - enemiesWithoutCorruption.Count < 3 &&
                cast.OnFocusUnit(Corruption, enemiesWithoutCorruption[0]))
            {
                return;
            }

            // PARTY Immolate
            List <WoWUnit> enemiesWithoutImmolate = AIOParty.EnemiesFighting
                                                    .Where(e => !e.HaveBuff("Immolate"))
                                                    .OrderBy(e => e.GetDistance)
                                                    .ToList();

            if (enemiesWithoutImmolate.Count > 0 &&
                AIOParty.EnemiesFighting.Count - enemiesWithoutImmolate.Count < 3 &&
                cast.OnFocusUnit(Immolate, enemiesWithoutImmolate[0]))
            {
                return;
            }

            // PARTY Siphon Life
            List <WoWUnit> enemiesWithoutSiphonLife = AIOParty.EnemiesFighting
                                                      .Where(e => !e.HaveBuff("Siphon Life"))
                                                      .OrderBy(e => e.GetDistance)
                                                      .ToList();

            if (enemiesWithoutSiphonLife.Count > 0 &&
                AIOParty.EnemiesFighting.Count - enemiesWithoutSiphonLife.Count < 3 &&
                cast.OnFocusUnit(SiphonLife, enemiesWithoutSiphonLife[0]))
            {
                return;
            }

            // Drain Soul
            bool _shouldDrainSoul = ToolBox.CountItemStacks("Soul Shard") < settings.NumberOfSoulShards || settings.AlwaysDrainSoul;

            if (_shouldDrainSoul &&
                ObjectManager.Target.HealthPercent < settings.DrainSoulHP &&
                ObjectManager.Target.Level >= Me.Level - 8 &&
                !UnitImmunities.Contains(ObjectManager.Target, "Drain Soul(Rank 1)"))
            {
                if (settings.DrainSoulLevel1 &&
                    cast.OnTarget(DrainSoulRank1))
                {
                    return;
                }
                else if (cast.OnTarget(DrainSoul))
                {
                    return;
                }
            }

            // Shadow Bolt
            if (cast.OnTarget(ShadowBolt))
            {
                return;
            }

            // Stop wand if banned
            if (ToolBox.UsingWand() &&
                UnitImmunities.Contains(ObjectManager.Target, "Shoot") &&
                cast.OnTarget(UseWand))
            {
                return;
            }

            // Spell if wand banned
            if (UnitImmunities.Contains(ObjectManager.Target, "Shoot"))
            {
                if (cast.OnTarget(ShadowBolt))
                {
                    return;
                }
            }

            // Use Wand
            if (!ToolBox.UsingWand() &&
                _iCanUseWand &&
                cast.OnTarget(UseWand, false))
            {
                return;
            }
        }
Example #4
0
        protected override void CombatRotation()
        {
            base.CombatRotation();
            WoWUnit Target = ObjectManager.Target;

            // Stop wand use on multipull
            if (_iCanUseWand && ObjectManager.GetNumberAttackPlayer() > 1)
            {
                _iCanUseWand = false;
            }

            // Remove Curse
            if (ToolBox.HasCurseDebuff())
            {
                Thread.Sleep(Main.humanReflexTime);
                if (cast.OnSelf(RemoveCurse))
                {
                    return;
                }
            }

            // Summon Water Elemental
            if (Target.HealthPercent > 95 ||
                ObjectManager.GetNumberAttackPlayer() > 1)
            {
                if (cast.OnSelf(SummonWaterElemental))
                {
                    return;
                }
            }

            // Ice Barrier
            if (IceBarrier.IsSpellUsable &&
                !Me.HaveBuff("Ice Barrier") &&
                cast.OnSelf(IceBarrier))
            {
                return;
            }

            // Mana Shield
            if (!Me.HaveBuff("Mana Shield") &&
                (Me.HealthPercent < 30 && Me.ManaPercentage > 50 ||
                 Me.HealthPercent < 10) &&
                cast.OnSelf(ManaShield))
            {
                return;
            }

            // Cold Snap
            if (ObjectManager.GetNumberAttackPlayer() > 1 &&
                !Me.HaveBuff("Icy Veins") &&
                !IcyVeins.IsSpellUsable &&
                cast.OnSelf(ColdSnap))
            {
                return;
            }

            // Icy Veins
            if (ObjectManager.GetNumberAttackPlayer() > 1 && settings.IcyVeinMultiPull ||
                !settings.IcyVeinMultiPull &&
                cast.OnSelf(IcyVeins))
            {
                return;
            }

            // Use Mana Stone
            if ((ObjectManager.GetNumberAttackPlayer() > 1 && Me.ManaPercentage < 50 || Me.ManaPercentage < 5) &&
                _foodManager.UseManaStone())
            {
                return;
            }

            // Ice Lance
            if ((Target.HaveBuff("Frostbite") || Target.HaveBuff("Frost Nova")) &&
                cast.OnTarget(IceLance))
            {
                return;
            }

            // Frost Nova
            if (Target.GetDistance < 6f &&
                Target.HealthPercent > 10 &&
                !Target.HaveBuff("Frostbite") &&
                _polymorphedEnemy == null &&
                cast.OnSelf(FrostNova))
            {
                return;
            }

            // Fire Blast
            if (Target.HealthPercent <= settings.FireblastThreshold &&
                !Target.HaveBuff("Frostbite") &&
                !Target.HaveBuff("Frost Nova") &&
                cast.OnTarget(FireBlast))
            {
                return;
            }

            // Cone of Cold
            if (Target.GetDistance < 10 &&
                settings.UseConeOfCold &&
                Me.IsFacing(Target.Position, 0.5f) &&
                _polymorphedEnemy == null &&
                cast.OnSelf(ConeOfCold))
            {
                return;
            }

            // Frost Bolt
            if (Me.Level >= 6 &&
                !cast.IsBackingUp &&
                (Target.HealthPercent > settings.WandThreshold || ObjectManager.GetNumberAttackPlayer() > 1 || Me.HealthPercent < 40 || !_iCanUseWand) &&
                cast.OnTarget(Frostbolt))
            {
                return;
            }

            // Low level Frost Bolt
            if ((Target.HealthPercent > 15 || Me.HealthPercent < 50) &&
                Me.Level < 6 &&
                cast.OnTarget(Frostbolt))
            {
                return;
            }

            // Low level FireBall
            if (!Frostbolt.KnownSpell &&
                (Target.HealthPercent > 15 || Me.HealthPercent < 50) &&
                cast.OnTarget(Fireball))
            {
                return;
            }

            // Stop wand if banned
            if (ToolBox.UsingWand() &&
                UnitImmunities.Contains(ObjectManager.Target, "Shoot") &&
                cast.OnTarget(UseWand))
            {
                return;
            }

            // Spell if wand banned
            if (UnitImmunities.Contains(ObjectManager.Target, "Shoot"))
            {
                if (cast.OnTarget(Frostbolt) || cast.OnTarget(Fireball) || cast.OnTarget(ArcaneMissiles))
                {
                    return;
                }
            }

            // Use Wand
            if (!ToolBox.UsingWand() &&
                _iCanUseWand &&
                !cast.IsBackingUp &&
                !MovementManager.InMovement)
            {
                if (cast.OnTarget(UseWand, false))
                {
                    return;
                }
            }

            // Go in melee because nothing else to do
            if (!ToolBox.UsingWand() &&
                !UseWand.IsSpellUsable &&
                !RangeManager.CurrentRangeIsMelee() &&
                !cast.IsBackingUp &&
                Target.IsAlive)
            {
                Logger.Log("Going in melee");
                RangeManager.SetRangeToMelee();
                return;
            }
        }
        protected override void CombatRotation()
        {
            bool    _hasMagicDebuff     = ToolBox.HasMagicDebuff();
            bool    _hasDisease         = ToolBox.HasDiseaseDebuff();
            bool    _hasWeakenedSoul    = ToolBox.HasDebuff("Weakened Soul");
            double  _myManaPC           = Me.ManaPercentage;
            bool    _inShadowForm       = Me.HaveBuff("ShadowForm");
            int     _mindBlastCD        = Lua.LuaDoString <int>("local start, duration, enabled = GetSpellCooldown(\"Mind Blast\"); return start + duration - GetTime();");
            int     _innerFocusCD       = Lua.LuaDoString <int>("local start, duration, enabled = GetSpellCooldown(\"Inner Focus\"); return start + duration - GetTime();");
            bool    _shoulBeInterrupted = ToolBox.TargetIsCasting();
            WoWUnit Target = ObjectManager.Target;

            // Power Word Shield on multi aggro
            if (!Me.HaveBuff("Power Word: Shield") &&
                !_hasWeakenedSoul &&
                ObjectManager.GetNumberAttackPlayer() > 1 &&
                settings.UsePowerWordShield &&
                cast.OnSelf(PowerWordShield))
            {
                return;
            }

            // Power Word Shield
            if (Me.HealthPercent < 50 &&
                !Me.HaveBuff("Power Word: Shield") &&
                !_hasWeakenedSoul &&
                settings.UsePowerWordShield &&
                cast.OnSelf(PowerWordShield))
            {
                return;
            }

            // Renew
            if (Me.HealthPercent < 70 &&
                !Me.HaveBuff("Renew") &&
                !_inShadowForm &&
                (Target.HealthPercent > 15 || Me.HealthPercent < 25) &&
                cast.OnSelf(Renew))
            {
                return;
            }

            // Psychic Scream
            if (Me.HealthPercent < 50 &&
                ObjectManager.GetNumberAttackPlayer() > 1 &&
                cast.OnSelf(PsychicScream))
            {
                return;
            }

            // Flash Heal
            if (Me.HealthPercent < 50 &&
                (Target.HealthPercent > 15 || Me.HealthPercent < 25) &&
                cast.OnSelf(FlashHeal))
            {
                return;
            }

            // Heal
            if (Me.HealthPercent < 50 &&
                (Target.HealthPercent > 15 || Me.HealthPercent < 25) &&
                cast.OnSelf(Heal))
            {
                return;
            }

            // Lesser Heal
            if (Me.HealthPercent < 50 &&
                !FlashHeal.KnownSpell &&
                (Target.HealthPercent > 15 || Me.HealthPercent < 25) &&
                cast.OnSelf(LesserHeal))
            {
                return;
            }

            // Silence
            if (_shoulBeInterrupted)
            {
                Thread.Sleep(Main.humanReflexTime);
                if (cast.OnTarget(Silence))
                {
                    return;
                }
            }

            // Cure Disease
            if (_hasDisease && !_inShadowForm)
            {
                Thread.Sleep(Main.humanReflexTime);
                if (cast.OnSelf(CureDisease))
                {
                    return;
                }
            }

            // Dispel Magic self
            if (_hasMagicDebuff &&
                _myManaPC > 10 &&
                DispelMagic.KnownSpell &&
                DispelMagic.IsSpellUsable &&
                (_dispelTimer.ElapsedMilliseconds > 10000 || _dispelTimer.ElapsedMilliseconds <= 0))
            {
                Thread.Sleep(Main.humanReflexTime);
                if (cast.OnSelf(DispelMagic))
                {
                    return;
                }
            }

            // Vampiric Touch
            if (!Target.HaveBuff("Vampiric Touch") &&
                _myManaPC > _innerManaSaveThreshold &&
                Target.HealthPercent > _wandThreshold &&
                cast.OnTarget(VampiricTouch))
            {
                return;
            }

            // Vampiric Embrace
            if (!Target.HaveBuff("Vampiric Embrace") &&
                _myManaPC > _innerManaSaveThreshold &&
                cast.OnTarget(VampiricEmbrace))
            {
                return;
            }

            // ShadowFiend
            if (ObjectManager.GetNumberAttackPlayer() > 1 &&
                cast.OnTarget(Shadowfiend))
            {
                return;
            }

            // Shadow Word Pain
            if (_myManaPC > 10 &&
                Target.HealthPercent > 15 &&
                !Target.HaveBuff("Shadow Word: Pain") &&
                cast.OnTarget(ShadowWordPain))
            {
                return;
            }

            // Inner Fire
            if (!Me.HaveBuff("Inner Fire") &&
                settings.UseInnerFire &&
                InnerFire.KnownSpell &&
                _myManaPC > _innerManaSaveThreshold &&
                Target.HealthPercent > _wandThreshold &&
                cast.OnSelf(InnerFire))
            {
                return;
            }

            // Shadowguard
            if (!Me.HaveBuff("Shadowguard") &&
                _myManaPC > _innerManaSaveThreshold &&
                settings.UseShadowGuard &&
                Target.HealthPercent > _wandThreshold &&
                cast.OnSelf(Shadowguard))
            {
                return;
            }

            // Shadow Protection
            if (!Me.HaveBuff("Shadow Protection") &&
                _myManaPC > 70 &&
                settings.UseShadowProtection &&
                cast.OnSelf(ShadowProtection))
            {
                return;
            }

            // Devouring Plague
            if (!Target.HaveBuff("Devouring Plague") &&
                Target.HealthPercent > 80 &&
                cast.OnTarget(DevouringPlague))
            {
                return;
            }

            // Shadow Word Death
            if (_myManaPC > _innerManaSaveThreshold &&
                settings.UseShadowWordDeath &&
                Target.HealthPercent < 15 &&
                cast.OnTarget(ShadowWordDeath))
            {
                return;
            }

            // Mind Blast + Inner Focus
            if (!_inShadowForm &&
                _myManaPC > _innerManaSaveThreshold &&
                Target.HealthPercent > 50 &&
                _mindBlastCD <= 0 &&
                (Target.HealthPercent > _wandThreshold || !_iCanUseWand))
            {
                if (InnerFocus.KnownSpell && _innerFocusCD <= 0)
                {
                    cast.OnSelf(InnerFocus);
                }

                if (cast.OnTarget(MindBlast))
                {
                    return;
                }
            }

            // Shadow Form Mind Blast + Inner Focus
            if (_inShadowForm &&
                _myManaPC > _innerManaSaveThreshold &&
                _mindBlastCD <= 0 &&
                Target.HealthPercent > _wandThreshold)
            {
                if (InnerFocus.KnownSpell && _innerFocusCD <= 0)
                {
                    cast.OnSelf(InnerFocus);
                }

                if (cast.OnTarget(MindBlast))
                {
                    return;
                }
            }

            // Mind FLay
            if ((Me.HaveBuff("Power Word: Shield") || !settings.UsePowerWordShield) &&
                _inShadowForm &&
                _myManaPC > _innerManaSaveThreshold &&
                Target.HealthPercent > _wandThreshold &&
                cast.OnTarget(MindFlay))
            {
                return;
            }

            // Low level Smite
            if (Me.Level < 5 && (Target.HealthPercent > 30 || Me.ManaPercentage > 80) &&
                _myManaPC > _innerManaSaveThreshold &&
                cast.OnTarget(Smite))
            {
                return;
            }

            // Smite
            if (!_inShadowForm &&
                _myManaPC > _innerManaSaveThreshold &&
                Me.Level >= 5 &&
                Target.HealthPercent > 20 &&
                (Target.HealthPercent > settings.WandThreshold || !_iCanUseWand) &&
                cast.OnTarget(Smite))
            {
                return;
            }

            // Stop wand if banned
            if (ToolBox.UsingWand() &&
                UnitImmunities.Contains(ObjectManager.Target, "Shoot") &&
                cast.OnTarget(UseWand))
            {
                return;
            }

            // Spell if wand banned
            if (UnitImmunities.Contains(ObjectManager.Target, "Shoot"))
            {
                if (cast.OnTarget(MindBlast) || cast.OnTarget(Smite))
                {
                    return;
                }
            }

            // Use Wand
            if (!ToolBox.UsingWand() &&
                _iCanUseWand &&
                cast.OnTarget(UseWand, false))
            {
                return;
            }

            // Go in melee because nothing else to do
            if (!ToolBox.UsingWand() &&
                !_iCanUseWand &&
                !RangeManager.CurrentRangeIsMelee() &&
                Target.IsAlive)
            {
                Logger.Log("Going in melee");
                RangeManager.SetRangeToMelee();
                return;
            }
        }
        protected override void CombatRotation()
        {
            base.CombatRotation();
            WoWUnit Target = ObjectManager.Target;

            // PARTY Remove Curse
            if (settings.PartyRemoveCurse)
            {
                List <AIOPartyMember> needRemoveCurse = AIOParty.GroupAndRaid
                                                        .FindAll(m => m.InCombatFlagOnly && ToolBox.HasCurseDebuff(m.Name))
                                                        .ToList();
                if (needRemoveCurse.Count > 0 && cast.OnFocusUnit(RemoveCurse, needRemoveCurse[0]))
                {
                    return;
                }
            }

            // Use Mana Stone
            if (Me.ManaPercentage < 20 &&
                _foodManager.UseManaStone())
            {
                return;
            }

            // Evocation
            if (Me.ManaPercentage < 20 &&
                AIORadar.CloseUnitsTargetingMe.Count <= 0 &&
                cast.OnSelf(Evocation))
            {
                Usefuls.WaitIsCasting();
                return;
            }

            // Dragon's Breath
            if (ToolBox.GetNbEnemiesClose(10f) > 2 &&
                cast.OnSelf(DragonsBreath))
            {
                return;
            }

            // Blast Wave
            if (ToolBox.GetNbEnemiesClose(10f) > 2 &&
                cast.OnSelf(BlastWave))
            {
                return;
            }

            // Icy Veins
            if (Target.HealthPercent < 100 &&
                Me.ManaPercentage > 10 &&
                cast.OnSelf(IcyVeins))
            {
                return;
            }

            // Arcane Power
            if (Target.HealthPercent < 100 &&
                Me.ManaPercentage > 10 &&
                cast.OnSelf(ArcanePower))
            {
                return;
            }

            // Presence of Mind
            if (!Me.HaveBuff("Presence of Mind") &&
                Target.HealthPercent < 100 &&
                cast.OnSelf(PresenceOfMind))
            {
                return;
            }
            if (Me.HaveBuff("Presence of Mind"))
            {
                if (cast.OnTarget(Fireball) || cast.OnTarget(Frostbolt))
                {
                    Usefuls.WaitIsCasting();
                    return;
                }
            }

            // Cold Snap
            if (IcyVeins.GetCurrentCooldown > 0 &&
                Me.ManaPercentage > 10 &&
                !Me.HaveBuff(IcyVeins.Name) &&
                cast.OnSelf(ColdSnap))
            {
                return;
            }

            // Scorch first
            int wantedScorchCount      = Target.IsBoss ? 5 : 2;
            int nbScorchDebuffOnTarget = ToolBox.CountDebuff("Fire Vulnerability", "target");

            if (_knowImprovedScorch &&
                (nbScorchDebuffOnTarget < wantedScorchCount) &&
                cast.OnTarget(Scorch))
            {
                return;
            }

            // Scorch renewal
            if (_knowImprovedScorch &&
                (nbScorchDebuffOnTarget >= wantedScorchCount && ToolBox.DeBuffTimeLeft("Fire Vulnerability", "target") < 10) &&
                cast.OnTarget(Scorch))
            {
                Thread.Sleep(1000);
                return;
            }

            // Combustion
            if (!Me.HaveBuff("Combustion") &&
                Combustion.GetCurrentCooldown <= 0 &&
                ToolBox.DeBuffTimeLeft("Fire Vulnerability", "target") > 20 &&
                ToolBox.CountDebuff("Fire Vulnerability", "target") >= wantedScorchCount &&
                cast.OnSelf(Combustion))
            {
                return;
            }

            // Fire Blast
            if (!_knowImprovedScorch &&
                cast.OnTarget(FireBlast))
            {
                return;
            }

            // Fireball
            if (cast.OnTarget(Fireball))
            {
                return;
            }


            // Stop wand if banned
            if (ToolBox.UsingWand() &&
                UnitImmunities.Contains(ObjectManager.Target, "Shoot") &&
                cast.OnTarget(UseWand))
            {
                return;
            }

            // Spell if wand banned
            if (UnitImmunities.Contains(ObjectManager.Target, "Shoot"))
            {
                if (cast.OnTarget(Frostbolt) || cast.OnTarget(Fireball) || cast.OnTarget(ArcaneBlast) || cast.OnTarget(ArcaneMissiles))
                {
                    return;
                }
            }

            // Use Wand
            if (!ToolBox.UsingWand() &&
                _iCanUseWand &&
                !cast.IsBackingUp &&
                !MovementManager.InMovement &&
                cast.OnTarget(UseWand, false))
            {
                return;
            }
        }
        protected override void CombatRotation()
        {
            base.CombatRotation();

            WoWUnit Me                    = ObjectManager.Me;
            WoWUnit Target                = ObjectManager.Target;
            double  _myManaPC             = Me.ManaPercentage;
            bool    _overLowManaThreshold = _myManaPC > _innerManaSaveThreshold;

            // Drain Soul
            bool _shouldDrainSoul = ToolBox.CountItemStacks("Soul Shard") < settings.NumberOfSoulShards || settings.AlwaysDrainSoul;

            if (_shouldDrainSoul &&
                ObjectManager.Target.HealthPercent < settings.DrainSoulHP &&
                ObjectManager.Target.Level >= Me.Level - 8 &&
                !UnitImmunities.Contains(ObjectManager.Target, "Drain Soul(Rank 1)"))
            {
                if (settings.DrainSoulLevel1 &&
                    cast.OnTarget(DrainSoulRank1))
                {
                    return;
                }
                else if (cast.OnTarget(DrainSoul))
                {
                    return;
                }
            }

            // How of Terror
            if (ToolBox.GetNumberEnemiesAround(10f, Me) > 1 &&
                cast.OnSelf(HowlOfTerror))
            {
                return;
            }

            // Use Health Stone
            if (Me.HealthPercent < 15)
            {
                WarlockPetAndConsumables.UseHealthstone();
            }

            // Shadow Trance
            if (Me.HaveBuff("Shadow Trance") &&
                _overLowManaThreshold &&
                cast.OnTarget(ShadowBolt))
            {
                return;
            }

            // Siphon Life
            if (Me.HealthPercent < 90 &&
                _overLowManaThreshold &&
                Target.HealthPercent > 20 &&
                !Target.HaveBuff("Siphon Life") &&
                settings.UseSiphonLife &&
                cast.OnTarget(SiphonLife))
            {
                return;
            }

            // Death Coil
            if (Me.HealthPercent < 20 &&
                cast.OnTarget(DeathCoil))
            {
                return;
            }

            // Drain Life low
            if (Me.HealthPercent < 30 &&
                Target.HealthPercent > 20 &&
                cast.OnTarget(DrainLife))
            {
                return;
            }

            // Curse of Agony
            if (!Target.HaveBuff("Curse of Agony") &&
                _overLowManaThreshold &&
                Target.HealthPercent > 20 &&
                cast.OnTarget(CurseOfAgony))
            {
                return;
            }

            // Unstable Affliction
            if (!Target.HaveBuff("Unstable Affliction") &&
                _overLowManaThreshold &&
                Target.HealthPercent > 30 &&
                cast.OnTarget(UnstableAffliction))
            {
                return;
            }

            // Corruption
            if (!Target.HaveBuff("Corruption") &&
                _overLowManaThreshold &&
                Target.HealthPercent > 20 &&
                cast.OnTarget(Corruption))
            {
                return;
            }

            // Immolate
            if (!Target.HaveBuff("Immolate") &&
                !ObjectManager.Target.HaveBuff("Fire Ward") &&
                _overLowManaThreshold &&
                Target.HealthPercent > 30 &&
                (settings.UseImmolateHighLevel || !UnstableAffliction.KnownSpell) &&
                cast.OnTarget(Immolate))
            {
                return;
            }

            // Drain Life high
            if (Me.HealthPercent < 70 &&
                Target.HealthPercent > 20 &&
                cast.OnTarget(DrainLife))
            {
                return;
            }

            // Health Funnel
            if (ObjectManager.Pet.IsValid &&
                ObjectManager.Pet.HealthPercent < 30 &&
                Me.HealthPercent > 30)
            {
                if (RangeManager.GetRange() > 19)
                {
                    RangeManager.SetRange(19f);
                }
                if (HealthFunnel.IsDistanceGood && cast.OnTarget(HealthFunnel))
                {
                    return;
                }
            }

            // Dark Pact
            if (Me.ManaPercentage < 70 &&
                ObjectManager.Pet.Mana > 0 &&
                ObjectManager.Pet.ManaPercentage > 60 &&
                settings.UseDarkPact &&
                cast.OnSelf(DarkPact))
            {
                return;
            }

            // Drain Mana
            if (Me.ManaPercentage < 70 &&
                Target.Mana > 0 &&
                Target.ManaPercentage > 30 &&
                cast.OnTarget(DrainMana))
            {
                return;
            }

            // Incinerate
            if (Target.HaveBuff("Immolate") &&
                _overLowManaThreshold &&
                Target.HealthPercent > 30 &&
                settings.UseIncinerate &&
                cast.OnTarget(Incinerate))
            {
                return;
            }

            // Shadow Bolt
            if ((!settings.PrioritizeWandingOverSB || !_iCanUseWand) &&
                (ObjectManager.Target.HealthPercent > 50 || Me.ManaPercentage > 90 && ObjectManager.Target.HealthPercent > 10) &&
                _myManaPC > 40 &&
                cast.OnTarget(ShadowBolt))
            {
                return;
            }

            // Life Tap
            if (Me.HealthPercent > 50 &&
                Me.ManaPercentage < 40 &&
                !ObjectManager.Target.IsTargetingMe &&
                settings.UseLifeTap &&
                cast.OnSelf(LifeTap))
            {
                return;
            }

            // Stop wand if banned
            if (ToolBox.UsingWand() &&
                UnitImmunities.Contains(ObjectManager.Target, "Shoot") &&
                cast.OnTarget(UseWand))
            {
                return;
            }

            // Spell if wand banned
            if (UnitImmunities.Contains(ObjectManager.Target, "Shoot") &&
                cast.OnTarget(ShadowBolt))
            {
                return;
            }

            // Use Wand
            if (!ToolBox.UsingWand() &&
                _iCanUseWand &&
                cast.OnTarget(UseWand, false))
            {
                return;
            }

            // Go in melee because nothing else to do
            if (!ToolBox.UsingWand() &&
                !UseWand.IsSpellUsable &&
                !RangeManager.CurrentRangeIsMelee() &&
                Target.IsAlive)
            {
                Logger.Log("Going in melee");
                RangeManager.SetRangeToMelee();
                return;
            }
        }
Example #8
0
        protected override void CombatRotation()
        {
            base.CombatRotation();
            Lua.LuaDoString("PetAttack();", false);
            WoWUnit Target = ObjectManager.Target;

            // PARTY Remove Curse
            if (settings.PartyRemoveCurse)
            {
                List <AIOPartyMember> needRemoveCurse = AIOParty.GroupAndRaid
                                                        .FindAll(m => ToolBox.HasCurseDebuff(m.Name))
                                                        .ToList();
                if (needRemoveCurse.Count > 0 && cast.OnFocusUnit(RemoveCurse, needRemoveCurse[0]))
                {
                    return;
                }
            }

            // Use Mana Stone
            if (Me.ManaPercentage < 20 &&
                _foodManager.UseManaStone())
            {
                return;
            }

            // Evocation
            if (Me.ManaPercentage < 20 &&
                AIORadar.CloseUnitsTargetingMe.Count <= 0 &&
                cast.OnSelf(Evocation))
            {
                Usefuls.WaitIsCasting();
                return;
            }

            // Arcane Explosion
            if (ToolBox.GetNbEnemiesClose(8f) > 2 &&
                AIORadar.CloseUnitsTargetingMe.Count <= 0 &&
                Me.Mana > 10 &&
                cast.OnSelf(ArcaneExplosion))
            {
                return;
            }

            // Icy Veins
            if (Target.HealthPercent < 100 &&
                Me.ManaPercentage > 10 &&
                cast.OnSelf(IcyVeins))
            {
                return;
            }

            // Arcane Power
            if (Target.HealthPercent < 100 &&
                Me.ManaPercentage > 10 &&
                cast.OnSelf(ArcanePower))
            {
                return;
            }

            // Presence of Mind
            if (!Me.HaveBuff("Presence of Mind") &&
                Target.HealthPercent < 100 &&
                cast.OnSelf(PresenceOfMind))
            {
                return;
            }
            if (Me.HaveBuff("Presence of Mind"))
            {
                if (cast.OnTarget(ArcaneBlast) || cast.OnTarget(Frostbolt))
                {
                    Usefuls.WaitIsCasting();
                    return;
                }
            }

            // Cold Snap
            if (IcyVeins.GetCurrentCooldown > 0 &&
                Me.ManaPercentage > 10 &&
                !Me.HaveBuff(IcyVeins.Name) &&
                cast.OnSelf(ColdSnap))
            {
                return;
            }

            // Slow
            if (Target.CreatureTypeTarget == "Humanoid" &&
                !Target.HaveBuff("Slow") &&
                Target.HealthPercent < 10 &&
                Me.ManaPercentage > 10 &&
                cast.OnTarget(Slow))
            {
                return;
            }

            int  arcaneBlastDebuffCount = ToolBox.CountDebuff("Arcane Blast");
            bool _shouldCastArcaneBlast =
                ArcaneBlast.KnownSpell &&
                (Me.ManaPercentage > 70 ||
                 Me.HaveBuff("Clearcasting") ||
                 (Me.ManaPercentage > 50 && arcaneBlastDebuffCount < 3) ||
                 (Me.ManaPercentage > 35 && arcaneBlastDebuffCount < 2) ||
                 (arcaneBlastDebuffCount < 1));

            // Arcane Blast
            if (_shouldCastArcaneBlast &&
                cast.OnTarget(ArcaneBlast))
            {
                return;
            }

            // Frost Bolt
            if (cast.OnTarget(Frostbolt))
            {
                return;
            }

            // Stop wand if banned
            if (ToolBox.UsingWand() &&
                UnitImmunities.Contains(ObjectManager.Target, "Shoot") &&
                cast.OnTarget(UseWand))
            {
                return;
            }

            // Spell if wand banned
            if (UnitImmunities.Contains(ObjectManager.Target, "Shoot"))
            {
                if (cast.OnTarget(ArcaneBlast) || cast.OnTarget(ArcaneMissiles) || cast.OnTarget(Frostbolt) || cast.OnTarget(Fireball))
                {
                    return;
                }
            }

            // Use Wand
            if (!ToolBox.UsingWand() &&
                _iCanUseWand &&
                !cast.IsBackingUp &&
                !MovementManager.InMovement &&
                cast.OnTarget(UseWand, false))
            {
                return;
            }
        }
        protected override void CombatRotation()
        {
            base.CombatRotation();
            Lua.LuaDoString("PetAttack();", false);
            WoWUnit Target = ObjectManager.Target;

            // Stop wand use on multipull
            if (_iCanUseWand && ObjectManager.GetNumberAttackPlayer() > 1)
            {
                _iCanUseWand = false;
            }

            // Remove Curse
            if (ToolBox.HasCurseDebuff())
            {
                Thread.Sleep(Main.humanReflexTime);
                if (cast.OnSelf(RemoveCurse))
                {
                    return;
                }
            }

            // Mana Shield
            if (!Me.HaveBuff("Mana Shield") &&
                (Me.HealthPercent < 30 && Me.ManaPercentage > 50 ||
                 Me.HealthPercent < 10) &&
                cast.OnSelf(ManaShield))
            {
                return;
            }

            // Use Mana Stone
            if ((ObjectManager.GetNumberAttackPlayer() > 1 && Me.ManaPercentage < 50 || Me.ManaPercentage < 5) &&
                _foodManager.UseManaStone())
            {
                return;
            }

            // Cast presence of mind spell
            if (Me.HaveBuff("Presence of Mind"))
            {
                if (cast.OnTarget(ArcaneBlast) || cast.OnTarget(Fireball))
                {
                    Usefuls.WaitIsCasting();
                    return;
                }
            }

            // Presence of Mind
            if (!Me.HaveBuff("Presence of Mind") &&
                (ObjectManager.GetNumberAttackPlayer() > 1 || !settings.PoMOnMulti) &&
                Target.HealthPercent > 50 &&
                cast.OnSelf(PresenceOfMind))
            {
                return;
            }

            // Arcane Power
            if (!Me.HaveBuff("Arcane Power") &&
                (ObjectManager.GetNumberAttackPlayer() > 1 || !settings.ArcanePowerOnMulti) &&
                Target.HealthPercent > 50 &&
                cast.OnSelf(ArcanePower))
            {
                return;
            }

            // Slow
            if ((settings.ACSlow || Target.CreatureTypeTarget == "Humanoid") &&
                !Target.HaveBuff("Slow") &&
                cast.OnTarget(Slow))
            {
                return;
            }

            // Cone of Cold
            if (Target.GetDistance < 10 &&
                settings.UseConeOfCold &&
                _polymorphedEnemy == null &&
                cast.OnTarget(ConeOfCold))
            {
                return;
            }

            // Fire Blast
            if (Target.HealthPercent <= settings.FireblastThreshold &&
                _polymorphedEnemy == null &&
                cast.OnTarget(FireBlast))
            {
                return;
            }

            bool _shouldCastArcaneBlast =
                ArcaneBlast.KnownSpell &&
                (Me.ManaPercentage > 70 ||
                 Me.HaveBuff("Clearcasting") ||
                 (Me.ManaPercentage > 50 && ToolBox.CountDebuff("Arcane Blast") < 3) ||
                 (Me.ManaPercentage > 35 && ToolBox.CountDebuff("Arcane Blast") < 2));

            // Arcane Blast
            if (_shouldCastArcaneBlast &&
                (Target.HealthPercent > settings.WandThreshold || !_iCanUseWand) &&
                cast.OnTarget(ArcaneBlast))
            {
                return;
            }

            // Arcane Missiles
            if (Me.Level >= 6 &&
                (Target.HealthPercent > settings.WandThreshold || ObjectManager.GetNumberAttackPlayer() > 1 || Me.HealthPercent < 40 || !_iCanUseWand) &&
                cast.OnTarget(ArcaneMissiles))
            {
                return;
            }

            // Frost Bolt
            if (Me.Level >= 6 &&
                (Target.HealthPercent > settings.WandThreshold || ObjectManager.GetNumberAttackPlayer() > 1 || Me.HealthPercent < 40 || !_iCanUseWand) &&
                _polymorphedEnemy == null &&
                cast.OnTarget(Frostbolt))
            {
                return;
            }

            // Low level Frost Bolt
            if ((Target.HealthPercent > 15 || Me.HealthPercent < 50) &&
                Me.Level < 6 &&
                cast.OnTarget(Frostbolt))
            {
                return;
            }

            // Low level FireBall
            if (!Frostbolt.KnownSpell &&
                (Target.HealthPercent > 15 || Me.HealthPercent < 50) &&
                cast.OnTarget(Fireball))
            {
                return;
            }

            // Stop wand if banned
            if (ToolBox.UsingWand() &&
                UnitImmunities.Contains(ObjectManager.Target, "Shoot") &&
                cast.OnTarget(UseWand))
            {
                return;
            }

            // Spell if wand banned
            if (UnitImmunities.Contains(ObjectManager.Target, "Shoot"))
            {
                if (cast.OnTarget(ArcaneBlast) || cast.OnTarget(ArcaneMissiles) || cast.OnTarget(Frostbolt) || cast.OnTarget(Fireball))
                {
                    return;
                }
            }

            // Use Wand
            if (!ToolBox.UsingWand() &&
                _iCanUseWand &&
                !cast.IsBackingUp &&
                !MovementManager.InMovement &&
                cast.OnTarget(UseWand, false))
            {
                return;
            }

            // Go in melee because nothing else to do
            if (!ToolBox.UsingWand() &&
                !UseWand.IsSpellUsable &&
                !RangeManager.CurrentRangeIsMelee() &&
                !cast.IsBackingUp &&
                Target.IsAlive)
            {
                Logger.Log("Going in melee");
                RangeManager.SetRangeToMelee();
                return;
            }
        }
        protected override void CombatRotation()
        {
            base.CombatRotation();
            WoWUnit Target = ObjectManager.Target;

            // PARTY Remove Curse
            if (settings.PartyRemoveCurse)
            {
                List <AIOPartyMember> needRemoveCurse = AIOParty.GroupAndRaid
                                                        .FindAll(m => ToolBox.HasCurseDebuff(m.Name))
                                                        .ToList();
                if (needRemoveCurse.Count > 0 && cast.OnFocusUnit(RemoveCurse, needRemoveCurse[0]))
                {
                    return;
                }
            }

            // Ice Barrier
            if (Me.HealthPercent < 50 &&
                cast.OnSelf(IceBarrier))
            {
                return;
            }

            // Ice Lance
            if ((Target.HaveBuff("Frostbite") || Target.HaveBuff("Frost Nova")) &&
                cast.OnTarget(IceLance))
            {
                return;
            }

            // Use Mana Stone
            if (Me.ManaPercentage < 20 &&
                _foodManager.UseManaStone())
            {
                return;
            }

            // Evocation
            if (Me.ManaPercentage < 15 &&
                AIORadar.CloseUnitsTargetingMe.Count <= 0 &&
                cast.OnSelf(Evocation))
            {
                Usefuls.WaitIsCasting();
                return;
            }

            // Cone of Cold
            if (ToolBox.GetNbEnemiesClose(10f) > 2 &&
                cast.OnTarget(ConeOfCold))
            {
                return;
            }

            // Icy Veins
            if (Target.HealthPercent < 100 &&
                Me.ManaPercentage > 10 &&
                !SummonWaterElemental.IsSpellUsable &&
                cast.OnSelf(IcyVeins))
            {
                return;
            }

            // Arcane Power
            if (Target.HealthPercent < 100 &&
                Me.ManaPercentage > 10 &&
                cast.OnSelf(ArcanePower))
            {
                return;
            }

            // Presence of Mind
            if (!Me.HaveBuff("Presence of Mind") &&
                Target.HealthPercent < 100 &&
                cast.OnSelf(PresenceOfMind))
            {
                return;
            }
            if (Me.HaveBuff("Presence of Mind"))
            {
                if (cast.OnTarget(ArcaneBlast) || cast.OnTarget(Frostbolt))
                {
                    Usefuls.WaitIsCasting();
                    return;
                }
            }

            // Cold Snap
            if (SummonWaterElemental.GetCurrentCooldown > 0 &&
                !ObjectManager.Pet.IsValid &&
                Me.ManaPercentage > 10 &&
                !Me.HaveBuff(IcyVeins.Name) &&
                cast.OnSelf(ColdSnap))
            {
                return;
            }

            // Summon Water Elemental
            if (cast.OnSelf(SummonWaterElemental))
            {
                return;
            }

            // FrostBolt
            if (cast.OnTarget(Frostbolt))
            {
                return;
            }

            // Stop wand if banned
            if (ToolBox.UsingWand() &&
                UnitImmunities.Contains(ObjectManager.Target, "Shoot") &&
                cast.OnTarget(UseWand))
            {
                return;
            }

            // Spell if wand banned
            if (UnitImmunities.Contains(ObjectManager.Target, "Shoot"))
            {
                if (cast.OnTarget(ArcaneBlast) || cast.OnTarget(ArcaneMissiles) || cast.OnTarget(Frostbolt) || cast.OnTarget(Fireball))
                {
                    return;
                }
            }

            // Use Wand
            if (!ToolBox.UsingWand() &&
                _iCanUseWand &&
                !cast.IsBackingUp &&
                !MovementManager.InMovement)
            {
                if (cast.OnTarget(UseWand, false))
                {
                    return;
                }
            }
        }